Compare commits

...
192 Commits
Author SHA1 Message Date
alufolie91 36d1f59114 correct map issues clientside
but be loud about it instead of I_Error´ing
most of those would be fatal anyways, so screw vanilla desyncing if they crash eitherways
2026-06-22 20:50:32 +02:00
entryway 99d49adad5 Check for blockmap overflow in P_BlockLinesIterator. Under RANGECHECK define. 2026-06-20 18:55:01 +02:00
alufolie91 6267e1a062 just set backsector to NULL
if not in vanilla doom compat mode/overflow emulation GetSectorAtNullAddress will just return NULL, so we can do so aswell
2026-06-19 19:08:14 +02:00
alufolie91 051bb528a6 add flag "COMPAT_VANILLA"
undefine to enable features that are not vanilla compatible
2026-06-19 19:08:11 +02:00
alufolie91 a95c9bf6ee port more checks from dsda-doom for invalid map data
decided to have it i_error for now, not sure what exactly is the best approach here
should we just "correct" some of those instead?
vanilla probably just crashes anyways
2026-06-19 16:54:58 +02:00
alufolie91 d74ebda83e replace non valid sidenum magic number
with what dsda-doom uses
2026-06-19 16:54:55 +02:00
alufolie91 b575c288fa allow page up/down to scroll through chat
like in console
2026-06-18 17:31:36 +02:00
indev f9a6702219 Fix player node staying muted when player leaves 2026-06-18 17:28:27 +03:00
indev cfda853e6f Add console variant for mute command, also fix it applying mute for players that are not in game 2026-06-18 16:35:48 +03:00
alufolie91 14ac3ca9b0 ;;... 2026-06-16 20:05:12 +02:00
alufolie91 e94fecf56d cleanup even more style issues
also should fix R_InitSprites printing the wrong spritename in some cases
2026-06-16 19:08:04 +02:00
alufolie91 51d9aa6197 add credit to bayer dither shader sources
completely forgot about this (sry!)
the original implementation was mostly based on hughsk´s 8x8 bayer shader while the current is mostly adapted from the libretro 4x4 bayer shader
2026-06-16 12:32:02 +02:00
alufolie91 96a29abc62 move this back
might change behavior of this, which may desynch in rare cases
2026-06-15 14:53:59 +02:00
alufolie91 fa1b797a44 handle interrupt signals during CONS_Error
also move stuff into smol inline function
2026-06-15 14:51:35 +02:00
alufolie91 e1061ab4b4 add PARANOIA cases for reject and blockmap stuff
also see comment
2026-06-13 15:11:41 +02:00
alufolie91 ab0d071d35 use sizeu1 instead of %lu
windoze.......
2026-06-13 13:41:06 +02:00
alufolie91 8129b89034 port P_VerifyBlockMap from dsda-doom
to check for blockmap issues that might cause crashes
2026-06-13 13:37:21 +02:00
alufolie91 14aaba7a87 make reject matrix print an error instead of warning
better on 2nd thought as this may crash vanilla clients that use nametags
2026-06-13 13:20:54 +02:00
alufolie91 2c1bb6c268 smol optimize fof checks in P_CheckSight
check if fof is solid before height comparisons, also split initial height comparisons to save on some height checks in some cases
2026-06-13 13:20:51 +02:00
alufolie91 cc6437285f check for missized rejectmatrix´s on load, pad them if needed
this is what dsda-doom/prboom does
ensures we wont crash from oob reads and makes us print a warning
2026-06-13 13:00:00 +02:00
indev b24f6683b7 Use SKINCOLOR_NONE for ROULETTECOLOR_NONE instead of TC_DEFAULT 2026-06-13 02:25:43 +03:00
indev 5f559af29c Add more options to roulettecolor 2026-06-13 02:12:23 +03:00
indev eef1c55549 Add option for item roulette to use 'local' colors instead of player color 2026-06-13 01:40:14 +03:00
alufolie91 3c227ec532 P_CheckSight: fix rare overflow in rejectmatrix check
didnt think this could overflow here but well it does
wish there was a better way to bounds check heap arrays in C
2026-06-12 22:06:57 +02:00
indev 50f839e1ad Fix JoyAxis and InputDown inputs being off by one, this fixes lookback only working for p1 (ty lug <3) 2026-06-12 16:47:55 +03:00
indev 8db399be9b Allow lookback in replays (currently only works for player 1) 2026-06-12 16:38:32 +03:00
alufolie91 8cb321993e restore functionality to set zipper/speed pad sounds
set using the front side upper texture field like the play sound special per "DSXXXX"
the parsing part already was there but not the actual code to make it use the specified sound for some reason lul
shouldnt break anything and is vanilla compatible!
2026-06-08 10:04:14 +02:00
alufolie91 b4cad08ad3 cleanup p_spec/p_setup a bit 2026-06-08 09:44:36 +02:00
alufolie91 fa899d3970 fix a few more style issues 2026-06-07 07:07:56 +02:00
alufolie91 b955fdb47d cleanup s_sound a little 2026-06-05 23:07:29 +02:00
James R 4686e8e112 Do not play invalid sfx 2026-06-05 23:07:26 +02:00
alufolie91 667c67a61a also avoid strcpy for PutFileNeeded 2026-06-05 20:43:37 +02:00
alufolie91 df9a23a6c7 CL_CheckFiles: avoid using strcpy
wadfile->filename has not a fixed size, so it theoretically might be bigger than wadfilename buffer
this probably wont ever happen but better be safe than sorry honestly
2026-06-05 20:20:38 +02:00
alufolie91 a3f557f4df SV_SendFile: check if I_GetNodeAddress is set before use 2026-06-05 20:07:43 +02:00
alufolie91 1ac029edc6 optimize CL_CheckFiles a bit
the "already loaded" check will not first compare the md5sum, which is a very simple memcmp, and only then it will do string copies, nameonly mutation and name compare should the md5sum match
this should save quite a few unnecessary string operations since the md5 match case will rarely ever hit
2026-06-05 20:07:43 +02:00
alufolie91 761766d353 whitespace fix 2026-06-05 16:19:02 +02:00
alufolie91 72d3360711 delet this
this doesent exist anymore lol
2026-06-05 15:59:55 +02:00
alufolie91 ac52ec2c48 print netcmd name for SendNetXCmdForPlayer warnings
makes those prints a little more useful for debug
2026-06-05 14:50:46 +02:00
alufolie91 956bc3f7df hw renderer cleanups from lugstuff branch
mostly just code dedupe with ceepeepee lambdas
had checked in the past those didnt cause any real noticeable perf changes
2026-06-05 13:07:57 +02:00
alufolie91 746a8cec8b hw_main: make HWR_SkyWallList_Add realloc check a little safer
stuff like that should always be checked per equals/greater than just equals
in practice this shouldnt have caused any issues but its just better practice to check for greater
2026-06-05 12:21:27 +02:00
alufolie91 f7a32b5f85 init "savegamename"
global that was missed
2026-06-04 09:21:38 +02:00
alufolie91 bd30ab8fb7 delet JoyType_t
palyer[sic]......
2026-06-04 09:21:36 +02:00
alufolie91 4140f93e41 update pingdisplay only once per second
this will make sense later......
2026-06-04 09:21:33 +02:00
alufolie91 8ae6f71578 bunch of smaller optimizations and cleanups
mostly avoiding needless work as per usual
2026-06-02 11:31:56 +02:00
alufolie91 d5083ac66c cleanup and split K_MoveKartPlayer
item stuff split into K_PlayerItemThink
2026-06-02 11:24:49 +02:00
alufolie91 62be792a0d cleanup K_KartDrift a bit 2026-06-02 11:23:47 +02:00
alufolie91 c34346cb9a Saturn Icon for mac 2026-05-30 07:29:30 +02:00
alufolie91 d7803ecdcf fix cmake build 2026-05-30 06:05:52 +02:00
alufolie91 1a2a487a93 change cmake title to "Saturn" 2026-05-30 05:42:54 +02:00
alufolie91 bed6306cdf p_sight: let P_CrossSubsecPolyObj also use "fast" P_DivlineCrossed
for P_CheckSight on polyobjects
2026-05-30 05:42:51 +02:00
alufolie91 7521b3abd2 tiny optimize PIT_RadiusAttack in some cases
by checking simpler things before distance checks which may avoid two P_AproxDistance/FixedHypot calls
2026-05-30 05:42:48 +02:00
alufolie91 58d5bab181 tiny optimization K_SpawnKartMissile
by avoiding "min/max" reevaluation
2026-05-30 05:42:46 +02:00
alufolie91 2bffe443ed simplify analogue throwdir stuff in K_drawInput 2026-05-25 17:11:18 +02:00
alufolie91 261c02f4b6 few more hw_ file cleanups 2026-05-22 23:12:56 +02:00
Alug d59ac7d01b fix weird gap in opengl options menu 2026-05-20 19:03:41 +02:00
indev ac86f36186 Skip empty lines in renderer.txt 2026-05-18 20:32:59 +03:00
alufolie91 b5c7fd5a2b HWR_Subsector: check for sub->polyList instead of numpolys
numpolys sometimes might not get reset, checking for sub->polyList is what was actually intended
2026-05-18 18:21:00 +02:00
alufolie91 da103f54d6 hw_main: reorder plane stuff in HWR_Subsector
check for subsector validcount first, then if its a sky plane
so we can skip checking sector heights for sky planes, which may save a bit of maths on maps with many slopes
2026-05-18 18:20:58 +02:00
alufolie91 f82d138482 cleanup some things 2026-05-15 13:00:30 +02:00
alufolie91 e7332a3efe Revert "Blua: implementation of fast track for gettable operations"
This reverts commit e4e51f0f80.
2026-05-15 11:54:10 +02:00
alufolie91 bd27a62769 Revert "Blua: fast track for 'settable'"
This reverts commit bdae0ef4ae.
2026-05-15 11:53:59 +02:00
alufolie91 2b650e4b61 Revert "Blua: 'Protect' in table operations is not needed in the fast track"
This reverts commit 537a50b9b3.
2026-05-15 11:53:53 +02:00
alufolie91 8e82256827 Revert "Blua: 'luaV_fastget' only treats the real fast case (table with a non-nil value at given key, so that it does not need to check metamethods)"
This reverts commit 019812db08.
2026-05-15 11:53:46 +02:00
alufolie91 4fa937728b Revert "Blua: OP_SELF can use 'luaV_fastget' specialized for strings, as it is applied only to string keys"
This reverts commit 0fb752b745.
2026-05-15 11:53:42 +02:00
alufolie91 9f9e6450f2 Revert "Blua: opcode OP_SELF operate only with string keys, so they can use fast-track table access"
This reverts commit 7684e6aa07.
2026-05-15 11:53:33 +02:00
alufolie91 1c75dd0401 Revert "blua: fix copy paste error for "slow path" in auxgetstr/lua_getfield"
This reverts commit b652d802f5.
2026-05-15 11:53:26 +02:00
alufolie91 e854096ca0 revert back to number based player names fallbacks
well need our player 1-16 not player a-z :chonkbuncle:
2026-05-15 03:11:52 +02:00
toaster 83a60ea857 Some fixes for bad player info on joining servers.
* Don't overwrite the first player's name when joining with multiple local splitscreen players. (resolves #151)
* The defaults for unprovided names are now consistently "Player A/B/C/D" as opposed to some being letter-based and some being number-based.
* Send local player info once per local splitscreen player, rather than n^2 times (where n is the number of local splitscreen players).
* Since the packet *requires* four names to be sent every time you join a server, send dummy names for local splitscreen players who aren't connecting, instead of your actual cvars (no data leakage you didn't ask for!)
2026-05-15 03:11:03 +02:00
toaster 3d9d14b353 EnsurePlayerNameIsGood: Remove trailing whitespace, instead of just failing on it
Interesting error with its recursive duplication resolving exposed by the previous commit!
2026-05-15 03:11:00 +02:00
alufolie91 24c9f88262 make snacpending error print player number
bit more informative :chaosleep:
2026-05-15 01:28:02 +02:00
alufolie91 b652d802f5 blua: fix copy paste error for "slow path" in auxgetstr/lua_getfield
lets hope this fixes the random crashes from gc sometime
stimky from https://github.com/Indev450/SRB2Kart-Saturn/pull/223/changes/e4e51f0f80fb7deb9213c72bb374d0a7e4c3f03b
2026-05-15 01:09:19 +02:00
alufolie91 459beeb000 fix oopsie from https://github.com/Indev450/SRB2Kart-Saturn/commit/093ed023ef36bb2e8608116ef39d7710366ccf84 2026-05-15 00:36:36 +02:00
indev a28d798189 Remove some redundant mo != NULL asserts if they are followed by !P_MobjWasRemoved(mo) asserts 2026-05-15 01:24:14 +03:00
indev e75a696ee5 Remove outdated PARANOIA assert in P_SetMobjState, it uses P_SetPlayerMobjState automatically for players now 2026-05-15 01:06:04 +03:00
alufolie91 e113027ce6 d_netcmd: fix snacpending stuff
also move all of it behind PARANOIA define, since nothing else was using it eitherway
2026-05-14 21:25:53 +02:00
alufolie91 2ce4e866e3 reorder seg_t struct a bit
fixes a 4byte hole so we can fit everything important into cacheline 1
even when compiled without HWRENDER this should be a better layout
checked per pahole
2026-05-14 18:56:43 +02:00
alufolie91 55a57a1036 fix checking for fbo completeness too early
this should come after everything apparently
all this shit really needs to be cleaned up again
2026-05-12 21:02:15 +02:00
alufolie91 6aabdc86c0 P_TryMove: reduce the amount of R_PointInSubsector per call
and also P_PlayerTouchingSectorSpecial
since either are in a loop that often runs multiple times per call
improves perf a bit per usual testing
2026-05-12 15:38:43 +02:00
indev 9aaa7cc5bf Don't break non-string keys in ArchiveTables when printing error message 2026-05-12 03:52:56 +03:00
alufolie91 d6946d4d44 fix HWR_RenderPolyObjectPlane
smol oopsie that was supposed to be float
fixes the rotating skybox thing in Zero Space
2026-05-11 15:08:14 +02:00
alufolie91 a868844bdf remove outdated comment about precipmobj 2026-05-10 20:15:28 +02:00
alufolie91 39fd31c4b9 p_mobj: potentially save a few more floor/ceiling z checks in some cases
+ some other crap
2026-05-10 20:15:24 +02:00
alufolie91 54f3d7b5e0 move lua_tostring out of the loop in mapheaderinfo_get
does not need to be reevaluated constantly
2026-05-10 16:57:45 +02:00
alufolie91 88116368bb fix potential null pointer deref in P_LineOpening
again ive never seen this hit, but the mobj gets checked right below its radius get dereferenced within the floorz/ceilingz functions which kinda annoyed me lol
as a fallback i just the floor/ceiling sectorheights, which were used before the addition of slopes
2026-05-09 20:00:19 +02:00
alufolie91 9328825a7c fix potential null pointer deref in P_MobjFloorZ/CeilingZ
dont think this ever really hit, but boundsec indeed can be null
it also gets checked if its null above anyways, so why not here?
2026-05-09 20:00:07 +02:00
alufolie91 f825ca32cc add "HAVE_IPV6" to passtrough compiler flags
to allow compiling with ipv6 support
to note this is unsupported from our side, as purely ipv6 servers are unreachable from vanilla clients
2026-05-09 15:33:48 +02:00
alufolie91 ce982d170f change "important" hook_state field to be bool type
matches the others
prob no diff in practice at all
2026-05-08 14:38:57 +02:00
alufolie91 1b3050028e save a few mobjfloorz/ceilingz calls in some cases
gave a small speedup on my test setup (+~3fps)
on slopes those are rather expensive
2026-05-08 14:38:47 +02:00
alufolie91 2344552ba8 Opengl: enable stencil testing only when portals are used
maybe a bit of perf on non portal maps, prob neglible but why not
2026-05-07 16:26:42 +02:00
alufolie91 50c1263e7d OpenGL: only enable stencil testing during level render
not 100% sure if this is the most correct thing, but this causes issues with Nvidia Gpu´s under x11
should fix https://github.com/Indev450/SRB2Kart-Saturn/issues/226
2026-05-06 12:28:08 +02:00
alufolie91 f1ded99262 some code style cleanups 2026-05-06 12:28:05 +02:00
alufolie91 b1620a3fce delet I_ShutdownConsole spam
without process forking I_ShutdownSystem will handle it, otherwise the parent process calls it before exiting
2026-05-04 23:02:04 +02:00
alufolie91 d0ea4d20d0 fix parent process being killed before child per interrupt/terminate signals
by ignoring those signals
otherwise the terminal will be left in a weird state, aswell as the parent exit stuff wont be properly run
this was "fine" before https://github.com/Indev450/SRB2Kart-Saturn/commit/f4dc161831a988e725e8639b9674984ebdf5f6bb but now needs to be handled like this
2026-05-04 23:02:01 +02:00
alufolie91 7f4804f98c fix super rare underflow within FixedHypot if input is -2147483648
this has an insanely rare chance of happening in certain cases (train rush map has a few spots where this is somewhat likely)
abs does not really handle -2147483648 and its result is pretty much implementation defined/ub, since we compile with fwrapv flag it would just return -2147483648 which will cause this to try and access tantoangle at a negative index
we can just return INT32_MAX here since treating either as 2147483647 would return 2147483647 eitherways
2026-05-04 14:10:49 +02:00
alufolie91 4fe3495652 fallback to srb2back instead of hoping the map is still loaded for intermission bg
timescale and replay fastforward caused stuff to crash and well this is better than a whitescreen ig
2026-05-04 10:28:32 +02:00
alufolie91 3c409b4a46 detect kill signal when printing signal from signalhandler
bit more informative than "signal number 9"
2026-05-04 10:01:26 +02:00
alufolie91 45067e00a5 fix compiler warnings + "support" gcc16 2026-05-04 08:04:08 +02:00
alufolie91 370ed1583b comment out unused spritescale/offset fields from gl_vissprite_t
yes those are in fact unused
not deleting since they might be useful for something sometime....
2026-05-02 21:02:50 +02:00
alufolie91 535c2073f1 move palshader code out of HWR_DrawScreenFinalTexture
and make the whole handling safer so we have less chance of ending up with blackscreens should the palette render shader fail
2026-05-01 03:51:28 +02:00
alufolie91 6460ae94f1 remove magic number for P_CalculatePrecipFloor stuff 2026-04-29 17:55:16 +02:00
alufolie91 093ed023ef cleanup CL_DrawConnectionStatus a little 2026-04-29 17:55:13 +02:00
minenice55 1bada2810a cap download size to total size in the connection UI 2026-04-29 17:55:10 +02:00
alufolie91 9df7f3cd3f dont let saltyhop overwrite the players spriteyoffset
let it add to it instead
otherwise if we ever use it for smth else in hardcode saltyhop will work with it
2026-04-29 17:55:04 +02:00
alufolie91 010b6c0361 use destructor attribute for W_Shutdown
makes sure this is always called in any case
also just simpler
2026-04-29 17:55:01 +02:00
alufolie91 dbf67a9670 remove some branch hints in some places
should really only use those for things that are basically dead but gotta be kept for compat reasons and such
2026-04-29 17:54:58 +02:00
alufolie91 8868445c3c S_UpdateSounds: init listenmobj
not sure why but ubsan did complain about it sometimes
S_StartSoundAtVolume also just memsets it so why not do the same here anyways
2026-04-29 17:54:55 +02:00
alufolie91 568cb8b8c7 check I_GetNodeAddress is set before use
this might´ve not been init yet at that point
2026-04-27 22:02:43 +02:00
alufolie91 3b00a69615 prevent buffer underflow within holepunching 2026-04-27 22:02:39 +02:00
alufolie91 6949ce82ab k_hud: fix achii speedometer not being properly coloured with colourhud
oopsie smol oversight from me
2026-04-23 10:07:40 +02:00
alufolie91 c343c52477 remove "extra3" hud stuff
decided to finally make smol stickers for the beta hud
this was never a really great solution since it made things look pretty bad at certain resolutions/scales
still keep the loading code for convenience but honestly not needed aswell at this point
2026-04-23 10:07:35 +02:00
alufolie91 7931a82b23 attempt to fix a plethora of buffer overflows when trying to connect to a server that does not exist
ex: if you typo´d the serveraddress
this really aint pretty but idk how to make things not turn into limbo hell otherwise
2026-04-21 20:52:15 +02:00
alufolie91 31ccf9c34a optimize K_CheckOffroadCollide further
also makes this alot more readable
like this most of the time we dont have to ever check the players floorz nor ceilingz at all since we check if the sector the players mobj is in is even offroad at all
nothing super big but i did see an improvement of around 1fps in my usual benchmark
2026-04-18 18:46:58 +02:00
alufolie91 ff3b73c49e fix offroad oopsie causing desynch
ye def not confusing at all to suddenly switch the meaning of floor and ceiling
2026-04-17 20:53:24 +02:00
alufolie91 64bed71509 add toggle to allow controllers to control the game while window is unfocused
can be toggled with "gamepadunfocused" or in the focus options
2026-04-17 18:54:18 +02:00
alufolie91 eed5943b0b optimize K_CheckOffroadCollide a little bit
no need to always check both the mobjs floor and ceiling z coordinates, those are surprisingly complicated checks on slopes
2026-04-17 17:46:17 +02:00
alufolie91 4f9ddffe2a d_cliserv: check for splitscreen nodes first in clientcmd handler
so we dont always have to check a bunch of things that most of the time wont apply anyways
2026-04-17 17:46:17 +02:00
alufolie91 a73f3a073c hw_main: dont need to do sprite billboarding stuff with shearing enabled within HWR_SplitSprite 2026-04-17 17:46:17 +02:00
alufolie91 a59928221b few more cleanups and super tiny optimizations k_hud 2026-04-16 17:39:13 +02:00
Eidolon b46e5cb577 gl: Fix sky dome VBO leak 2026-04-15 23:51:15 +02:00
alufolie91 bb62fbfc12 add "USEJEMALLOC" make flag to link against "jemalloc" allocator
on my linux system and usual benchmark setup this improves performance quite significantly (+~12fps)
this relies on jemalloc to be installed as a separate library for now and is more a convenience thing
2026-04-15 23:51:15 +02:00
GenericHeroGuy 81f46224e1 Fix asan error when pressing shift and arrow key
Also fix addons menu ignoring shift when capslock is on!
Also also fix capslock+rshift still typing uppercase letters!
2026-04-15 18:08:03 +02:00
NepDisk 6c58c0de41 Add support for using custom SDL2 mappings 2026-04-14 20:25:31 +02:00
alufolie91 4edc102d67 hack: fix intermission background becoming white after resolution change 2026-04-12 15:23:53 +02:00
alufolie91 e0bf663157 Hack: fix intermission screen displaying whitescreen in some cases
does not fix whitescreen when switching resolutions while in intermission screen, but oh well
lets hope there will be no issues with calling D_Renderview in intermission state, but it seems to work from quick testing lul
2026-04-12 15:05:51 +02:00
alufolie91 eccc3eb33f print opengl extensions in new lines for ogllog
otherwise this may still get truncated and lots of text editor also complain about a super long single line of text
also fix null ptr dereferencing into strtok should strdup return null
2026-04-12 14:30:49 +02:00
indev 1217089d81 G_UseContinue is unused, delet it 2026-04-11 21:53:15 +03:00
alufolie91 e5c0967a3f BLUA: simplify lua number hash 2026-04-11 16:49:19 +02:00
indev 27f22e4b5b Use case insensitive string hashing and compare functions for cvar hashtable 2026-04-09 19:09:37 +03:00
alufolie91 c039d14efc remove even more unused stuff 2026-04-08 22:42:34 +02:00
alufolie91 71a0b25e32 remove old and unused menu player description stuff
hope ignorelines is the correct thing to well ignore lines lol
2026-04-08 22:42:31 +02:00
alufolie91 8c2132a98c remove a few more unused things 2026-04-08 21:54:32 +02:00
alufolie91 898bcd336d should be
:chonkbuncle:
2026-04-08 18:53:43 +02:00
alufolie91 5461a6dcbe cleanup skinselect menu stuff slightly 2026-04-08 14:56:44 +02:00
alufolie91 d957bddc1f update opengl dithering shader
now works more like i intended too by more or less scaling the pattern to be roughly the same size on each resolution and trying to reduce precision issues by using floor to convert float values to integer range
2026-04-08 14:39:09 +02:00
alufolie91 7177a9f57f raise version to v9.3 2026-04-07 17:53:11 +02:00
alufolie91 4ccf3dfaf9 software: make R_DrawWallColumn being able to render "holey" textures
not the most efficient but idk a better solution to this, and clipping code may cause some other undesired effects, but well were not supposed to be drawing textures with holes on single sided walls eitherways, but here we are
basically this copies columns into a buffer filled with cyan pixels, so the holes become cyan instead of nothing, which we can cut again using the twomultipatch drawers
fixes the "melt" effect on some things like spelunky or music plant (and well reading/writing oob)
2026-04-05 20:37:24 +02:00
indev 489a58f9fd Allocate all colormaps with PU_STATIC 2026-04-05 18:31:55 +02:00
alufolie91 b26effa241 Merge pull request #223 from Indev450/bluaopti2
Some optimizations and fixes for BLUA from LUA
2026-04-05 18:28:50 +02:00
alufolie91 efd8c20d26 enable lto by default on makefile builds
change flag to NOLTO to disable lto
at this point we shouldnt have any issues anymore since the utter crapton of bugfixes
2026-04-05 18:26:16 +02:00
alufolie91 03b85aa00e Merge pull request #225 from Indev450/optifindvar
Speed up CV_Findvar & CV_FindNetVar with hashtable
2026-04-04 17:05:25 +02:00
indev e6434c24ec Fix spelling in server addon info tooltip 2026-04-04 18:01:10 +03:00
indev 52e23e7b08 Merge pull request #224 from Indev450/addon-download-info
Addon download info
2026-04-04 14:49:38 +00:00
indev b84e6d89e2 Add toggle for server addons info hud into settings 2026-04-04 17:24:58 +03:00
indev 42fa435a0b Add toggle for server addon info 2026-04-04 17:17:11 +03:00
indev 873cff4474 Display information about addon types loaded on server when joining (WIP) 2026-04-04 17:17:09 +03:00
indev e543599598 Add option to hide skin name from stat display 2026-04-04 16:54:17 +03:00
alufolie91 9d75bb1405 hw_main: reorder things, mark const, remove pointless check for polyobject planes
like normal planes, polyobject planes will just reallocate their vertex buffer eitherways according to size, so that check does not make much sense, srb2 also did remove it a while ago
2026-04-04 15:47:02 +02:00
indev 7b0e3269b3 Add option to hide finished players from minimap 2026-04-04 16:37:15 +03:00
alufolie91 12169bfb38 controllers:check if controller supports addressable led and rumble 2026-03-29 13:50:13 +02:00
alufolie91 4dd5957f19 cache islocalplayer in P_SpectatorJoinGame 2026-03-29 13:50:10 +02:00
alufolie91 0fadfe0f72 dehacked: fixup lua_enumlib_sprintf_upper
apparently reusing a va list like that is ub, so we should just copy it if we want to reuse it
also fix the resize check, since vsnprintf return does not include 0 terminator which we need to account for

also make this part of dehacked.c a bit more readable lol
2026-03-29 10:58:51 +02:00
alufolie91 621df7e296 v_video: make stringwidth loops safer 2026-03-28 23:39:21 +01:00
alufolie91 17d72e02fe cleanup some redundant/dead code 2026-03-28 23:39:17 +01:00
alufolie91 cd76660314 restore intended behavior for cvar menu categories
for onchange functions
2026-03-28 23:39:01 +01:00
alufolie91 06a9ab785e add misssing break K_SpawnBattlePoints
oopsie, somehow this seems to never caused any issues?
2026-03-28 23:06:10 +01:00
indev 6760546bcd I thought i reverted debug print aaaaaaaa 2026-03-29 00:34:11 +03:00
indev b44e003ab9 This is intended to be empty string, this way it reads the rest of the string including '=' :p 2026-03-29 00:29:38 +03:00
alufolie91 6a1c907aa4 bunch of random fixes
-handle more memory allocation failures
-fix null pointer dereferences
-prevent writing out of bounds while writing filenames for D_ParseFileneeded
-prevent reading out of bounds while checking for new target in director
-fix Update_MS checking against an unitialized value in some cases
-fix assert for AddLumpToCache since strlen on non null terminated strings is UB
-cleanup and rearrange R_DrawColumn
-cleanup musicdef parser a little

all in one commit cause idk would be ugly if those were seperate ig
2026-03-28 00:45:15 +01:00
indev fded8cc562 Crash fix for super tiny resolutions
Not really sure if anyone would actually want to play on something that
is lower than 320x200 but this prevents zero division in V_Recalc at least
2026-03-27 22:05:11 +03:00
alufolie91 43465c0e3f add debug print for fallback flashpals 2026-03-26 18:29:46 +01:00
alufolie91 7fb21c35ba Experiment: speed up CV_FindVar and CV_FindNetVar
oftentimes lua scripts call CV_FindVar a fuckton of times during runtime, with many cvars this can actually tank performance more than one might think
ideally lua scripts should cache the result, but with so much stuff and servers we cant expect everyone to go through all scripts to do that
using a hashtable for CV_FindNetVar might improve join times aswell, but needs further testing to confirm
2026-03-25 19:35:20 +01:00
alufolie91 f6a0430a40 use constructor for W_Startup
never liked having this inside i_system
2026-03-25 19:35:17 +01:00
alufolie91 ab209448d1 Introduce GNU constructor and destructor attributes
The constructor attribute causes the function to be called automatically before execution enters main (). Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called. Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.

added "used" attribute aswell so compiler does not omit non referenced functions (i hope)
gotta test this a bit but seems cool for stuff like verstable maps
2026-03-25 19:35:14 +01:00
alufolie91 9334b86f6e console print for playing demos from replayhut
might be useful
perhaps this should be put into g_doplaydemo instead?
2026-03-25 19:34:56 +01:00
alufolie91 6022966d69 G_DoPlayDemo: fix demoname becoming garbage when replay restarts/rewinds
only used in the error paths, which we shouldnt reach
but im not a fan of having a chance of putting garbo in the console
2026-03-25 19:34:54 +01:00
indev 6c7db705c7 Strip colors from demo titles for replay search 2026-03-25 21:05:39 +03:00
indev ce3d17de68 Simplify R_DoPlayerFade crash fix a bit and rename playerdist to otherplayerdist 2026-03-25 20:24:37 +03:00
alufolie91 404d88a536 remove some dead code 2026-03-24 01:07:07 +01:00
indev 4f28f574bb Fix rare crash in R_DoPlayerFade when viewplayerdist is too low 2026-03-24 00:20:28 +03:00
alufolie91 654895dcff fix timedemo not accounting for level and addon loading
apparently demos used to send a mapcmd before instead of directly calling G_InitNew, so this function was never called which meant that timedemos always returned a wrong result first time
2026-03-23 19:05:37 +01:00
alufolie91 8af43a55c9 split CONS_Printf
so both CONS_Alert and CONS_Debug dont have to handle and copy the varargs twice
probably makes no actual difference in practice, but i prefer it to not do pointless work
2026-03-22 22:29:21 +01:00
alufolie91 0d20ebb01f delet P_CyclePlayerMobjState
P_SetMobjState already handles player case and forwards it to P_SetPlayerMobjState
so this is just duped code
2026-03-22 22:17:45 +01:00
alufolie91 1c74b37026 unify console shift handling
both the non AZERTY and AZERTY functions basically did the exact same thing so can just get rid of one
also simplify some checks
2026-03-22 22:14:19 +01:00
indev 6721f534cc Fix Got_Saycmd not skipping null terminator when message has maximum length 2026-03-22 22:16:55 +03:00
indev bb3414d603 Fix /pm and emote suggestions overlapping 2026-03-21 23:10:48 +03:00
indev e13cb1ca92 Remove few remaining flashpal things in opengl menu 2026-03-17 19:00:38 +03:00
indev a0dffd0670 Fix listemotes calculating incorrect number of pages 2026-03-16 04:07:48 +03:00
Alug 7684e6aa07 Blua: opcode OP_SELF operate only with string keys, so they can use fast-track table access
https://github.com/lua/lua/commit/cb3d5dce30089512085f78a0bef79e30ef732e30
2026-03-15 18:19:06 +01:00
Alug 0fb752b745 Blua: OP_SELF can use 'luaV_fastget' specialized for strings, as it is applied only to string keys
https://github.com/lua/lua/commit/257961c601fdec1ea1f9640d460e0d31c39333a1
2026-03-15 18:19:03 +01:00
Alug c418fe3ef8 Blua: 'luaV_fastget' only treats the real fast case (table with a non-nil value at given key, so that it does not need to check metamethods)
https://github.com/lua/lua/commit/1a44e822009752513ce895b9eabc51a4ee4a195a
2026-03-15 18:18:59 +01:00
Alug fdccc80260 Blua: 'Protect' in table operations is not needed in the fast track
https://github.com/lua/lua/commit/df8b996bccd3830d6fe9d7ba80e8fccd6ac3cabf
2026-03-15 18:18:57 +01:00
Alug 84be9096b1 Blua: fast track for 'settable'
https://github.com/lua/lua/commit/3b795541c488c7e633567897c9112312007a20a0
https://github.com/lua/lua/commit/b91bc93fd33f2158745b37c9e091c6fa4d1a4fd5

had to adjust some things, hope this doesent explode lmao
2026-03-15 18:18:54 +01:00
Alug e4e51f0f80 Blua: implementation of fast track for gettable operations
https://github.com/lua/lua/commit/e247c3ada3ff47a1352927e797263137f4e02e0e

lets hope i converted this properly lul
2026-03-15 18:18:51 +01:00
Alug 9087fd8377 lua hooklib: use NUMMOBJTYPES to detect mobj hooks
removes the "force_mobj" field, gives a suprising perf boost from my timedemo testing +6-7fps (164 - 169/170fps)
this does however will prevent the generic hook from being called if the mobj being passed ever should be NULL
This shouldnt ever happen, vanilla assumes this aswell and way worse things would happen there, but just wanted to note
2026-03-13 19:09:38 +01:00
Alug 1aa37be676 p_user: cache kartspeed value within P_3dMovement
its result shouldnt change there, so no need to always recompute stuff, even if its not heavy work
2026-03-13 19:09:26 +01:00
Alug 04f63b23ff software: hack for bogus height walls
as per comment, this is merely a shitty workaround for a chain reaction of bad fixed point maths
since im honestly not feeling like rewriting most of the software renderer to either operate on 64bit or float maths, we just skip drawing anything that seems completely unreasonable
2026-03-13 19:09:18 +01:00
Alug d6ed923f83 P_XYMovement: check for kart specific stuff first to determine friction apply
this stuff is much more common than the other stuff being checked, so more likely to return earlier and save a bunch of other checks
2026-03-13 19:09:08 +01:00
Alug c7845118c0 explicitly cast those 2026-03-13 19:08:50 +01:00
alufolie91 ffc6adde4c Merge branch 'servaddonsonly' into Saturn-Next 2026-03-13 19:08:21 +01:00
Alug 00bc8bc149 limit addon only stuff to server info screen
quite honestly everything else is awful and i dont want to bother with it
2026-01-27 18:23:51 +01:00
Alug f12b55f63b rename addonsonly variable to cl_addonsonly
very generic name so add the prefix for whatever cl means
2026-01-27 18:08:12 +01:00
Alug 3e476d7658 implement allowing to load addons and gamestate only instead of joining server
really messy, needs some cleanup, not sure if this is good at all
2026-01-27 18:06:22 +01:00
118 changed files with 4471 additions and 4054 deletions

No files matched your search

+4 -1
View File
@@ -1,5 +1,8 @@
cmake_minimum_required(VERSION 3.5) cmake_minimum_required(VERSION 3.5)
# needed for lto to work for some reason
cmake_policy(SET CMP0069 NEW)
if(${PROJECT_SOURCE_DIR} MATCHES ${PROJECT_BINARY_DIR}) if(${PROJECT_SOURCE_DIR} MATCHES ${PROJECT_BINARY_DIR})
message(FATAL_ERROR "In-source builds will bring you a world of pain. Please make a separate directory to invoke CMake from.") message(FATAL_ERROR "In-source builds will bring you a world of pain. Please make a separate directory to invoke CMake from.")
endif() endif()
@@ -31,7 +34,7 @@ if("${SRB2_CPACK_GENERATOR}" STREQUAL "")
endif() endif()
set(CPACK_GENERATOR ${SRB2_CPACK_GENERATOR}) set(CPACK_GENERATOR ${SRB2_CPACK_GENERATOR})
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sonic Robo Blast 2 Kart" CACHE STRING "Program name for display purposes") set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sonic Robo Blast 2 Kart Saturn" CACHE STRING "Program name for display purposes")
set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes") set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes")
#set(CPACK_PACKAGE_DESCRIPTION_FILE ) #set(CPACK_PACKAGE_DESCRIPTION_FILE )
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+2 -2
View File
@@ -54,7 +54,7 @@ set(SRB2_CORE_SOURCES
string.c string.c
tables.c tables.c
v_video.c v_video.c
w_wad.cpp w_wad.c
y_inter.c y_inter.c
z_zone.cpp z_zone.cpp
) )
@@ -518,7 +518,7 @@ if(${SRB2_CONFIG_HWRENDER})
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_batching.c ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_batching.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_shaders.c ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_shaders.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_bsp.c ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_bsp.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.cpp ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp
+7 -2
View File
@@ -93,7 +93,8 @@
# NOLDWARNING=1 - ? # NOLDWARNING=1 - ?
# NOSDLMAIN=1 - ? # NOSDLMAIN=1 - ?
# SDLMAIN=1 - ? # SDLMAIN=1 - ?
# USELTO=1 - Enable building with LTO. # NOLTO=1 - Disable link time optimizations
# USEJEMALLOC=1 Enable building with jemalloc Allocator to replace GLibc malloc, might improve performance
# #
# Library configuration flags: # Library configuration flags:
# Everything here is an override. # Everything here is an override.
@@ -260,7 +261,7 @@ debug_opts=-D_DEBUG
else # build a normal optimized version else # build a normal optimized version
debug_opts=-DNDEBUG debug_opts=-DNDEBUG
opts+=-O3 opts+=-O3
ifdef USELTO ifndef NOLTO
# compile with LTO # compile with LTO
opts+=-flto=auto opts+=-flto=auto
libs+=-flto=auto libs+=-flto=auto
@@ -279,6 +280,10 @@ opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
libs+=-fsanitize=undefined libs+=-fsanitize=undefined
endif endif
ifdef USEJEMALLOC
libs+=-ljemalloc
endif
ifneq (,$(filter $(CC) $(CXX),clang clang++)) ifneq (,$(filter $(CC) $(CXX),clang clang++))
libs+=-fuse-ld=lld libs+=-fuse-ld=lld
endif endif
+2 -1
View File
@@ -64,6 +64,7 @@ endif
# This must have high to low order. # This must have high to low order.
gcc_versions:=\ gcc_versions:=\
161 160 16\
152 151 150 15\ 152 151 150 15\
142 141 140 14\ 142 141 140 14\
133 132 131 130 13\ 133 132 131 130 13\
@@ -77,7 +78,7 @@ gcc_versions:=\
55 54 53 52 51 50\ 55 54 53 52 51 50\
49 48 47 46 45 44 43 42 41 40 49 48 47 46 45 44 43 42 41 40
latest_gcc_version:=15.2 latest_gcc_version:=16.1
# Automatically set version flag, but not if one was # Automatically set version flag, but not if one was
# manually set. And don't bother if this is a clean only # manually set. And don't bother if this is a clean only
+1
View File
@@ -8,6 +8,7 @@ passthru_opts+=\
HAVE_MINIUPNPC\ HAVE_MINIUPNPC\
HAVE_DISCORDRPC DEVELOP\ HAVE_DISCORDRPC DEVELOP\
NOHOLEPUNCH\ NOHOLEPUNCH\
HAVE_IPV6\
# build with debugging information # build with debugging information
ifdef DEBUGMODE ifdef DEBUGMODE
+7
View File
@@ -81,6 +81,7 @@ static /*const*/ Node dummynode_ = {
/* /*
** hash for lua_Numbers ** hash for lua_Numbers
*/ */
#if 0
static Node *hashnum (const Table *t, lua_Number n) { static Node *hashnum (const Table *t, lua_Number n) {
unsigned int a[numints]; unsigned int a[numints];
int i; int i;
@@ -90,6 +91,12 @@ static Node *hashnum (const Table *t, lua_Number n) {
for (i = 1; i < numints; i++) a[0] += a[i]; for (i = 1; i < numints; i++) a[0] += a[i];
return hashmod(t, a[0]); return hashmod(t, a[0]);
} }
#else
// our lua_Number is just typedef´d int32 so no need to do any of the above
static inline Node *hashnum (const Table *t, lua_Number n) {
return hashmod(t, cast(unsigned int, n));
}
#endif
+64 -2
View File
@@ -1165,6 +1165,39 @@ void VS_Print(vsbuf_t *buf, const char *data)
// //
// ========================================================================= // =========================================================================
#define NAME cvar_map_t
#define KEY_TY const char *
#define VAL_TY consvar_t *
#define HASH_FN FNV1a_HashLowercaseString
#define CMPR_FN vt_cmpr_casestring
#include "verstable.h"
#define NAME netvar_map_t
#define KEY_TY UINT16
#define VAL_TY consvar_t *
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "verstable.h"
static cvar_map_t cvar_map;
static netvar_map_t netvar_map;
CONSTRUCTOR static void CV_InitMap(void)
{
// ensure the map is initialized
cvar_map_t_init(&cvar_map);
cvar_map_t_reserve(&cvar_map, 512);
netvar_map_t_init(&netvar_map);
netvar_map_t_reserve(&netvar_map, 256);
}
DESTRUCTOR static void CV_DestroyMap(void)
{
cvar_map_t_cleanup(&cvar_map);
netvar_map_t_cleanup(&netvar_map);
}
static const char *cv_null_string = ""; static const char *cv_null_string = "";
/** Searches if a variable has been registered. /** Searches if a variable has been registered.
@@ -1175,11 +1208,17 @@ static const char *cv_null_string = "";
*/ */
consvar_t *CV_FindVar(const char *name) consvar_t *CV_FindVar(const char *name)
{ {
consvar_t *cvar; cvar_map_t_itr it = cvar_map_t_get(&cvar_map, name);
if (!cvar_map_t_is_end(it))
return it.data->val;
// fallback linear search
/*
consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (fasticmp(name, cvar->name)) if (fasticmp(name, cvar->name))
return cvar; return cvar;
*/
return NULL; return NULL;
} }
@@ -1194,7 +1233,7 @@ consvar_t *CV_FindVar(const char *name)
static inline UINT16 CV_ComputeNetid(const char *s) static inline UINT16 CV_ComputeNetid(const char *s)
{ {
UINT16 ret = 0, i = 0; UINT16 ret = 0, i = 0;
static UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53}; static const UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
while (*s) while (*s)
{ {
@@ -1213,11 +1252,17 @@ static inline UINT16 CV_ComputeNetid(const char *s)
*/ */
static consvar_t *CV_FindNetVar(UINT16 netid) static consvar_t *CV_FindNetVar(UINT16 netid)
{ {
netvar_map_t_itr it = netvar_map_t_get(&netvar_map, netid);
if (!netvar_map_t_is_end(it))
return it.data->val;
/*
consvar_t *cvar; consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->netid == netid) if (cvar->netid == netid)
return cvar; return cvar;
*/
if (netid == 44542) // ouch this hack if (netid == 44542) // ouch this hack
return &cv_karteliminatelast; return &cv_karteliminatelast;
@@ -1283,6 +1328,11 @@ void CV_RegisterVar(consvar_t *variable)
// the SetValue will set this bit // the SetValue will set this bit
variable->flags &= ~CV_MODIFIED; variable->flags &= ~CV_MODIFIED;
cvar_map_t_insert(&cvar_map, variable->name, variable);
if (variable->flags & CV_NETVAR)
netvar_map_t_insert(&netvar_map, variable->netid, variable);
} }
/** Finds the string value of a console variable. /** Finds the string value of a console variable.
@@ -1588,9 +1638,21 @@ size_t CV_LoadNetVars(const UINT8 *bufstart)
// prevent "invalid command received" // prevent "invalid command received"
serverloading = true; serverloading = true;
// we can use our netvar map instead of going through all cvars each time
netvar_map_t_itr it;
for (it = netvar_map_t_first(&netvar_map);
!netvar_map_t_is_end(it);
it = netvar_map_t_next(it))
{
cvar = it.data->val;
Setvalue(cvar, cvar->defaultvalue, true);
}
/*
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->flags & CV_NETVAR) if (cvar->flags & CV_NETVAR)
Setvalue(cvar, cvar->defaultvalue, true); Setvalue(cvar, cvar->defaultvalue, true);
*/
count = READUINT16(p); count = READUINT16(p);
while (count--) while (count--)
+193 -78
View File
@@ -208,14 +208,6 @@ static void CONS_Clear_f(void)
Unlock_state(); Unlock_state();
} }
// Choose english keymap
//
/*static void CONS_English_f(void)
{
shiftxform = english_shiftxform;
CONS_Printf(M_GetText("%s keymap.\n"), M_GetText("English"));
}*/
static char *bindtable[NUMINPUTS]; static char *bindtable[NUMINPUTS];
static void CONS_Bind_f(void) static void CONS_Bind_f(void)
@@ -633,72 +625,191 @@ void CON_MoveConsole(void)
Unlock_state(); Unlock_state();
} }
//======================================================================
// KEYBOARD LAYOUTS FOR ENTERING TEXT
//======================================================================
static char english_shiftxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!', '"', '#', '$', '%', '&',
'"', // shift-'
'(', ')', '*', '+',
'<', // shift-,
'_', // shift--
'>', // shift-.
'?', // shift-/
')', // shift-0
'!', // shift-1
'@', // shift-2
'#', // shift-3
'$', // shift-4
'%', // shift-5
'^', // shift-6
'&', // shift-7
'*', // shift-8
'(', // shift-9
':',
':', // shift-;
'<',
'+', // shift-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', // shift-[
'|', // shift-backslash - OH MY GOD DOES WATCOM SUCK
'}', // shift-]
'"', '_',
'~', // shift-`
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127
};
static char french_shiftxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ','$', //shift-!
'3', //shift-"
'#', '$', '%',
'1', //shift-&
'4', // shift-'
'5', // shift-(
')', // shift-)
'*', '+',
'?', // shift-,
'6', // shift--
'.', '/',
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9',
'/', // shitf-:
'.', // shift-;
'>', // shift-<
'+', // shift-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'[', '\\', ']', '^',
'8', //shift-_
'`',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127,
128, 129,
'2',
131, 132,
'0',
134,
'9',
136, 137,
'7',
139, 140,
'%'
};
static char french_altgrxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!',
'#', //altgr-"
'#', '$', '%', '&',
'{', //altgr-'
'[', //altgr-(
']', //altgr-)
'*', '+', ',',
'|', //altg--
'.', '/',
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9',
':', ';', '<',
'}', //altgr-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'[', '\\', ']', '^',
'\\', //altgr-backslash
'`',
'a', 'b', 'c', 'd', 'E', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'{', '|', '}', '~', 127,
128, 129,
'~',
131, 132,
'@',
134,
'^',
136, 137,
'`',
139, 140,
KEY_FR_U_GRAVE
};
// fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
static INT32 CON_FallBackFrSpecialLetter(INT32 key)
{
switch (key)
{
case KEY_FR_E_AIGUE: return 'e';
case KEY_FR_E_GRAVE: return 'e';
case KEY_FR_C_CEDILLE: return 'c';
case KEY_FR_A_GRAVE: return 'a';
case KEY_FR_U_GRAVE: return 'u';
default: return key;
}
}
// goddang AZERTY
static size_t CON_GetShiftSize(void)
{
return ((cv_keyboardlayout.value == 3) ? sizeof(french_shiftxform) : sizeof(english_shiftxform));
}
static char *CON_Shiftform(void)
{
return (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
}
INT32 CON_ShiftChar(INT32 ch) INT32 CON_ShiftChar(INT32 ch)
{ {
if (I_UseNativeKeyboard()) if (I_UseNativeKeyboard() || ch >= (INT32)CON_GetShiftSize())
return ch; return ch;
// warning: shiftdown is NOT a boolean, it's 1 or 2 for lshift/rshift
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{ {
if (cv_keyboardlayout.value == 3) return !!shiftdown != capslock ? CON_Shiftform()[ch] : ch;
{
if (shiftdown ^ capslock)
ch = shiftxform[ch];
else if (altdown & 0x2)
ch = french_altgrxform[ch];
else
ch = HU_FallBackFrSpecialLetter(ch);
}
else
{
if (shiftdown ^ capslock)
ch = shiftxform[ch];
}
} }
else // if we're holding shift we should still shift non letter symbols
// if we're holding shift we should still shift non letter symbols
if (shiftdown)
{ {
if (cv_keyboardlayout.value == 3) return CON_Shiftform()[ch];
{ }
if (shiftdown)
ch = shiftxform[ch]; // AZERTY
else if (altdown & 0x2) if (cv_keyboardlayout.value == 3)
ch = french_altgrxform[ch]; {
else if (altdown & 0x2)
ch = HU_FallBackFrSpecialLetter(ch); return french_altgrxform[ch];
}
else return CON_FallBackFrSpecialLetter(ch);
{
if (shiftdown)
ch = shiftxform[ch];
}
} }
return ch; return ch;
} }
INT32 CON_ShitAndAltGrChar(INT32 ch)
{
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{
if (shiftdown ^ capslock)
ch = shiftxform[ch];
}
else // if we're holding shift we should still shift non letter symbols
{
if (shiftdown)
ch = shiftxform[ch];
else if (altdown & 0x2)
{
ch = french_altgrxform[ch];
}
else
{
ch = HU_FallBackFrSpecialLetter(ch);
}
}
return ch;
}
// Clear time of console heads up messages // Clear time of console heads up messages
// //
@@ -892,7 +1003,7 @@ boolean CON_Responder(event_t *ev)
return true; return true;
// ctrl modifier -- changes behavior, adds shortcuts // ctrl modifier -- changes behavior, adds shortcuts
if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown)) if (ctrldown && (cv_keyboardlayout.value != 3 || !altdown))
{ {
// show all cvars/commands that match what we have inputted // show all cvars/commands that match what we have inputted
if (key == KEY_TAB) if (key == KEY_TAB)
@@ -1222,19 +1333,10 @@ void CON_LogMessage(const char *msg)
// Console print! Wahooo! Lots o fun! // Console print! Wahooo! Lots o fun!
// //
void CONS_Printf(const char *fmt, ...) static inline void CONS_PrintMsg(char *txt)
{ {
va_list argptr;
static char *txt = NULL;
boolean startup; boolean startup;
if (txt == NULL)
txt = malloc(8192);
va_start(argptr, fmt);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
// echo console prints to log file // echo console prints to log file
DEBFILE(txt); DEBFILE(txt);
@@ -1260,6 +1362,21 @@ void CONS_Printf(const char *fmt, ...)
} }
} }
void CONS_Printf(const char *fmt, ...)
{
va_list argptr;
static char *txt = NULL;
if (txt == NULL)
txt = malloc(8192);
va_start(argptr, fmt);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
CONS_PrintMsg(txt);
}
void CONS_Alert(alerttype_t level, const char *fmt, ...) void CONS_Alert(alerttype_t level, const char *fmt, ...)
{ {
va_list argptr; va_list argptr;
@@ -1288,9 +1405,7 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
break; break;
} }
// I am lazy and I feel like just letting CONS_Printf take care of things. CONS_PrintMsg(txt);
// Is that okay?
CONS_Printf("%s", txt);
} }
void CONS_Debug(INT32 debugflags, const char *fmt, ...) void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1308,11 +1423,9 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
vsnprintf(txt, 8192, fmt, argptr); vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr); va_end(argptr);
// Again I am lazy, oh well CONS_PrintMsg(txt);
CONS_Printf("%s", txt);
} }
// Print an error message, and wait for ENTER key to continue. // Print an error message, and wait for ENTER key to continue.
// To make sure the user has seen the message // To make sure the user has seen the message
// //
@@ -1324,6 +1437,8 @@ void CONS_Error(const char *msg)
// dirty quick hack, but for the good cause // dirty quick hack, but for the good cause
while (I_GetKey() != KEY_ENTER) while (I_GetKey() != KEY_ENTER)
{ {
I_HandleInterrupt();
// Sleep so we don't take too much of cpu usage // Sleep so we don't take too much of cpu usage
I_Sleep(1.f/TICRATE*1000); I_Sleep(1.f/TICRATE*1000);
-1
View File
@@ -49,7 +49,6 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
extern UINT8 *consolebgmap; extern UINT8 *consolebgmap;
INT32 CON_ShiftChar(INT32 ch); INT32 CON_ShiftChar(INT32 ch);
INT32 CON_ShitAndAltGrChar(INT32 ch);
void CON_SetupBackColormap(void); void CON_SetupBackColormap(void);
void CON_ClearHUD(void); // clear heads up messages void CON_ClearHUD(void); // clear heads up messages
+187 -68
View File
@@ -100,6 +100,10 @@ static int map_icon_request_count; // current count of icon requests sent
static UINT8 *map_icon_data; static UINT8 *map_icon_data;
static patch_t *map_icon; static patch_t *map_icon;
// if true, signals the game to only load addons AND gamestate
// instead of fully joining a server
static boolean cl_addonsonly = false;
plrinfo playerinfo[MAXPLAYERS] = {}; plrinfo playerinfo[MAXPLAYERS] = {};
SINT8 joinnode = 0; // used for CL_VIEWSERVER SINT8 joinnode = 0; // used for CL_VIEWSERVER
@@ -121,6 +125,7 @@ static tic_t freezetimeout[MAXNETNODES]; // Until when can this node freeze the
UINT16 pingmeasurecount = 1; UINT16 pingmeasurecount = 1;
UINT32 realpingtable[MAXPLAYERS] = {}; //the base table of ping where an average will be sent to everyone. 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 playerpingtable[MAXPLAYERS] = {}; //table of player latency values.
UINT32 localplayerping = 0;
#define GENTLEMANSMOOTHING (TICRATE) #define GENTLEMANSMOOTHING (TICRATE)
static tic_t reference_lag = 0; static tic_t reference_lag = 0;
@@ -352,12 +357,13 @@ void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_
if (2+nparam > MAXTEXTCMD) if (2+nparam > MAXTEXTCMD)
{ {
CONS_Alert(CONS_ERROR, M_GetText("packet too large to fit NetXCmd, cannot add netcmd %d! (size: %s, max: %d)\n"), id, sizeu1(2+nparam), MAXTEXTCMD); CONS_Alert(CONS_ERROR, M_GetText("packet too large to fit NetXCmd, cannot add netcmd %s with id %d! (size: %s, max: %d)\n"), netxcmdnames[id-1], id, sizeu1(2+nparam), MAXTEXTCMD);
return; return;
} }
// for future reference: if (cv_debug) != debug disabled. // for future reference: if (cv_debug) != debug disabled.
CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %d... (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam)); CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %s with id %d... (size: %d, needed: %s)\n"), netxcmdnames[id-1], id, localtextcmd[playerid][0], sizeu1(nparam));
if (buf == NULL) if (buf == NULL)
{ {
textcmdbuf[playerid] = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL); textcmdbuf[playerid] = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
@@ -1150,6 +1156,67 @@ static void CV_LoadPlayerNames(UINT8 **p)
} }
} }
static void CL_DrawAddonTypes(void)
{
if (!cv_serveraddoninfo.value)
return;
INT32 y = 0;
INT32 addontypes_downloaded[NUMADDONTYPES] = {0};
for (INT32 i = 0; i < fileneedednum; ++i)
{
switch (fileneeded[i].status)
{
case FS_FOUND:
case FS_OPEN:
addontypes_downloaded[fileneeded[i].type]++;
break;
default:
break;
}
}
for (addontype_t type = 0; type < NUMADDONTYPES; ++type)
{
if (addontypes[type] == 0)
continue;
INT32 flags = V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE;
if (addontypes[type] == addontypes_downloaded[type])
flags |= V_GREENMAP;
else
flags |= V_YELLOWMAP;
const char *typestr = "Misc";
switch (type)
{
case ADDON_SCRIPT:
typestr = "Script";
break;
case ADDON_MAP:
typestr = "Map";
break;
case ADDON_CHARACTER:
typestr = "Character";
break;
default:
break;
}
V_DrawSmallString(4, 4 + y, flags, va("%s addons", typestr));
V_DrawRightAlignedSmallString(100, 4 + y, flags, va("%d/%d", addontypes_downloaded[type], addontypes[type]));
y += 6;
}
}
// //
// CL_DrawConnectionStatus // CL_DrawConnectionStatus
// //
@@ -1190,20 +1257,18 @@ static void CL_DrawConnectionStatus(void)
case CL_DOWNLOADSAVEGAME: case CL_DOWNLOADSAVEGAME:
if (filedownload.current != -1) if (filedownload.current != -1)
{ {
INT32 dldlength = 0; UINT32 dldlength = 0;
fileneeded_t *file = &fileneeded[filedownload.current]; fileneeded_t *file = &fileneeded[filedownload.current];
UINT32 currentsize = file->currentsize;
UINT32 totalsize = file->totalsize; UINT32 totalsize = file->totalsize;
UINT32 currentsize = min(file->currentsize, totalsize);
cltext = M_GetText("Downloading game state..."); cltext = M_GetText("Downloading game state...");
Net_GetNetStat(); Net_GetNetStat();
if (totalsize != 0) if (totalsize != 0)
dldlength = (INT32)((currentsize/(double)totalsize) * 256); dldlength = (UINT32)((currentsize/(double)totalsize) * 256);
if (dldlength > 256)
dldlength = 256;
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 96); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, (INT32)dldlength, 8, 96);
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
va(" %4uK/%4uK", currentsize>>10, totalsize>>10)); va(" %4uK/%4uK", currentsize>>10, totalsize>>10));
@@ -1265,6 +1330,8 @@ static void CL_DrawConnectionStatus(void)
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %2u/%2u Files", checkednum, fileneedednum)); va(" %2u/%2u Files", checkednum, fileneedednum));
CL_DrawAddonTypes();
} }
else if (cl_mode == CL_LOADFILES) else if (cl_mode == CL_LOADFILES)
{ {
@@ -1288,6 +1355,8 @@ static void CL_DrawConnectionStatus(void)
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %2u/%2u Files", loadcompletednum, fileneedednum)); va(" %2u/%2u Files", loadcompletednum, fileneedednum));
CL_DrawAddonTypes();
} }
else if (cl_mode == CL_VIEWSERVER) else if (cl_mode == CL_VIEWSERVER)
{ {
@@ -1411,18 +1480,20 @@ static void CL_DrawConnectionStatus(void)
// Buttons // Buttons
V_DrawFill(8, BASEVIDHEIGHT - 14, BASEVIDWIDTH - 16, 12, 239); V_DrawFill(8, BASEVIDHEIGHT - 14, BASEVIDWIDTH - 16, 12, 239);
V_DrawThinString(16, BASEVIDHEIGHT - 12, V_ALLOWLOWERCASE, va("[%sESC%s] = Abort", "\x82", "\x80")); V_DrawThinString(16, BASEVIDHEIGHT - 12, V_ALLOWLOWERCASE, va("[%sESC%s] = Abort", "\x82", "\x80"));
V_DrawCenteredThinString(BASEVIDWIDTH/2, BASEVIDHEIGHT - 12, V_ALLOWLOWERCASE, va("[%sSPACE%s] = Load Addons", "\x82", "\x80"));
V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, BASEVIDHEIGHT - 12, V_ALLOWLOWERCASE, va("[%sENTER%s] = Join", "\x82", "\x80")); V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, BASEVIDHEIGHT - 12, V_ALLOWLOWERCASE, va("[%sENTER%s] = Join", "\x82", "\x80"));
} }
else if (filedownload.current != -1) else if (filedownload.current != -1)
{ {
INT32 dldlength = 0; UINT32 dldlength = 0;
INT32 totalfileslength = 0;
UINT32 totaldldsize = 0; UINT32 totaldldsize = 0;
UINT32 totalfileslength = 0;
static char tempname[28]; static char tempname[28];
fileneeded_t *file = &fileneeded[filedownload.current]; fileneeded_t *file = &fileneeded[filedownload.current];
char *filename = file->filename; char *filename = file->filename;
UINT32 currentsize = file->currentsize;
UINT32 totalsize = file->totalsize; UINT32 totalsize = file->totalsize;
UINT32 currentsize = min(file->currentsize, totalsize);
UINT32 fdtotalsize = filedownload.totalsize;
// Draw the bottom box. // Draw the bottom box.
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-58-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-58-8, 32, 1);
@@ -1430,11 +1501,9 @@ static void CL_DrawConnectionStatus(void)
Net_GetNetStat(); Net_GetNetStat();
if (totalsize != 0) if (totalsize != 0)
dldlength = (INT32)((currentsize/(double)totalsize) * 256); dldlength = (UINT32)((currentsize/(double)totalsize) * 256);
if (dldlength > 256)
dldlength = 256;
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, 256, 8, 175);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, dldlength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, (INT32)dldlength, 8, 160);
memset(tempname, 0, sizeof(tempname)); memset(tempname, 0, sizeof(tempname));
@@ -1475,21 +1544,23 @@ static void CL_DrawConnectionStatus(void)
totaldldsize = filedownload.completedsize; totaldldsize = filedownload.completedsize;
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-14, V_YELLOWMAP|MENUCAPS, "Overall Download Progress"); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-14, V_YELLOWMAP|MENUCAPS, "Overall Download Progress");
if (filedownload.totalsize != 0) if (fdtotalsize != 0)
totalfileslength = (INT32)((totaldldsize/(double)filedownload.totalsize) * 256); totalfileslength = (UINT32)((totaldldsize/(double)fdtotalsize) * 256);
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, (INT32)totalfileslength, 8, 160);
if (filedownload.totalsize>>20 >= 10) // display in MB if over 10MB if ((fdtotalsize>>20) >= 10) // display in MB if over 10MB
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %4uM/%4uM", totaldldsize>>20, filedownload.totalsize>>20)); va(" %4uM/%4uM", (INT32)(totaldldsize>>20), (INT32)(fdtotalsize>>20)));
else else
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %4uK/%4uK", totaldldsize>>10, filedownload.totalsize>>10)); va(" %4uK/%4uK", (INT32)(totaldldsize>>10), (INT32)(fdtotalsize>>10)));
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va("%2u/%2u Files ", filedownload.completednum, filedownload.totalnum)); va("%2u/%2u Files ", filedownload.completednum, filedownload.totalnum));
CL_DrawAddonTypes();
} }
else else
{ {
@@ -1506,6 +1577,8 @@ static void CL_DrawConnectionStatus(void)
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS,
M_GetText("Waiting to download files...")); M_GetText("Waiting to download files..."));
CL_DrawAddonTypes();
} }
} }
} }
@@ -2157,7 +2230,12 @@ static void CL_ReloadReceivedSavegame(void)
static void SendAskInfo(INT32 node) static void SendAskInfo(INT32 node)
{ {
tic_t asktime; tic_t asktime;
doomdata_t *netbuffer = DOOMCOM_DATA(doomcom); doomdata_t *netbuffer;
if (node == -1)
return;
netbuffer = DOOMCOM_DATA(doomcom);
#ifdef HOLEPUNCH #ifdef HOLEPUNCH
if (node != 0 && node != BROADCASTADDR && if (node != 0 && node != BROADCASTADDR &&
@@ -2504,7 +2582,7 @@ static boolean CL_FinishedFileList(void)
* \sa CL_ConnectToServer * \sa CL_ConnectToServer
* *
*/ */
static boolean CL_ServerConnectionSearchTicker(tic_t *asksent) static void CL_ServerConnectionSearchTicker(tic_t *asksent)
{ {
INT32 i; INT32 i;
@@ -2522,7 +2600,7 @@ static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
{ {
i = SL_SearchServer(servernode); i = SL_SearchServer(servernode);
if (i < 0) if (i < 0)
return true; return;
} }
joinnode = i; joinnode = i;
@@ -2550,10 +2628,11 @@ static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
{ {
cl_mode = CL_ASKFULLFILELIST; cl_mode = CL_ASKFULLFILELIST;
cl_lastcheckedfilecount = 0; cl_lastcheckedfilecount = 0;
return true; return;
} }
cl_mode = (cv_serverinfoscreen.value) ? CL_VIEWSERVER : CL_CHECKFILES; cl_mode = cv_serverinfoscreen.value ? CL_VIEWSERVER : CL_CHECKFILES;
CL_CheckAddonTypes();
} }
else else
{ {
@@ -2561,7 +2640,7 @@ static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
*asksent = 0; *asksent = 0;
} }
return true; return;
} }
// Ask the info to the server (askinfo packet) // Ask the info to the server (askinfo packet)
@@ -2571,7 +2650,17 @@ static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
*asksent = I_GetTime() + NEWTICRATE; *asksent = I_GetTime() + NEWTICRATE;
} }
return true; }
static void FreeMapIcon(void)
{
if (map_icon != NULL)
Patch_Free(map_icon);
map_icon = NULL;
if (map_icon_data != NULL)
Z_Free(map_icon_data);
map_icon_data = NULL;
map_icon_request_count = 0;
} }
/** Called by CL_ConnectToServer /** Called by CL_ConnectToServer
@@ -2592,13 +2681,15 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
switch (cl_mode) switch (cl_mode)
{ {
case CL_SEARCHING: case CL_SEARCHING:
if (!CL_ServerConnectionSearchTicker(asksent)) CL_ServerConnectionSearchTicker(asksent);
return false;
break; break;
case CL_ASKFULLFILELIST: case CL_ASKFULLFILELIST:
if (cl_lastcheckedfilecount == UINT16_MAX) // All files retrieved if (cl_lastcheckedfilecount == UINT16_MAX) // All files retrieved
cl_mode = (cv_serverinfoscreen.value) ? CL_VIEWSERVER : CL_CHECKFILES; {
cl_mode = cv_serverinfoscreen.value ? CL_VIEWSERVER : CL_CHECKFILES;
CL_CheckAddonTypes();
}
else if (fileneedednum != cl_lastcheckedfilecount || I_GetTime() >= *asksent) else if (fileneedednum != cl_lastcheckedfilecount || I_GetTime() >= *asksent)
{ {
if (CL_AskFileList(fileneedednum)) if (CL_AskFileList(fileneedednum))
@@ -2731,7 +2822,19 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
{ {
// Gamestate is now handled within CL_LoadReceivedSavegame() // Gamestate is now handled within CL_LoadReceivedSavegame()
CL_LoadReceivedSavegame(false); CL_LoadReceivedSavegame(false);
cl_mode = CL_CONNECTED;
if (cl_addonsonly)
{
// close connection after savegame load
// we want the actual server state
// in case theres some stuff like records to be synched
cl_mode = CL_ABORTED;
}
else
{
cl_mode = CL_CONNECTED;
}
break; break;
} // don't break case continue to CL_CONNECTED } // don't break case continue to CL_CONNECTED
else else
@@ -2745,7 +2848,6 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
case CL_ABORTED: case CL_ABORTED:
cl_mode = CL_SEARCHING; cl_mode = CL_SEARCHING;
return false; return false;
} }
GetPackets(); GetPackets();
@@ -2756,10 +2858,7 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
{ {
INT32 key; INT32 key;
if (I_Interrupted()) I_HandleInterrupt();
{
I_Quit();
}
I_OsPolling(); I_OsPolling();
@@ -2772,24 +2871,21 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
{ {
if (key == KEY_ENTER || key == KEY_JOY1) if (key == KEY_ENTER || key == KEY_JOY1)
{ {
cl_addonsonly = false;
cl_mode = CL_CHECKFILES; cl_mode = CL_CHECKFILES;
if (map_icon != NULL) FreeMapIcon();
Patch_Free(map_icon);
map_icon = NULL;
if (map_icon_data != NULL)
Z_Free(map_icon_data);
map_icon_data = NULL;
} }
else if (key == KEY_ESCAPE || key == KEY_JOY1+1) else if (key == KEY_ESCAPE || key == KEY_JOY1+1)
{ {
cl_mode = CL_ABORTED; cl_mode = CL_ABORTED;
if (map_icon != NULL) cl_addonsonly = false;
Patch_Free(map_icon); FreeMapIcon();
map_icon = NULL; }
if (map_icon_data != NULL) else if (key == KEY_SPACE || key == KEY_JOY1+2)
Z_Free(map_icon_data); {
map_icon_data = NULL; cl_addonsonly = true;
map_icon_request_count = 0; cl_mode = CL_CHECKFILES;
FreeMapIcon();
} }
} }
@@ -2798,6 +2894,7 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
{ {
CONS_Printf(M_GetText("Network game synchronization aborted.\n")); CONS_Printf(M_GetText("Network game synchronization aborted.\n"));
CL_AbortConnection(); CL_AbortConnection();
cl_addonsonly = false;
return false; return false;
} }
@@ -3294,9 +3391,21 @@ static void Command_connect(void)
} }
else else
CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n")); CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
// invalid address
if (servernode == -1)
{
D_QuitNetGame(); // this will also call D_CloseConnection for us
CL_Reset();
servernode = 0; // not sure if this is cool, but if this is -1 then bad things happen in alot of networking code
D_StartTitle();
M_StartMessage(M_GetText("Failed to connect to server\nMake sure you put in a valid Address!\n"), NULL, MM_NOTHING);
return;
}
} }
CV_Set(&cv_lastserver, I_GetNodeAddress(servernode)); if (I_GetNodeAddress)
CV_Set(&cv_lastserver, I_GetNodeAddress(servernode));
if (splitscreen != cv_splitplayers.value-1) if (splitscreen != cv_splitplayers.value-1)
{ {
@@ -3388,6 +3497,9 @@ void CL_RemovePlayer(INT32 playernum, INT32 reason)
while ((doomcom->numslots > 1) && !playeringame[doomcom->numslots-1]) while ((doomcom->numslots > 1) && !playeringame[doomcom->numslots-1])
doomcom->numslots--; doomcom->numslots--;
// Unmute slot if player was muted
player_muted[playernum] = false;
// Reset the name // Reset the name
sprintf(player_names[playernum], "Player %d", playernum+1); sprintf(player_names[playernum], "Player %d", playernum+1);
@@ -4191,6 +4303,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}; consvar_t cv_serverinfoscreen = {"serverinfoscreen", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_serveraddoninfo = {"serveraddoninfo", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
static void Got_AddPlayer(const UINT8 **p, INT32 playernum); static void Got_AddPlayer(const UINT8 **p, INT32 playernum);
static void Got_RemovePlayer(const UINT8 **p, INT32 playernum); static void Got_RemovePlayer(const UINT8 **p, INT32 playernum);
@@ -4263,7 +4377,7 @@ void D_ClientServerInit(void)
playerinfo[i].node = 255; playerinfo[i].node = 255;
gametic = 0; gametic = 0;
localgametic = 0; leveltime = 0;
// do not send anything before the real begin // do not send anything before the real begin
SV_StopServer(); SV_StopServer();
@@ -4335,6 +4449,7 @@ void SV_ResetServer(void)
pingmeasurecount = 1; pingmeasurecount = 1;
memset(realpingtable, 0, sizeof(realpingtable)); memset(realpingtable, 0, sizeof(realpingtable));
memset(playerpingtable, 0, sizeof(playerpingtable)); memset(playerpingtable, 0, sizeof(playerpingtable));
localplayerping = 0;
ClearAdminPlayers(); ClearAdminPlayers();
@@ -5519,7 +5634,7 @@ static void PT_ClientCmd(INT32 netconsole, SINT8 node)
realstart = ExpandTics(netbuffer->u.clientpak.client_tic, nettics[node]); realstart = ExpandTics(netbuffer->u.clientpak.client_tic, nettics[node]);
realend = ExpandTics(netbuffer->u.clientpak.resendfrom, nettics[node]); realend = ExpandTics(netbuffer->u.clientpak.resendfrom, nettics[node]);
if (netbuffer->packettype == PT_CLIENTMIS || netbuffer->packettype == PT_CLIENT2MIS if ( netbuffer->packettype == PT_CLIENTMIS || netbuffer->packettype == PT_CLIENT2MIS
|| netbuffer->packettype == PT_CLIENT3MIS || netbuffer->packettype == PT_CLIENT4MIS || netbuffer->packettype == PT_CLIENT3MIS || netbuffer->packettype == PT_CLIENT4MIS
|| netbuffer->packettype == PT_NODEKEEPALIVEMIS || netbuffer->packettype == PT_NODEKEEPALIVEMIS
|| supposedtics[node] < realend) || supposedtics[node] < realend)
@@ -5562,10 +5677,10 @@ static void PT_ClientCmd(INT32 netconsole, SINT8 node)
return; return;
// Splitscreen cmd // Splitscreen cmd
if (((netbuffer->packettype == PT_CLIENT2CMD || netbuffer->packettype == PT_CLIENT2MIS) if ((nodetoplayer2[node] >= 0) &&
((netbuffer->packettype == PT_CLIENT2CMD || netbuffer->packettype == PT_CLIENT2MIS)
|| (netbuffer->packettype == PT_CLIENT3CMD || netbuffer->packettype == PT_CLIENT3MIS) || (netbuffer->packettype == PT_CLIENT3CMD || netbuffer->packettype == PT_CLIENT3MIS)
|| (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS)) || (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS)))
&& (nodetoplayer2[node] >= 0))
{ {
G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer2[node]], &netbuffer->u.client2pak.cmd2, 1); G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer2[node]], &netbuffer->u.client2pak.cmd2, 1);
@@ -5573,9 +5688,9 @@ static void PT_ClientCmd(INT32 netconsole, SINT8 node)
return; return;
} }
if (((netbuffer->packettype == PT_CLIENT3CMD || netbuffer->packettype == PT_CLIENT3MIS) if ((nodetoplayer3[node] >= 0) &&
|| (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS)) ((netbuffer->packettype == PT_CLIENT3CMD || netbuffer->packettype == PT_CLIENT3MIS)
&& (nodetoplayer3[node] >= 0)) || (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS)))
{ {
G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer3[node]], &netbuffer->u.client3pak.cmd3, 1); G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer3[node]], &netbuffer->u.client3pak.cmd3, 1);
@@ -5583,8 +5698,8 @@ static void PT_ClientCmd(INT32 netconsole, SINT8 node)
return; return;
} }
if ((netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS) if ((nodetoplayer4[node] >= 0) &&
&& (nodetoplayer4[node] >= 0)) (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS))
{ {
G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer4[node]], &netbuffer->u.client4pak.cmd4, 1); G_MoveTiccmd(&playercmds[(UINT8)nodetoplayer4[node]], &netbuffer->u.client4pak.cmd4, 1);
@@ -5880,13 +5995,11 @@ static void PT_ServerTics(SINT8 node)
realend = gametic + CLIENTBACKUPTICS; realend = gametic + CLIENTBACKUPTICS;
cl_packetmissed = realstart > neededtic; cl_packetmissed = realstart > neededtic;
UINT8 *pak = (UINT8 *)&packet->cmds;
UINT8 *txtpak = (UINT8 *)&packet->cmds[packet->numslots * packet->numtics];
if (realstart <= neededtic && realend > neededtic) if (realstart <= neededtic && realend > neededtic)
{ {
tic_t i, j; tic_t i, j;
pak = (UINT8 *)&packet->cmds; UINT8 *pak = (UINT8 *)&packet->cmds;
UINT8 *txtpak = (UINT8 *)&packet->cmds[packet->numslots * packet->numtics];
for (i = realstart; i < realend; i++) for (i = realstart; i < realend; i++)
{ {
@@ -6723,7 +6836,7 @@ boolean TryRunTics(tic_t realtics)
{ {
boolean update_stats = !(paused || P_AutoPause()); boolean update_stats = !(paused || P_AutoPause());
DEBFILE(va("============ Running tic %d (local %d)\n", gametic, localgametic)); DEBFILE(va("============ Running tic %d (local %d)\n", gametic, leveltime));
if (update_stats) if (update_stats)
PS_START_TIMING(ps_tictime); PS_START_TIMING(ps_tictime);
@@ -6873,10 +6986,12 @@ static void UpdatePingTable(void)
INT32 i; INT32 i;
const boolean playing = Playing();
if (server) if (server)
{ {
//if (Playing() && !(gametime % 8)) // Value chosen based on _my vibes man_ << dont do this for v8 atleast, this is placeboeing ppl to hell and back //if (playing && !(gametime % 8)) // Value chosen based on _my vibes man_ << dont do this for v8 atleast, this is placeboeing ppl to hell and back
if (Playing() && !(gametime % 35)) // update once per second. if (playing && !(gametime % 35)) // update once per second.
PingUpdate(); PingUpdate();
fastest = 0; fastest = 0;
@@ -6935,6 +7050,10 @@ static void UpdatePingTable(void)
else else
lowest_lag = simulated_lag = 0; lowest_lag = simulated_lag = 0;
} }
// this is really dumb but oh well
if (playing && !(gametime % 35))
localplayerping = playerpingtable[consoleplayer];
} }
#ifdef HOLEPUNCH #ifdef HOLEPUNCH
+4
View File
@@ -600,6 +600,8 @@ extern consvar_t cv_discordinvites;
extern consvar_t cv_serverinfoscreen; extern consvar_t cv_serverinfoscreen;
extern consvar_t cv_serveraddoninfo;
// Used in d_net, the only dependence // Used in d_net, the only dependence
//tic_t ExpandTics(INT32 low, tic_t basetic); //tic_t ExpandTics(INT32 low, tic_t basetic);
void D_ClientServerInit(void); void D_ClientServerInit(void);
@@ -648,6 +650,8 @@ extern UINT8 playernode[MAXPLAYERS];
extern boolean player_muted[MAXPLAYERS]; extern boolean player_muted[MAXPLAYERS];
extern UINT32 localplayerping;
INT32 D_NumPlayers(void); INT32 D_NumPlayers(void);
void D_ResetTiccmds(void); void D_ResetTiccmds(void);
+41 -41
View File
@@ -138,6 +138,7 @@ boolean devparm = false; // started game with -devparm
boolean singletics = false; // timedemo boolean singletics = false; // timedemo
boolean lastdraw = false; boolean lastdraw = false;
boolean intermissionbginit = false;
#ifdef MOTIONBLUR #ifdef MOTIONBLUR
INT32 postimgparam[MAXSPLITSCREENPLAYERS]; INT32 postimgparam[MAXSPLITSCREENPLAYERS];
@@ -153,7 +154,7 @@ boolean music_disabled = false;
INT32 debugload = 0; INT32 debugload = 0;
#endif #endif
char savegamename[256]; char savegamename[256] = {};
char srb2home[256] = "."; char srb2home[256] = ".";
char srb2path[256] = "."; char srb2path[256] = ".";
@@ -362,6 +363,33 @@ static void D_Renderview(void)
// added comment : there is a wipe eatch change of the gamestate // added comment : there is a wipe eatch change of the gamestate
gamestate_t wipegamestate = GS_LEVEL; gamestate_t wipegamestate = GS_LEVEL;
static void D_MakeIntermissionBG(void)
{
if (!lastdraw)
return;
if (rendermode == render_none)
{
lastdraw = false;
intermissionbginit = false;
return;
}
#ifdef HWRENDER
if (rendermode == render_opengl)
{
HWR_MakeScreenTexture();
}
else
#endif
{
VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
}
lastdraw = false;
intermissionbginit = true;
}
static boolean D_Display(void) static boolean D_Display(void)
{ {
boolean ranwipe = false; boolean ranwipe = false;
@@ -527,16 +555,8 @@ static boolean D_Display(void)
PS_START_TIMING(ps_rendercalltime); PS_START_TIMING(ps_rendercalltime);
D_Renderview(); D_Renderview();
PS_STOP_TIMING(ps_rendercalltime); PS_STOP_TIMING(ps_rendercalltime);
}
if (lastdraw) D_MakeIntermissionBG();
{
if (rendermode == render_soft)
{
VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
}
lastdraw = false;
} }
PS_START_TIMING(ps_uitime); PS_START_TIMING(ps_uitime);
@@ -697,18 +717,17 @@ void D_SRB2Loop(void)
for (;;) for (;;)
{ {
if (I_Interrupted())
{
I_Quit();
}
// capbudget is the minimum precise_t duration of a single loop iteration // capbudget is the minimum precise_t duration of a single loop iteration
precise_t capbudget; precise_t capbudget;
precise_t elapsed; precise_t elapsed;
precise_t enterprecise, finishprecise; precise_t enterprecise, finishprecise;
boolean ranwipe = false;
enterprecise = I_GetPreciseTime(); enterprecise = I_GetPreciseTime();
I_HandleInterrupt();
memset(&g_dc, 0, sizeof(g_dc)); memset(&g_dc, 0, sizeof(g_dc));
Z_Frame_Reset(); Z_Frame_Reset();
@@ -716,8 +735,6 @@ void D_SRB2Loop(void)
const UINT32 framecap = R_GetFramerateCap(); const UINT32 framecap = R_GetFramerateCap();
capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round
boolean ranwipe = false;
I_UpdateTime(cv_timescale.value); I_UpdateTime(cv_timescale.value);
if (lastwipetic) if (lastwipetic)
@@ -1208,7 +1225,7 @@ void D_AddPostloadFiles(void)
static boolean AddIWAD(const char * file, const char *dir) static boolean AddIWAD(const char * file, const char *dir)
{ {
char * path = va(pandf, dir, file); char *path = va(pandf, dir, file);
if (FIL_ReadFileOK(path)) if (FIL_ReadFileOK(path))
{ {
@@ -1385,8 +1402,6 @@ static inline void D_MakeTitleString(char *s)
// extra graphic patches for saturn specific thingies // extra graphic patches for saturn specific thingies
boolean xtra_speedo = false; // extra speedometer check boolean xtra_speedo = false; // extra speedometer check
boolean xtra_speedo_clr = false; // extra speedometer colour check boolean xtra_speedo_clr = false; // extra speedometer colour check
boolean xtra_speedo3 = false; // 80x 11 extra speedometer check
boolean xtra_speedo_clr3 = false; // 80x 11 extra speedometer colour check
boolean achi_speedo = false; // achiiro speedometer check boolean achi_speedo = false; // achiiro speedometer check
boolean achi_speedo_clr = false; // extra speedometer colour check boolean achi_speedo_clr = false; // extra speedometer colour check
boolean dial_speedo = false; // dial speedometer check boolean dial_speedo = false; // dial speedometer check
@@ -1416,7 +1431,6 @@ static void D_CheckSaturnExtraFiles(void)
CV_PossibleValue_t minimapdot_cons_temp[NUMMINIMAPDOTSTUFF] = {{0, "Off"}, {0, NULL}, {0, NULL}, {0, NULL}, {0, NULL}}; CV_PossibleValue_t minimapdot_cons_temp[NUMMINIMAPDOTSTUFF] = {{0, "Off"}, {0, NULL}, {0, NULL}, {0, NULL}, {0, NULL}};
unsigned last_speedo_i = 0; unsigned last_speedo_i = 0;
unsigned last_driftgauge_i = 3;
unsigned last_inputdisplay_i = 2; unsigned last_inputdisplay_i = 2;
unsigned last_minimapdot_i = 0; unsigned last_minimapdot_i = 0;
#define PUSHCONS(cons, i, id, name) { ++i; cons[i].value = id; cons[i].strvalue = name; } #define PUSHCONS(cons, i, id, name) { ++i; cons[i].value = id; cons[i].strvalue = name; }
@@ -1575,20 +1589,6 @@ static void D_CheckSaturnExtraFiles(void)
if (found_extra3_kart) if (found_extra3_kart)
{ {
mainwads++; mainwads++;
// 80x11 speedometer crap
if (W_LumpExists("SP_SM3TC"))
{
xtra_speedo3 = true;
PUSHCONS(speedo_cons_temp, last_speedo_i, 7, "Extra");
PUSHCONS(driftgaugestyle_cons_temp, last_driftgauge_i, 5, "Extra");
}
// 80x11 speedometer crap but colour
if (W_LumpExists("SC_SM3TC"))
{
xtra_speedo_clr3 = true;
}
} }
#undef PUSHCONS #undef PUSHCONS
@@ -1786,10 +1786,6 @@ void D_SRB2Main(void)
// Setup default unlockable conditions // Setup default unlockable conditions
M_SetupDefaultConditionSets(); M_SetupDefaultConditionSets();
// Setup character tables
// Have to be done here before files are loaded
M_InitCharacterTables();
// load wad, including the main wad file // load wad, including the main wad file
CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n"); CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n");
@@ -2043,9 +2039,13 @@ void D_SRB2Main(void)
if (M_CheckProtoParam("replay")) if (M_CheckProtoParam("replay"))
{ {
const char *replayurl = M_GetProtoParam(); const char *replayurl = M_GetProtoParam();
if (!replayurl)
I_Error("REPLAY: Invalid URL.");
gconst char *replayname = strrchr(replayurl, '/'); gconst char *replayname = strrchr(replayurl, '/');
if (!replayname || !replayurl) if (!replayname)
I_Error("REPLAY: Invalid URL."); I_Error("REPLAY: Invalid URL.");
#define REPLAYDIR "/DownloadedReplays/" #define REPLAYDIR "/DownloadedReplays/"
@@ -2159,8 +2159,8 @@ void D_SRB2Main(void)
if (dedicated && server) if (dedicated && server)
{ {
levelstarttic = gametic;
G_SetGamestate(GS_LEVEL); G_SetGamestate(GS_LEVEL);
if (!P_SetupLevel(false, false)) if (!P_SetupLevel(false, false))
I_Quit(); // fail so reset game stuff I_Quit(); // fail so reset game stuff
} }
-2
View File
@@ -38,8 +38,6 @@ extern boolean found_extra3_kart; // for use in k_kart.c
extern boolean xtra_speedo; // extra speedometer check extern boolean xtra_speedo; // extra speedometer check
extern boolean xtra_speedo_clr; // extra speedometer colour check extern boolean xtra_speedo_clr; // extra speedometer colour check
extern boolean xtra_speedo3; // 80x11 extra speedometer check
extern boolean xtra_speedo_clr3; // 80x11 extra speedometer colour check
extern boolean achi_speedo; // achiiro speedometer check extern boolean achi_speedo; // achiiro speedometer check
extern boolean achi_speedo_clr; // extra speedometer colour check extern boolean achi_speedo_clr; // extra speedometer colour check
extern boolean dial_speedo; // dial speedometer check extern boolean dial_speedo; // dial speedometer check
-1
View File
@@ -27,7 +27,6 @@ extern "C" {
// SINT8 is used for nodes sometimes >:( // SINT8 is used for nodes sometimes >:(
#define MAXNETNODES 127 #define MAXNETNODES 127
#define BROADCASTADDR MAXNETNODES #define BROADCASTADDR MAXNETNODES
#define NETSPLITSCREEN // Kart's splitscreen netgame feature
#define STATLENGTH (TICRATE*2) #define STATLENGTH (TICRATE*2)
+61 -28
View File
@@ -900,6 +900,7 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_mindelay); CV_RegisterVar(&cv_mindelay);
CV_RegisterVar(&cv_gentlemens); CV_RegisterVar(&cv_gentlemens);
CV_RegisterVar(&cv_serverinfoscreen); CV_RegisterVar(&cv_serverinfoscreen);
CV_RegisterVar(&cv_serveraddoninfo);
#ifdef NETGAME_DEVMODE #ifdef NETGAME_DEVMODE
CV_RegisterVar(&cv_fishcake); CV_RegisterVar(&cv_fishcake);
@@ -1009,6 +1010,7 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_gamepadled[i]); CV_RegisterVar(&cv_gamepadled[i]);
} }
CV_RegisterVar(&cv_gamepadifunfocused);
CV_RegisterVar(&cv_gamepadledifunfocused); CV_RegisterVar(&cv_gamepadledifunfocused);
CV_RegisterVar(&cv_rumbleifunfocused); CV_RegisterVar(&cv_rumbleifunfocused);
@@ -1212,13 +1214,22 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
if (len == 0 || len > MAXPLAYERNAME) if (len == 0 || len > MAXPLAYERNAME)
return false; // Empty or too long. return false; // Empty or too long.
if (name[0] == ' ' || name[len-1] == ' ') if (name[0] == ' ')
return false; // Starts or ends with a space. return false; // Starts with a space.
if (isdigit(name[0])) if (isdigit(name[0]))
return false; // Starts with a digit. return false; // Starts with a digit.
if (name[0] == '@' || name[0] == '~') if (name[0] == '@' || name[0] == '~')
return false; // Starts with an admin symbol. return false; // Starts with an admin symbol.
// Clean up trailing whitespace.
while (len && name[len-1] == ' ')
{
name[len-1] = '\0';
len--;
}
if (len == 0)
return false;
// Check if it contains a non-printing character. // Check if it contains a non-printing character.
// Note: ANSI C isprint() considers space a printing character. // Note: ANSI C isprint() considers space a printing character.
// Also don't allow semicolons, since they are used as // Also don't allow semicolons, since they are used as
@@ -1271,7 +1282,8 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
* is restored to what it was before. * is restored to what it was before.
* *
* We assume that if playernum is ::consoleplayer or ::secondarydisplayplayer * We assume that if playernum is ::consoleplayer or ::secondarydisplayplayer
* the console variable ::cv_playername or ::cv_playername2 respectively is * (unless clientjoin is true, a necessary evil)
* the console variable ::cv_playername to ::cv_playername4 respectively is
* already set to newname. However, the player name table is assumed to * already set to newname. However, the player name table is assumed to
* contain the old name. * contain the old name.
* *
@@ -1291,6 +1303,10 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
char *tmpname = NULL; char *tmpname = NULL;
INT32 i; INT32 i;
boolean namefailed = true; boolean namefailed = true;
boolean clientjoin = !!(playernum >= MAXPLAYERS);
if (clientjoin)
playernum -= MAXPLAYERS;
buf = Z_StrDup(newname); buf = Z_StrDup(newname);
@@ -1347,17 +1363,20 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
} }
// no stealing another player's name // no stealing another player's name
for (i = 0; i < MAXPLAYERS; i++) if (!clientjoin)
{ {
if (i != playernum && playeringame[i] for (i = 0; i < MAXPLAYERS; i++)
&& fasticmp(tmpname, player_names[i]))
{ {
break; if (i != playernum && playeringame[i]
&& fasticmp(tmpname, player_names[i]))
{
break;
}
} }
}
if (i < MAXPLAYERS) if (i < MAXPLAYERS)
break; break;
}
// name is okay then // name is okay then
namefailed = false; namefailed = false;
@@ -1368,15 +1387,23 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
// set consvars whether namefailed or not, because even if it succeeded, // set consvars whether namefailed or not, because even if it succeeded,
// spaces may have been removed // spaces may have been removed
if (playernum == consoleplayer) if (clientjoin)
CV_StealthSet(&cv_playername, tmpname); {
else if (playernum == displayplayers[1] || (!netgame && playernum == 1)) consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
CV_StealthSet(&cv_playername2, tmpname); CV_StealthSet(namevars[playernum], tmpname);
else if (playernum == displayplayers[2] || (!netgame && playernum == 2)) }
CV_StealthSet(&cv_playername3, tmpname); else
else if (playernum == displayplayers[3] || (!netgame && playernum == 3)) {
CV_StealthSet(&cv_playername4, tmpname); if (playernum == consoleplayer)
else I_Assert(((void)"CleanupPlayerName used on non-local player", 0)); CV_StealthSet(&cv_playername, tmpname);
else if (playernum == displayplayers[1] || (!netgame && playernum == 1))
CV_StealthSet(&cv_playername2, tmpname);
else if (playernum == displayplayers[2] || (!netgame && playernum == 2))
CV_StealthSet(&cv_playername3, tmpname);
else if (playernum == displayplayers[3] || (!netgame && playernum == 3))
CV_StealthSet(&cv_playername4, tmpname);
else I_Assert(((void)"CleanupPlayerName used on non-local player", 0));
}
Z_Free(buf); Z_Free(buf);
} }
@@ -1494,7 +1521,9 @@ static void ForceAllSkins(INT32 forcedskin)
} }
static INT32 chmappending; static INT32 chmappending;
#ifdef PARANOIA
static INT32 snacpending[MAXSPLITSCREENPLAYERS]; static INT32 snacpending[MAXSPLITSCREENPLAYERS];
#endif
// wonky compat, idk if anything uses this.... // wonky compat, idk if anything uses this....
#define playerisbot (splitplayer == 1 && botingame) #define playerisbot (splitplayer == 1 && botingame)
@@ -1594,7 +1623,9 @@ static void SendNameAndColor(UINT8 splitplayer)
return; return;
} }
#ifdef PARANOIA
snacpending[splitplayer]++; snacpending[splitplayer]++;
#endif
// Don't change name if muted // Don't change name if muted
if (player_name_changes[pnum] >= MAXNAMECHANGES) if (player_name_changes[pnum] >= MAXNAMECHANGES)
@@ -1630,8 +1661,8 @@ static void SendNameAndColor(UINT8 splitplayer)
static void Got_NameAndColor(const UINT8 **cp, INT32 playernum) static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
{ {
player_t *player = &players[playernum]; player_t *player;
char name[MAXPLAYERNAME+1]; char name[MAXPLAYERNAME+1] = {};
UINT8 color, skin; UINT8 color, skin;
#ifdef PARANOIA #ifdef PARANOIA
@@ -1639,14 +1670,18 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
I_Error("There is no player %d!", playernum); I_Error("There is no player %d!", playernum);
#endif #endif
player = &players[playernum];
#ifdef PARANOIA
if (P_IsLocalPlayer(player)) if (P_IsLocalPlayer(player))
{ {
snacpending[playernum]--; const INT32 localpnum = P_GetLocalPlayerNumForPlayer(player);
#ifdef PARANOIA snacpending[localpnum]--;
if (snacpending[playernum] < 0)
I_Error("snacpending negative!"); if (snacpending[localpnum] < 0)
#endif I_Error("snacpending negative for player %d!", localpnum);
} }
#endif
READSTRINGN(*cp, name, MAXPLAYERNAME); READSTRINGN(*cp, name, MAXPLAYERNAME);
color = READUINT8(*cp); color = READUINT8(*cp);
@@ -2187,7 +2222,6 @@ void D_SetupVote(void)
WRITEUINT8(p, secondgt); WRITEUINT8(p, secondgt);
secondgt &= ~0x80; secondgt &= ~0x80;
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
{ {
UINT16 m; UINT16 m;
@@ -5814,7 +5848,6 @@ static void BaseNumLaps_OnChange(void)
} }
} }
static void KartFrantic_OnChange(void) static void KartFrantic_OnChange(void)
{ {
if ((boolean)cv_kartfrantic.value != franticitems && gamestate == GS_LEVEL && leveltime > starttime) if ((boolean)cv_kartfrantic.value != franticitems && gamestate == GS_LEVEL && leveltime > starttime)
+1 -9
View File
@@ -51,10 +51,6 @@ extern consvar_t cv_mousevisible;
//WTF //WTF
extern consvar_t cv_mouseturn; extern consvar_t cv_mouseturn;
extern consvar_t cv_usejoystick[4]; //MAXSPLITSCREENPLAYERS extern consvar_t cv_usejoystick[4]; //MAXSPLITSCREENPLAYERS
#ifdef LJOYSTICK
extern consvar_t cv_joyport;
extern consvar_t cv_joyport2;
#endif
extern consvar_t cv_joyscale[4]; //MAXSPLITSCREENPLAYERS extern consvar_t cv_joyscale[4]; //MAXSPLITSCREENPLAYERS
// normally in p_mobj but the .h is not read // normally in p_mobj but the .h is not read
@@ -93,11 +89,6 @@ extern consvar_t cv_pause;
extern consvar_t cv_restrictskinchange, cv_allowteamchange, cv_ingamecap, cv_respawntime; extern consvar_t cv_restrictskinchange, cv_allowteamchange, cv_ingamecap, cv_respawntime;
extern consvar_t cv_spectatorreentry, cv_antigrief; extern consvar_t cv_spectatorreentry, cv_antigrief;
/*extern consvar_t cv_teleporters, cv_superring, cv_supersneakers, cv_invincibility;
extern consvar_t cv_jumpshield, cv_watershield, cv_ringshield, cv_forceshield, cv_bombshield;
extern consvar_t cv_1up, cv_eggmanbox;
extern consvar_t cv_recycler;*/
// SRB2kart items // SRB2kart items
extern consvar_t cv_sneaker, cv_rocketsneaker, cv_invincibility, cv_banana; extern consvar_t cv_sneaker, cv_rocketsneaker, cv_invincibility, cv_banana;
extern consvar_t cv_eggmanmonitor, cv_orbinaut, cv_jawz, cv_mine; extern consvar_t cv_eggmanmonitor, cv_orbinaut, cv_jawz, cv_mine;
@@ -155,6 +146,7 @@ extern consvar_t cv_pingstyle;
//extern consvar_t cv_smallpos; //extern consvar_t cv_smallpos;
extern consvar_t cv_showminimapnames; extern consvar_t cv_showminimapnames;
extern consvar_t cv_showminimapfinished;
extern consvar_t cv_minihead; extern consvar_t cv_minihead;
extern consvar_t cv_showminimapangle; extern consvar_t cv_showminimapangle;
+83 -20
View File
@@ -116,6 +116,8 @@ static I_mutex downloadmutex;
#endif #endif
char downloaddir[512] = "DOWNLOAD"; char downloaddir[512] = "DOWNLOAD";
INT32 addontypes[NUMADDONTYPES] = {0};
file_download_t filedownload = {}; file_download_t filedownload = {};
#ifdef HAVE_CURL #ifdef HAVE_CURL
@@ -135,6 +137,8 @@ HTTP_login *curl_logins = NULL;
static void CURLGetFile(void); static void CURLGetFile(void);
#endif #endif
static addontype_t GetAddonType(const char *name);
/** Fills a serverinfo packet with information about wad files loaded. /** Fills a serverinfo packet with information about wad files loaded.
* *
* \todo Give this function a better name since it is in global scope. * \todo Give this function a better name since it is in global scope.
@@ -163,7 +167,9 @@ UINT8 *PutFileNeeded(UINT16 firstfile)
continue; continue;
} }
nameonly(strcpy(wadfilename, wadfiles[i]->filename)); strncpy(wadfilename, wadfiles[i]->filename, MAX_WADPATH);
wadfilename[MAX_WADPATH-1] = '\0';
nameonly(wadfilename);
// Look below at the WRITE macros to understand what these numbers mean. // Look below at the WRITE macros to understand what these numbers mean.
const size_t len = strlen(wadfilename) + 1; const size_t len = strlen(wadfilename) + 1;
@@ -225,8 +231,11 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
fileneeded[i].willsend = (UINT8)(filestatus >> 4); fileneeded[i].willsend = (UINT8)(filestatus >> 4);
fileneeded[i].totalsize = READUINT32(p); // The four next bytes are the file size fileneeded[i].totalsize = READUINT32(p); // The four next bytes are the file size
fileneeded[i].file = NULL; // The file isn't open yet fileneeded[i].file = NULL; // The file isn't open yet
READSTRINGN(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name READSTRINGL(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name
READMEM(p, fileneeded[i].md5sum, 16); // The last 16 bytes are the file checksum READMEM(p, fileneeded[i].md5sum, 16); // The last 16 bytes are the file checksum
// Should be good place to calculate that?
fileneeded[i].type = GetAddonType(fileneeded[i].filename);
} }
} }
@@ -250,9 +259,10 @@ void CL_PrepareDownloadSaveGame(const char *tmpsave)
*/ */
boolean CL_CheckDownloadable(void) boolean CL_CheckDownloadable(void)
{ {
UINT8 i,dlstatus = 0; UINT8 i, dlstatus = 0;
for (i = 0; i < fileneedednum; i++) for (i = 0; i < fileneedednum; i++)
{
if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN) if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
{ {
if (fileneeded[i].willsend == 1) if (fileneeded[i].willsend == 1)
@@ -263,6 +273,7 @@ boolean CL_CheckDownloadable(void)
else //if (fileneeded[i].willsend == 2) else //if (fileneeded[i].willsend == 2)
dlstatus = 2; dlstatus = 2;
} }
}
// Downloading locally disabled // Downloading locally disabled
if (!dlstatus && M_CheckParm("-nodownload")) if (!dlstatus && M_CheckParm("-nodownload"))
@@ -273,15 +284,17 @@ boolean CL_CheckDownloadable(void)
// not downloadable, put reason in console // not downloadable, put reason in console
CONS_Alert(CONS_NOTICE, M_GetText("You need additional files to connect to this server:\n")); CONS_Alert(CONS_NOTICE, M_GetText("You need additional files to connect to this server:\n"));
for (i = 0; i < fileneedednum; i++) for (i = 0; i < fileneedednum; i++)
{
if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN) if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
{ {
CONS_Printf(" * \"%s\" (%dK)", fileneeded[i].filename, fileneeded[i].totalsize >> 10); CONS_Printf(" * \"%s\" (%dK)", fileneeded[i].filename, fileneeded[i].totalsize >> 10);
if (fileneeded[i].status == FS_MD5SUMBAD) if (fileneeded[i].status == FS_MD5SUMBAD)
CONS_Printf(M_GetText(" wrong version, md5: ")); CONS_Printf(M_GetText(" wrong version, md5: "));
else else
CONS_Printf(M_GetText(" not found, md5: ")); CONS_Printf(M_GetText(" not found, md5: "));
{ {
INT32 j; INT32 j;
@@ -292,6 +305,7 @@ boolean CL_CheckDownloadable(void)
} }
CONS_Printf("\n"); CONS_Printf("\n");
} }
}
switch (dlstatus) switch (dlstatus)
{ {
@@ -305,6 +319,7 @@ boolean CL_CheckDownloadable(void)
CONS_Printf(M_GetText("All files downloadable, but you have chosen to disable downloading locally.\n")); CONS_Printf(M_GetText("All files downloadable, but you have chosen to disable downloading locally.\n"));
break; break;
} }
return false; return false;
} }
@@ -542,7 +557,7 @@ INT32 CL_CheckFiles(void)
if (fileneeded[i].status != FS_OPEN) if (fileneeded[i].status != FS_OPEN)
filestoload++; filestoload++;
if (fileneeded[i].status != FS_NOTCHECKED) //since we're running this over multiple tics now, its possible for us to come across files checked in previous tics if (fileneeded[i].status != FS_NOTCHECKED) // since we're running this over multiple tics now, its possible for us to come across files checked in previous tics
continue; continue;
CONS_Debug(DBG_NETPLAY, "searching for '%s' ", fileneeded[i].filename); CONS_Debug(DBG_NETPLAY, "searching for '%s' ", fileneeded[i].filename);
@@ -550,14 +565,18 @@ INT32 CL_CheckFiles(void)
// Check in already loaded files // Check in already loaded files
for (j = mainwads+1; j < numwadfiles; j++) for (j = mainwads+1; j < numwadfiles; j++)
{ {
nameonly(strcpy(wadfilename, wadfiles[j]->filename)); if (!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
if (fasticmp(wadfilename, fileneeded[i].filename) &&
!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
{ {
CONS_Debug(DBG_NETPLAY, "already loaded\n"); strncpy(wadfilename, wadfiles[j]->filename, MAX_WADPATH);
fileneeded[i].status = FS_OPEN; wadfilename[MAX_WADPATH-1] = '\0';
return 4; nameonly(wadfilename);
if (fasticmp(wadfilename, fileneeded[i].filename))
{
CONS_Debug(DBG_NETPLAY, "already loaded\n");
fileneeded[i].status = FS_OPEN;
return 4;
}
} }
} }
@@ -575,6 +594,48 @@ INT32 CL_CheckFiles(void)
return 1; //everything is FS_OPEN or FS_FOUND, proceed to loading return 1; //everything is FS_OPEN or FS_FOUND, proceed to loading
} }
static addontype_t GetAddonType(const char *name)
{
const char *prefix = strchr(name, '_');
// Doesn't have prefix (no '_' character or it is too far and is probably not for prefix but for something like version)
// KRBCL_ is longest prefix i can think of so this should be enough
if (prefix == NULL || prefix - name > 5)
return ADDON_MISC;
// Skip 'K'
if (*name == 'K')
++name;
switch (*name)
{
case 'L':
return ADDON_SCRIPT;
break;
case 'R':
case 'B':
return ADDON_MAP;
break;
case 'C':
return ADDON_CHARACTER;
break;
}
return ADDON_MISC;
}
void CL_CheckAddonTypes(void)
{
memset(&addontypes, 0, sizeof(addontypes));
for (INT32 i = 0; i < fileneedednum; i++)
{
addontypes[fileneeded[i].type]++;
}
}
// Load it now // Load it now
boolean CL_LoadServerFiles(void) boolean CL_LoadServerFiles(void)
{ {
@@ -596,7 +657,7 @@ boolean CL_LoadServerFiles(void)
else else
{ {
const char *s; const char *s;
switch(fileneeded[i].status) switch (fileneeded[i].status)
{ {
case FS_NOTFOUND: case FS_NOTFOUND:
s = "FS_NOTFOUND"; s = "FS_NOTFOUND";
@@ -639,7 +700,7 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
char wadfilename[MAX_WADPATH]; char wadfilename[MAX_WADPATH];
if (cv_noticedownload.value) if (cv_noticedownload.value && I_GetNodeAddress)
CONS_Printf("Sending file \"%s\" (id %d) to node %d (%s)\n", filename, fileid, node, I_GetNodeAddress(node)); CONS_Printf("Sending file \"%s\" (id %d) to node %d (%s)\n", filename, fileid, node, I_GetNodeAddress(node));
// Find the last file in the list and set a pointer to its "next" field // Find the last file in the list and set a pointer to its "next" field
@@ -664,7 +725,9 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
// Look for the requested file through all loaded files // Look for the requested file through all loaded files
for (wadnum = 0; wadfiles[wadnum]; wadnum++) for (wadnum = 0; wadfiles[wadnum]; wadnum++)
{ {
strlcpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH); // im a certified strlcpy hater
strncpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH);
wadfilename[MAX_WADPATH-1] = '\0';
nameonly(wadfilename); nameonly(wadfilename);
if (fasticmp(wadfilename, p->id.filename)) if (fasticmp(wadfilename, p->id.filename))
@@ -1017,7 +1080,7 @@ void Got_Filetxpak(void)
{ {
const char *s; const char *s;
switch(file->status) switch (file->status)
{ {
case FS_NOTFOUND: case FS_NOTFOUND:
s = "FS_NOTFOUND"; s = "FS_NOTFOUND";
@@ -1145,7 +1208,7 @@ filestatus_t checkfilemd5(char *filename, const UINT8 *wantedmd5sum)
fhandle = fopen(filename, "rb"); fhandle = fopen(filename, "rb");
if (fhandle) if (fhandle)
{ {
md5_stream(fhandle,md5sum); md5_stream(fhandle, md5sum);
fclose(fhandle); fclose(fhandle);
if (!memcmp(wantedmd5sum, md5sum, 16)) if (!memcmp(wantedmd5sum, md5sum, 16))
return FS_FOUND; return FS_FOUND;
+12
View File
@@ -40,6 +40,15 @@ typedef enum
FS_FALLBACK, // HTTP failed FS_FALLBACK, // HTTP failed
} filestatus_t; } filestatus_t;
typedef enum addontype_e
{
ADDON_SCRIPT,
ADDON_MAP,
ADDON_CHARACTER,
ADDON_MISC,
NUMADDONTYPES,
} addontype_t;
typedef struct typedef struct
{ {
UINT8 willsend; // Is the server willing to send it? UINT8 willsend; // Is the server willing to send it?
@@ -51,11 +60,13 @@ typedef struct
UINT32 totalsize; UINT32 totalsize;
filestatus_t status; // The value returned by recsearch filestatus_t status; // The value returned by recsearch
boolean justdownloaded; // To prevent late fragments from causing an I_Error boolean justdownloaded; // To prevent late fragments from causing an I_Error
addontype_t type;
} fileneeded_t; } fileneeded_t;
extern INT32 fileneedednum; extern INT32 fileneedednum;
extern fileneeded_t fileneeded[MAX_WADFILES]; extern fileneeded_t fileneeded[MAX_WADFILES];
extern char downloaddir[512]; extern char downloaddir[512];
extern INT32 addontypes[NUMADDONTYPES];
typedef struct typedef struct
{ {
@@ -91,6 +102,7 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
void CL_PrepareDownloadSaveGame(const char *tmpsave); void CL_PrepareDownloadSaveGame(const char *tmpsave);
INT32 CL_CheckFiles(void); INT32 CL_CheckFiles(void);
void CL_CheckAddonTypes(void);
boolean CL_LoadServerFiles(void); boolean CL_LoadServerFiles(void);
void SV_SendRam(INT32 node, void *data, size_t size, freemethod_t freemethod, void SV_SendRam(INT32 node, void *data, size_t size, freemethod_t freemethod,
UINT8 fileid); UINT8 fileid);
+42 -14
View File
@@ -735,6 +735,22 @@ const char *I_GetJoyName(INT32 joyindex)
return NULL; return NULL;
} }
void I_SetJoystickFocus(void)
{
}
boolean I_GamepadHasLED(INT32 playernum)
{
(void)playernum;
return false;
}
boolean I_GamepadHasRumble(INT32 playernum)
{
(void)playernum;
return false;
}
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration) void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
{ {
(void)playernum; (void)playernum;
@@ -1007,8 +1023,13 @@ static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_ms
sigmsg = ("SIGSEGV - SRB2Kart-Saturn has attempted to access a memory location that it shouldn't and needs to close."); sigmsg = ("SIGSEGV - SRB2Kart-Saturn has attempted to access a memory location that it shouldn't and needs to close.");
break; break;
#ifdef SIGTERM #ifdef SIGTERM
case SIGTERM: // Software termination signal from kill case SIGTERM: // Software termination signal from terminate
sigmsg = ("SIGTERM - SRB2Kart-Saturn was terminated by a kill signal."); sigmsg = ("SIGTERM - SRB2Kart-Saturn was terminated by a terminate signal.");
break;
#endif
#ifdef SIGKILL
case SIGKILL: // Software termination signal from kill
sigmsg = ("SIGKILL - SRB2Kart-Saturn was terminated by a kill signal.");
break; break;
#endif #endif
#ifdef SIGBREAK #ifdef SIGBREAK
@@ -1341,18 +1362,28 @@ static void I_Fork(void)
I_RegisterChildSignals(); I_RegisterChildSignals();
break; break;
default: default:
// ignore those, those are handled by child process
// otherwise parent might exit before it
// and the below stuff wont run and your terminal will be left in an awkward state
#ifdef SIGINT
signal(SIGINT, SIG_IGN);
#endif
#ifdef SIGBREAK
signal(SIGBREAK, SIG_IGN);
#endif
#ifdef SIGTERM
signal(SIGTERM, SIG_IGN);
#endif
if (logstream) if (logstream)
fclose(logstream);/* the child has this */ fclose(logstream);/* the child has this */
c = wait(&status); c = wait(&status);
#ifdef LOGMESSAGES #ifdef LOGMESSAGES
/* By the way, exit closes files. */ /* By the way, exit closes files. */
logstream = fopen(logfilename, "at"); logstream = fopen(logfilename, "at");
#else #else
logstream = 0; logstream = 0;
#endif #endif
if (c == -1) if (c == -1)
{ {
kill(child, SIGKILL); kill(child, SIGKILL);
@@ -1384,7 +1415,6 @@ static void I_Fork(void)
INT32 I_StartupSystem(void) INT32 I_StartupSystem(void)
{ {
W_Startup();
I_StartupConsole(); I_StartupConsole();
#ifdef NEWSIGNALHANDLER #ifdef NEWSIGNALHANDLER
// This is useful when debugging. It lets GDB attach to // This is useful when debugging. It lets GDB attach to
@@ -1413,8 +1443,8 @@ void I_Quit(void)
/* prevent recursive I_Quit() */ /* prevent recursive I_Quit() */
if (quiting) if (quiting)
goto death; goto death;
quiting = false; quiting = false;
I_ShutdownConsole();
M_SaveConfig(NULL); //save game config, cvars.. M_SaveConfig(NULL); //save game config, cvars..
D_SaveBan(); // save the ban list D_SaveBan(); // save the ban list
G_SaveGameData(false); // Tails 12-08-2002 G_SaveGameData(false); // Tails 12-08-2002
@@ -1430,16 +1460,18 @@ void I_Quit(void)
// use this for 1.28 19990220 by Kin // use this for 1.28 19990220 by Kin
I_ShutdownGraphics(); I_ShutdownGraphics();
I_ShutdownSystem(); I_ShutdownSystem();
/* if option -noendtxt is set, don't print the text */ /* if option -noendtxt is set, don't print the text */
if (!M_CheckParm("-noendtxt") && W_CheckNumForName("ENDOOM") != LUMPERROR) if (!M_CheckParm("-noendtxt") && W_CheckNumForName("ENDOOM") != LUMPERROR)
{ {
printf("\r"); printf("\r");
ShowEndTxt(); ShowEndTxt();
} }
if (myargmalloc) if (myargmalloc)
free(myargv); // Deallocate allocated memory free(myargv); // Deallocate allocated memory
death: death:
W_Shutdown();
exit(0); exit(0);
} }
@@ -1485,7 +1517,6 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
I_OutputMsg("SRB2Kart %s Recursive Error", buffer); I_OutputMsg("SRB2Kart %s Recursive Error", buffer);
W_Shutdown();
exit(-1); // recursive errors detected exit(-1); // recursive errors detected
} }
} }
@@ -1503,8 +1534,6 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
#endif #endif
// --- // ---
I_ShutdownConsole();
M_SaveConfig(NULL); // save game config, cvars.. M_SaveConfig(NULL); // save game config, cvars..
D_SaveBan(); // save the ban list D_SaveBan(); // save the ban list
G_SaveGameData(false); // Tails 12-08-2002 G_SaveGameData(false); // Tails 12-08-2002
@@ -1520,8 +1549,6 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
I_ShutdownGraphics(); I_ShutdownGraphics();
I_ShutdownSystem(); I_ShutdownSystem();
W_Shutdown();
#if defined (PARANOIA) && defined (__CYGWIN__) #if defined (PARANOIA) && defined (__CYGWIN__)
*(INT32 *)2 = 4; //Alam: Debug! *(INT32 *)2 = 4; //Alam: Debug!
#endif #endif
@@ -1627,9 +1654,10 @@ void I_ShutdownSystem(void)
{ {
INT32 c; INT32 c;
#ifndef NEWSIGNALHANDLER #ifdef NEWSIGNALHANDLER
I_ShutdownConsole(); if (M_CheckParm("-nofork"))
#endif #endif
I_ShutdownConsole();
for (c = MAX_QUIT_FUNCS-1; c >= 0; c--) for (c = MAX_QUIT_FUNCS-1; c >= 0; c--)
if (quit_funcs[c]) if (quit_funcs[c])
+282 -338
View File
File diff suppressed because it is too large. Load diff
+4 -2
View File
@@ -61,7 +61,7 @@ enum
typedef struct typedef struct
{ {
INT16 x, y; INT16 x, y;
}ATTRPACK mapvertex_t; } ATTRPACK mapvertex_t;
// A SideDef, defining the visual appearance of a wall, // A SideDef, defining the visual appearance of a wall,
// by setting textures and offsets. // by setting textures and offsets.
@@ -81,10 +81,12 @@ typedef struct
INT16 flags; INT16 flags;
INT16 special; INT16 special;
INT16 tag; INT16 tag;
// sidenum[1] will be 0xffff if one sided // sidenum[1] will be NO_INDEX if one sided
UINT16 sidenum[2]; UINT16 sidenum[2];
} ATTRPACK maplinedef_t; } ATTRPACK maplinedef_t;
#define NO_INDEX 0xffff
// //
// LineDef attributes. // LineDef attributes.
// //
+20 -2
View File
@@ -130,8 +130,8 @@ extern char logfilename[1024];
#else #else
#define VERSION 1 // Game version #define VERSION 1 // Game version
#define SUBVERSION 6 // more precise version number #define SUBVERSION 6 // more precise version number
#define VERSIONSTRING "Saturn v9.2" #define VERSIONSTRING "Saturn v9.3"
#define VERSIONSTRINGW L"Saturn v9.2" #define VERSIONSTRINGW L"Saturn v9.3"
#define SATURN_TESTING // comment out for saturn release builds! #define SATURN_TESTING // comment out for saturn release builds!
@@ -573,6 +573,13 @@ INT32 I_GetKey(void);
// NOTE: you WILL have nasal troubles if the variable is not initialized // NOTE: you WILL have nasal troubles if the variable is not initialized
#define CLEANUP(f) __attribute__((__cleanup__(f))) #define CLEANUP(f) __attribute__((__cleanup__(f)))
// the GNU constructor and destructor attributes
// The constructor attribute causes the function to be called automatically before execution enters main ().
// Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called.
// Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.
#define CONSTRUCTOR __attribute__((constructor, used))
#define DESTRUCTOR __attribute__((destructor, used))
// An assert-type mechanism. // An assert-type mechanism.
#ifdef PARANOIA #ifdef PARANOIA
#define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__)) #define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__))
@@ -595,6 +602,9 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
// None of these that are disabled in the normal build are guaranteed to work perfectly // None of these that are disabled in the normal build are guaranteed to work perfectly
// Compile them at your own risk! // Compile them at your own risk!
// undefine to enable fixes and features that are not vanilla compatible
#define COMPAT_VANILLA
//-- SATURN __ //-- SATURN __
/// Detect if a client is on Saturn in the clientconfig. /// Detect if a client is on Saturn in the clientconfig.
/// To seperately allow them to join or block joining from vanilla clients. /// To seperately allow them to join or block joining from vanilla clients.
@@ -659,6 +669,14 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
#undef UPDATE_ALERT #undef UPDATE_ALERT
#endif #endif
// overwrite some of those
// when not compiling in vanilla compat mode
#ifndef COMPAT_VANILLA
#define SATURNJOIN
#define SATURNPAK
#undef SEENAMES
#endif
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif
+4 -46
View File
@@ -54,7 +54,6 @@ extern INT16 maptol;
extern UINT8 globalweather; extern UINT8 globalweather;
extern INT32 curWeather; extern INT32 curWeather;
extern INT32 cursaveslot; extern INT32 cursaveslot;
extern INT16 lastmapsaved;
extern boolean gamecomplete; extern boolean gamecomplete;
#define PRECIP_NONE 0 #define PRECIP_NONE 0
@@ -78,7 +77,6 @@ extern boolean imcontinuing; // Temporary flag while continuing
extern UINT8 modeattacking; extern UINT8 modeattacking;
// menu demo things // menu demo things
extern UINT8 numDemos;
extern UINT32 demoDelayTime; extern UINT32 demoDelayTime;
extern UINT32 demoIdleTime; extern UINT32 demoIdleTime;
@@ -114,8 +112,8 @@ extern UINT8 paused; // Game paused?
extern UINT8 window_notinfocus; // are we in focus? (backend independant -- handles auto pausing and display of "focus lost" message) extern UINT8 window_notinfocus; // are we in focus? (backend independant -- handles auto pausing and display of "focus lost" message)
extern boolean nodrawers; extern boolean nodrawers;
extern boolean noblit;
extern boolean lastdraw; extern boolean lastdraw;
extern boolean intermissionbginit;
#ifdef MOTIONBLUR #ifdef MOTIONBLUR
extern INT32 postimgparam[MAXSPLITSCREENPLAYERS]; extern INT32 postimgparam[MAXSPLITSCREENPLAYERS];
@@ -205,12 +203,6 @@ extern struct quake
fixed_t radius, intensity; fixed_t radius, intensity;
} quake; } quake;
// NiGHTS grades
typedef struct
{
UINT32 grade[6]; // D, C, B, A, S, X (F: failed to reach any of these)
} nightsgrades_t;
// Custom Lua values // Custom Lua values
// (This is not ifdeffed so the map header structure can stay identical, just in case.) // (This is not ifdeffed so the map header structure can stay identical, just in case.)
typedef struct typedef struct
@@ -261,28 +253,16 @@ typedef struct
UINT8 numlaps; ///< Number of laps in circuit mode, unless overridden. UINT8 numlaps; ///< Number of laps in circuit mode, unless overridden.
SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no. SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no.
UINT8 levelselect; ///< Is this map available in the level select? If so, which map list is it available in? UINT8 levelselect; ///< Is this map available in the level select? If so, which map list is it available in?
SINT8 bonustype; ///< What type of bonus does this level have? (-1 for null.)
SINT8 saveoverride; ///< Set how the game is allowed to save (1 for always, -1 for never, 0 is 2.1 default)
UINT8 levelflags; ///< LF_flags: merged eight booleans into one UINT8 for space, see below UINT8 levelflags; ///< LF_flags: merged eight booleans into one UINT8 for space, see below
UINT8 menuflags; ///< LF2_flags: options that affect record attack / nights mode menus UINT8 menuflags; ///< LF2_flags: options that affect record attack / nights mode menus
// NiGHTS stuff.
UINT8 numGradedMares; ///< Internal. For grade support.
nightsgrades_t *grades; ///< NiGHTS grades. Allocated dynamically for space reasons. Be careful.
// SRB2kart // SRB2kart
//boolean automap; ///< Displays a level's white map outline in modified games
fixed_t mobj_scale; ///< Replacement for TOL_ERZ3 fixed_t mobj_scale; ///< Replacement for TOL_ERZ3
mapheader_lighting_t lighting; ///< Wall and sprite lighting mapheader_lighting_t lighting; ///< Wall and sprite lighting
mapheader_lighting_t lighting_encore; ///< Alternative lighting for Encore mode mapheader_lighting_t lighting_encore; ///< Alternative lighting for Encore mode
boolean use_encore_lighting; ///< Whether to use separate Encore lighting boolean use_encore_lighting; ///< Whether to use separate Encore lighting
// Music stuff.
UINT32 musinterfadeout; ///< Fade out level music on intermission screen in milliseconds
char musintername[7]; ///< Intermission screen music.
// Lua stuff. // Lua stuff.
// (This is not ifdeffed so the map header structure can stay identical, just in case.) // (This is not ifdeffed so the map header structure can stay identical, just in case.)
UINT8 numCustomOptions; ///< Internal. For Lua custom value support. UINT8 numCustomOptions; ///< Internal. For Lua custom value support.
@@ -379,8 +359,6 @@ typedef struct
{ {
tic_t time; ///< Time in which the level was finished. tic_t time; ///< Time in which the level was finished.
tic_t lap; ///< Best lap time for this level. tic_t lap; ///< Best lap time for this level.
//UINT32 score; ///< Score when the level was finished.
//UINT16 rings; ///< Rings when the level was finished.
} recorddata_t; } recorddata_t;
/** Setup for one NiGHTS map. /** Setup for one NiGHTS map.
@@ -394,34 +372,19 @@ typedef struct
#define GRADE_A 5 #define GRADE_A 5
#define GRADE_S 6 #define GRADE_S 6
/*typedef struct
{
// 8 mares, 1 overall (0)
UINT8 nummares;
UINT32 score[9];
UINT8 grade[9];
tic_t time[9];
} nightsdata_t;*/
//extern nightsdata_t *nightsrecords[NUMMAPS];
extern recorddata_t *mainrecords[NUMMAPS]; extern recorddata_t *mainrecords[NUMMAPS];
// mapvisited is now a set of flags that says what we've done in the map. // mapvisited is now a set of flags that says what we've done in the map.
#define MV_VISITED 1 #define MV_VISITED 1
#define MV_BEATEN 2 #define MV_BEATEN 2
#define MV_ALLEMERALDS 4 #define MV_ALLEMERALDS 4
//#define MV_ULTIMATE 8
//#define MV_PERFECT 16
#define MV_MAX 7 // used in gamedata check #define MV_MAX 7 // used in gamedata check
extern UINT8 mapvisited[NUMMAPS]; extern UINT8 mapvisited[NUMMAPS];
// Temporary holding place for nights data for the current map extern UINT32 token; ///< Number of tokens collected in a level
//nightsdata_t ntemprecords;
extern UINT32 token; ///< Number of tokens collected in a level
extern UINT32 tokenlist; ///< List of tokens collected extern UINT32 tokenlist; ///< List of tokens collected
extern INT32 tokenbits; ///< Used for setting token bits extern INT32 tokenbits; ///< Used for setting token bits
extern INT32 sstimer; ///< Time allotted in the special stage extern INT32 sstimer; ///< Time allotted in the special stage
extern UINT32 bluescore; ///< Blue Team Scores extern UINT32 bluescore; ///< Blue Team Scores
extern UINT32 redscore; ///< Red Team Scores extern UINT32 redscore; ///< Red Team Scores
@@ -437,9 +400,6 @@ extern boolean CheckForReverseGravity;
extern UINT16 invulntics; extern UINT16 invulntics;
extern UINT16 sneakertics; extern UINT16 sneakertics;
extern UINT16 flashingtics; extern UINT16 flashingtics;
extern UINT16 tailsflytics;
extern UINT16 underwatertics;
extern UINT16 spacetimetics;
extern UINT16 extralifetics; extern UINT16 extralifetics;
// SRB2kart // SRB2kart
@@ -461,7 +421,6 @@ extern UINT8 introtoplay;
extern UINT8 creditscutscene; extern UINT8 creditscutscene;
extern UINT8 use1upSound; extern UINT8 use1upSound;
extern UINT8 maxXtraLife; // Max extra lives from rings
extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations
@@ -526,7 +485,6 @@ extern UINT32 timesBeatenWithEmeralds;
// WAD, partly set at startup time. // WAD, partly set at startup time.
extern tic_t gametic; extern tic_t gametic;
#define localgametic leveltime
// Player spawn spots. // Player spawn spots.
extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative
-8
View File
@@ -1110,14 +1110,6 @@ void F_TitleScreenTicker(boolean run)
return; return;
} }
// Replay intro when done cycling through demos
/*if (curDemo == numDemos) -- uuuh... we have a LOT of maps AND a big devteam... probably not gonna see a repeat unless you're super unlucky :V
{
curDemo = 0;
F_StartIntro();
return;
}*/
mapname = G_BuildMapName(G_RandMap(TOL_RACE, -2, false, 0, false, NULL)+1); mapname = G_BuildMapName(G_RandMap(TOL_RACE, -2, false, 0, false, NULL)+1);
numstaff = 1; numstaff = 1;
+1 -4
View File
@@ -361,10 +361,7 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
// on for fade-to-black // on for fade-to-black
for (;;) for (;;)
{ {
if (I_Interrupted()) I_HandleInterrupt();
{
I_Quit();
}
// get fademask first so we can tell if it exists or not // get fademask first so we can tell if it exists or not
fmask = F_GetFadeMask(wipetype, wipeframe++); fmask = F_GetFadeMask(wipetype, wipeframe++);
+3 -1
View File
@@ -111,10 +111,12 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
char *searchname; char *searchname;
int depthleft = maxsearchdepth; int depthleft = maxsearchdepth;
char searchpath[MAXFILEPATH]; char searchpath[MAXFILEPATH];
size_t *searchpathindex; size_t *searchpathindex = NULL;
dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*)); dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*));
searchpathindex = (size_t *)malloc(maxsearchdepth * sizeof(size_t)); searchpathindex = (size_t *)malloc(maxsearchdepth * sizeof(size_t));
if (!searchpathindex)
I_Error("out of memory while searching for file %s\n", filename);
strcpy(searchpath, startpath); strcpy(searchpath, startpath);
searchpathindex[--depthleft] = strlen(searchpath) + 1; searchpathindex[--depthleft] = strlen(searchpath) + 1;
+51 -57
View File
@@ -66,12 +66,10 @@
#include <locale.h> #include <locale.h>
// menu demo things // menu demo things
UINT8 numDemos = 0; //3; -- i'm FED UP of losing my skincolour to a broken demo. change this back when we make new ones
UINT32 demoDelayTime = 15*TICRATE; UINT32 demoDelayTime = 15*TICRATE;
UINT32 demoIdleTime = 3*TICRATE; UINT32 demoIdleTime = 3*TICRATE;
boolean nodrawers = false; // for comparative timing purposes boolean nodrawers = false; // for comparative timing purposes
boolean noblit = false; // for comparative timing purposes
static tic_t demostarttime; // for comparative timing purposes static tic_t demostarttime; // for comparative timing purposes
//@TODO put these all in a struct for namespacing purposes? //@TODO put these all in a struct for namespacing purposes?
@@ -517,49 +515,49 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
if (cmd->forwardmove != oldcmd[playernum].forwardmove) if (cmd->forwardmove != oldcmd[playernum].forwardmove)
{ {
WRITEUINT8(demobuf.p,cmd->forwardmove); WRITEUINT8(demobuf.p, cmd->forwardmove);
oldcmd[playernum].forwardmove = cmd->forwardmove; oldcmd[playernum].forwardmove = cmd->forwardmove;
ziptic |= ZT_FWD; ziptic |= ZT_FWD;
} }
if (cmd->sidemove != oldcmd[playernum].sidemove) if (cmd->sidemove != oldcmd[playernum].sidemove)
{ {
WRITEUINT8(demobuf.p,cmd->sidemove); WRITEUINT8(demobuf.p, cmd->sidemove);
oldcmd[playernum].sidemove = cmd->sidemove; oldcmd[playernum].sidemove = cmd->sidemove;
ziptic |= ZT_SIDE; ziptic |= ZT_SIDE;
} }
if (cmd->angleturn != oldcmd[playernum].angleturn) if (cmd->angleturn != oldcmd[playernum].angleturn)
{ {
WRITEINT16(demobuf.p,cmd->angleturn); WRITEINT16(demobuf.p, cmd->angleturn);
oldcmd[playernum].angleturn = cmd->angleturn; oldcmd[playernum].angleturn = cmd->angleturn;
ziptic |= ZT_ANGLE; ziptic |= ZT_ANGLE;
} }
if (cmd->buttons != oldcmd[playernum].buttons) if (cmd->buttons != oldcmd[playernum].buttons)
{ {
WRITEUINT16(demobuf.p,cmd->buttons); WRITEUINT16(demobuf.p, cmd->buttons);
oldcmd[playernum].buttons = cmd->buttons; oldcmd[playernum].buttons = cmd->buttons;
ziptic |= ZT_BUTTONS; ziptic |= ZT_BUTTONS;
} }
if (cmd->aiming != oldcmd[playernum].aiming) if (cmd->aiming != oldcmd[playernum].aiming)
{ {
WRITEINT16(demobuf.p,cmd->aiming); WRITEINT16(demobuf.p, cmd->aiming);
oldcmd[playernum].aiming = cmd->aiming; oldcmd[playernum].aiming = cmd->aiming;
ziptic |= ZT_AIMING; ziptic |= ZT_AIMING;
} }
if (cmd->driftturn != oldcmd[playernum].driftturn) if (cmd->driftturn != oldcmd[playernum].driftturn)
{ {
WRITEINT16(demobuf.p,cmd->driftturn); WRITEINT16(demobuf.p, cmd->driftturn);
oldcmd[playernum].driftturn = cmd->driftturn; oldcmd[playernum].driftturn = cmd->driftturn;
ziptic |= ZT_DRIFT; ziptic |= ZT_DRIFT;
} }
if (cmd->latency != oldcmd[playernum].latency) if (cmd->latency != oldcmd[playernum].latency)
{ {
WRITEUINT8(demobuf.p,cmd->latency); WRITEUINT8(demobuf.p, cmd->latency);
oldcmd[playernum].latency = cmd->latency; oldcmd[playernum].latency = cmd->latency;
ziptic |= ZT_LATENCY; ziptic |= ZT_LATENCY;
} }
@@ -728,8 +726,8 @@ void G_WriteGhostTic(mobj_t *ghost, INT32 playernum)
// GZT_XYZ is only useful if you've moved 256 FRACUNITS or more in a single tic. // GZT_XYZ is only useful if you've moved 256 FRACUNITS or more in a single tic.
if (abs(ghost->x-oldghost[playernum].x) > MAXMOM if (abs(ghost->x-oldghost[playernum].x) > MAXMOM
|| abs(ghost->y-oldghost[playernum].y) > MAXMOM || abs(ghost->y-oldghost[playernum].y) > MAXMOM
|| abs(ghost->z-oldghost[playernum].z) > MAXMOM || abs(ghost->z-oldghost[playernum].z) > MAXMOM
|| ((UINT8)(leveltime & 255) > 0 && (UINT8)(leveltime & 255) <= (UINT8)cv_netdemosyncquality.value)) // Hack to enable slightly nicer resyncing || ((UINT8)(leveltime & 255) > 0 && (UINT8)(leveltime & 255) <= (UINT8)cv_netdemosyncquality.value)) // Hack to enable slightly nicer resyncing
{ {
oldghost[playernum].x = ghost->x; oldghost[playernum].x = ghost->x;
@@ -1377,7 +1375,7 @@ fadeghost:
UINT16 i, health; UINT16 i, health;
UINT16 count = READUINT16(g->p); UINT16 count = READUINT16(g->p);
//UINT32 type; //UINT32 type;
fixed_t x,y,z; fixed_t x, y, z;
angle_t angle; angle_t angle;
mobj_t *poof; mobj_t *poof;
@@ -1653,10 +1651,12 @@ void G_RecordDemo(const char *name)
maxsize = cv_maxdemosize.value*1024*1024; maxsize = cv_maxdemosize.value*1024*1024;
demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL); demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL);
demoend = demobuf.buffer + maxsize;
if (demobuf.buffer) if (demobuf.buffer)
{
demoend = demobuf.buffer + maxsize;
demo.recording = true; demo.recording = true;
}
else else
CONS_Alert(CONS_ERROR, "Failed to allocate demo buffer\n"); CONS_Alert(CONS_ERROR, "Failed to allocate demo buffer\n");
} }
@@ -1994,7 +1994,6 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)
UINT8 totalfiles, filesloaded, nmusfilecount; UINT8 totalfiles, filesloaded, nmusfilecount;
char filename[MAX_WADPATH]; char filename[MAX_WADPATH];
UINT8 md5sum[16]; UINT8 md5sum[16];
boolean toomany = false;
boolean alreadyloaded; boolean alreadyloaded;
UINT8 i, j; UINT8 i, j;
UINT8 error = 0; UINT8 error = 0;
@@ -2004,53 +2003,44 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)
for (i = 0; i < totalfiles; ++i) for (i = 0; i < totalfiles; ++i)
{ {
if (toomany) strlcpy(filename, (char *)(*pp), sizeof filename);
SKIPSTRING((*pp)); SKIPSTRING((*pp));
else
{
strlcpy(filename, (char *)(*pp), sizeof filename);
SKIPSTRING((*pp));
}
READMEM((*pp), md5sum, 16); // hue hue peepee READMEM((*pp), md5sum, 16); // hue hue peepee
if (!toomany) alreadyloaded = false;
nmusfilecount = 0;
for (j = 0; j < numwadfiles; ++j)
{ {
alreadyloaded = false; if (wadfiles[j]->important && j > mainwads)
nmusfilecount = 0; nmusfilecount++;
else
for (j = 0; j < numwadfiles; ++j)
{
if (wadfiles[j]->important && j > mainwads)
nmusfilecount++;
else
continue;
if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0)
{
alreadyloaded = true;
if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER)
error |= DFILE_ERROR_OUTOFORDER;
break;
}
}
if (alreadyloaded)
{
filesloaded++;
continue; continue;
}
if (numwadfiles >= MAX_WADFILES) if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0)
error = DFILE_ERROR_CANNOTLOAD; {
else if (!quick && findfile(filename, md5sum, false) != FS_FOUND) alreadyloaded = true;
error = DFILE_ERROR_CANNOTLOAD;
else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER) if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER)
error |= DFILE_ERROR_NOTLOADED; error |= DFILE_ERROR_OUTOFORDER;
} else
break;
}
}
if (alreadyloaded)
{
filesloaded++;
continue;
}
if (numwadfiles >= MAX_WADFILES)
error = DFILE_ERROR_CANNOTLOAD; error = DFILE_ERROR_CANNOTLOAD;
else if (!quick && findfile(filename, md5sum, false) != FS_FOUND)
error = DFILE_ERROR_CANNOTLOAD;
else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER)
error |= DFILE_ERROR_NOTLOADED;
} }
// Get final file count // Get final file count
@@ -2616,7 +2606,7 @@ void G_DoPlayDemo(char *defdemoname)
if (defdemoname == NULL) if (defdemoname == NULL)
{ {
demobuf.p = demobuf.buffer; demobuf.p = demobuf.buffer;
pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed
} }
else else
{ {
@@ -2628,7 +2618,7 @@ void G_DoPlayDemo(char *defdemoname)
n++; n++;
pdemoname = ZZ_Alloc(strlen(n)+1); pdemoname = ZZ_Alloc(strlen(n)+1);
strcpy(pdemoname,n); strcpy(pdemoname, n);
M_SetPlaybackMenuPointer(); M_SetPlaybackMenuPointer();
@@ -3090,6 +3080,9 @@ post_compat:
if (cv_director.value) if (cv_director.value)
CV_SetValue(&cv_director, 0); CV_SetValue(&cv_director, 0);
if (demo.timing)
G_DoneLevelLoad();
demo.deferstart = true; demo.deferstart = true;
} }
#undef SKIPERRORS #undef SKIPERRORS
@@ -3517,10 +3510,11 @@ static INT32 restorecv_vidwait;
void G_TimeDemo(const char *name) void G_TimeDemo(const char *name)
{ {
nodrawers = M_CheckParm("-nodraw"); nodrawers = M_CheckParm("-nodraw");
noblit = M_CheckParm("-noblit");
restorecv_vidwait = cv_vidwait.value; restorecv_vidwait = cv_vidwait.value;
if (cv_vidwait.value) if (cv_vidwait.value)
CV_Set(&cv_vidwait, "0"); CV_Set(&cv_vidwait, "0");
demo.timing = true; demo.timing = true;
singletics = true; singletics = true;
framecount = 0; framecount = 0;
+17 -37
View File
@@ -61,14 +61,11 @@
gameaction_t gameaction = 0; gameaction_t gameaction = 0;
gamestate_t gamestate = GS_NULL; gamestate_t gamestate = GS_NULL;
UINT8 ultimatemode = false;
boolean botingame = false; boolean botingame = false;
UINT8 botskin = 0; UINT8 botskin = 0;
UINT8 botcolor = 0; UINT8 botcolor = 0;
JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
// SRB2kart // SRB2kart
char gamedatafilename[64] = "kartdata.dat"; char gamedatafilename[64] = "kartdata.dat";
char timeattackfolder[64] = "kart"; char timeattackfolder[64] = "kart";
@@ -87,7 +84,6 @@ INT16 maptol = 0;
UINT8 globalweather = 0; UINT8 globalweather = 0;
INT32 curWeather = PRECIP_NONE; INT32 curWeather = PRECIP_NONE;
INT32 cursaveslot = -1; // Auto-save 1p savegame slot INT32 cursaveslot = -1; // Auto-save 1p savegame slot
INT16 lastmapsaved = 0; // Last map we auto-saved at
boolean gamecomplete = false; boolean gamecomplete = false;
UINT16 mainwads = 0; UINT16 mainwads = 0;
@@ -97,7 +93,6 @@ boolean savemoddata = false;
UINT8 paused = 0; UINT8 paused = 0;
UINT8 modeattacking = ATTACKING_NONE; UINT8 modeattacking = ATTACKING_NONE;
boolean imcontinuing = false; boolean imcontinuing = false;
boolean runemeraldmanager = false;
boolean netgame = false; // only true if packets are broadcast boolean netgame = false; // only true if packets are broadcast
boolean multiplayer = false; boolean multiplayer = false;
@@ -109,7 +104,6 @@ INT32 consoleplayer = 0; // player taking events and displaying
INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed
tic_t gametic = 0; tic_t gametic = 0;
tic_t levelstarttic = 0; // gametic at level start
UINT32 totalrings = 0; // for intermission UINT32 totalrings = 0; // for intermission
INT16 lastmap = 0; // last level you were at (returning from special stages) 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) tic_t timeinmap = 0; // Ticker for time spent in level (used for levelcard display)
@@ -187,9 +181,6 @@ boolean CheckForReverseGravity = false;
UINT16 invulntics = 20*TICRATE; UINT16 invulntics = 20*TICRATE;
UINT16 sneakertics = 20*TICRATE; UINT16 sneakertics = 20*TICRATE;
UINT16 flashingtics = 3*TICRATE/2; // SRB2kart UINT16 flashingtics = 3*TICRATE/2; // SRB2kart
UINT16 tailsflytics = 8*TICRATE;
UINT16 underwatertics = 30*TICRATE;
UINT16 spacetimetics = 11*TICRATE + (TICRATE/2);
UINT16 extralifetics = 4*TICRATE; UINT16 extralifetics = 4*TICRATE;
// SRB2kart // SRB2kart
@@ -207,10 +198,7 @@ const INT32 wipeoutslowtime = 20;
const INT32 wantedreduce = 5*TICRATE; const INT32 wantedreduce = 5*TICRATE;
const INT32 wantedfrequency = 10*TICRATE; const INT32 wantedfrequency = 10*TICRATE;
INT32 gameovertics = 15*TICRATE;
UINT8 use1upSound = 0; UINT8 use1upSound = 0;
UINT8 maxXtraLife = 2; // Max extra lives from rings
UINT8 introtoplay = 0; UINT8 introtoplay = 0;
UINT8 creditscutscene = 0; UINT8 creditscutscene = 0;
@@ -765,7 +753,7 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
if (retaxis > (+JOYAXISRANGE)) if (retaxis > (+JOYAXISRANGE))
retaxis = +JOYAXISRANGE; retaxis = +JOYAXISRANGE;
if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD) if (!DigitalGamepadStyle(pnum) && axissel < AXISDEAD)
{ {
const INT32 jdeadzone = ((JOYAXISRANGE-1) * deadzone) >> FRACBITS; const INT32 jdeadzone = ((JOYAXISRANGE-1) * deadzone) >> FRACBITS;
@@ -813,8 +801,8 @@ static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
const UINT8 forplayer = (ssplayer-1); const UINT8 forplayer = (ssplayer-1);
const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !Joystick[forplayer].bGamepadStyle; const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !DigitalGamepadStyle(forplayer);
const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle; const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && DigitalGamepadStyle(forplayer);
turnright = InputDown(gc_turnright, ssplayer); turnright = InputDown(gc_turnright, ssplayer);
turnleft = InputDown(gc_turnleft, ssplayer); turnleft = InputDown(gc_turnleft, ssplayer);
@@ -1002,10 +990,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
player_t *player = P_GetLocalPlayerForNum(forplayer); player_t *player = P_GetLocalPlayerForNum(forplayer);
camera_t *thiscam = &camera[forplayer]; camera_t *thiscam = &camera[forplayer];
const boolean freecam = camera[forplayer].freecam; const boolean freecam = thiscam->freecam;
const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !Joystick[forplayer].bGamepadStyle;
const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle;
lang = localangle[forplayer]; lang = localangle[forplayer];
laim = localaiming[forplayer]; laim = localaiming[forplayer];
@@ -1037,6 +1022,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
return; return;
} }
const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !DigitalGamepadStyle(forplayer);
const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && DigitalGamepadStyle(forplayer);
usejoystick = (analogjoystickmove || gamepadjoystickmove); usejoystick = (analogjoystickmove || gamepadjoystickmove);
turnright = InputDown(gc_turnright, ssplayer); turnright = InputDown(gc_turnright, ssplayer);
turnleft = InputDown(gc_turnleft, ssplayer); turnleft = InputDown(gc_turnleft, ssplayer);
@@ -1300,8 +1288,6 @@ static void G_DoLoadLevel(boolean resetplayer)
// Make sure objectplace is OFF when you first start the level! // Make sure objectplace is OFF when you first start the level!
OP_ResetObjectplace(); OP_ResetObjectplace();
levelstarttic = gametic; // for time calculation
if (wipegamestate == GS_LEVEL) if (wipegamestate == GS_LEVEL)
wipegamestate = -1; // force a wipe wipegamestate = -1; // force a wipe
@@ -1323,6 +1309,7 @@ static void G_DoLoadLevel(boolean resetplayer)
{ {
// fail so reset game stuff // fail so reset game stuff
Command_ExitGame_f(); Command_ExitGame_f();
P_FreeCorruptMapWarnings();
return; return;
} }
@@ -1356,6 +1343,8 @@ static void G_DoLoadLevel(boolean resetplayer)
// clear hud messages remains (usually from game startup) // clear hud messages remains (usually from game startup)
CON_ClearHUD(); CON_ClearHUD();
// print any map errors now due to clearhud above :chaosleep:
P_PrintCorruptMapWarnings();
server_lagless = !cv_gentlemens.value; server_lagless = !cv_gentlemens.value;
@@ -3355,18 +3344,6 @@ static void G_DoStartVote(void)
gameaction = ga_nothing; gameaction = ga_nothing;
} }
//
// G_UseContinue
//
void G_UseContinue(void)
{
if (gamestate == GS_LEVEL && !netgame && !multiplayer)
{
gameaction = ga_startcont;
lastdraw = true;
}
}
static void G_DoStartContinue(void) static void G_DoStartContinue(void)
{ {
I_Assert(!netgame && !multiplayer); I_Assert(!netgame && !multiplayer);
@@ -3405,7 +3382,7 @@ static void G_DoContinued(void)
token = 0; token = 0;
// Reset # of lives // Reset # of lives
pl->lives = (ultimatemode) ? 1 : 3; pl->lives = 3;
D_MapChange(gamemap, gametype, false, false, 0, false, false); D_MapChange(gamemap, gametype, false, false, 0, false, false);
@@ -4049,7 +4026,6 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
if (W_CheckNumForName(mapname) == LUMPERROR) if (W_CheckNumForName(mapname) == LUMPERROR)
{ {
I_Error("Internal game map '%s' not found\n", mapname); I_Error("Internal game map '%s' not found\n", mapname);
Command_ExitGame_f();
return; return;
} }
@@ -4114,6 +4090,7 @@ char *G_BuildMapTitle(INT32 mapnum)
const char *actnum = NULL; const char *actnum = NULL;
len += strlen(mapheaderinfo[mapnum-1]->lvlttl); len += strlen(mapheaderinfo[mapnum-1]->lvlttl);
if (strlen(mapheaderinfo[mapnum-1]->zonttl) > 0) if (strlen(mapheaderinfo[mapnum-1]->zonttl) > 0)
{ {
zonetext = M_GetText(mapheaderinfo[mapnum-1]->zonttl); zonetext = M_GetText(mapheaderinfo[mapnum-1]->zonttl);
@@ -4124,6 +4101,7 @@ char *G_BuildMapTitle(INT32 mapnum)
zonetext = M_GetText("Zone"); zonetext = M_GetText("Zone");
len += strlen(zonetext) + 1; // ' ' + zonetext len += strlen(zonetext) + 1; // ' ' + zonetext
} }
if (strlen(mapheaderinfo[mapnum-1]->actnum) > 0) if (strlen(mapheaderinfo[mapnum-1]->actnum) > 0)
{ {
actnum = M_GetText(mapheaderinfo[mapnum-1]->actnum); actnum = M_GetText(mapheaderinfo[mapnum-1]->actnum);
@@ -4137,8 +4115,10 @@ char *G_BuildMapTitle(INT32 mapnum)
sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl); sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl);
if (zonetext) sprintf(title + strlen(title), " %s", zonetext); if (zonetext)
if (actnum) sprintf(title + strlen(title), " %s", actnum); sprintf(title + strlen(title), " %s", zonetext);
if (actnum)
sprintf(title + strlen(title), " %s", actnum);
} }
return title; return title;
-5
View File
@@ -39,12 +39,8 @@ extern INT32 player_name_changes[MAXPLAYERS];
extern player_t players[MAXPLAYERS]; extern player_t players[MAXPLAYERS];
extern boolean playeringame[MAXPLAYERS]; extern boolean playeringame[MAXPLAYERS];
// gametic at level start
extern tic_t levelstarttic;
// for modding? // for modding?
extern INT16 prevmap, nextmap; extern INT16 prevmap, nextmap;
extern INT32 gameovertics;
extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard display) extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard display)
extern INT16 rw_maximums[NUM_WEAPONS]; extern INT16 rw_maximums[NUM_WEAPONS];
@@ -252,7 +248,6 @@ UINT8 G_GetGametypeColor(INT16 gt);
void G_ExitLevel(void); void G_ExitLevel(void);
void G_NextLevel(void); void G_NextLevel(void);
void G_Continue(void); void G_Continue(void);
void G_UseContinue(void);
void G_AfterIntermission(void); void G_AfterIntermission(void);
void G_EndGame(void); // moved from y_inter.c/h and renamed void G_EndGame(void); // moved from y_inter.c/h and renamed
+22
View File
@@ -81,6 +81,7 @@ consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
{"gamepadled4", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle4, 0, NULL, NULL, 0, 0, NULL} {"gamepadled4", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle4, 0, NULL, NULL, 0, 0, NULL}
}; };
consvar_t cv_gamepadifunfocused = {"gamepadunfocused", "Off", CV_SAVE|CV_CALL, CV_OnOff, I_SetJoystickFocus, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_gamepadledifunfocused = {"gamepadledunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_gamepadledifunfocused = {"gamepadledunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_rumbleifunfocused = {"rumbleifunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_rumbleifunfocused = {"rumbleifunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -939,6 +940,11 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
return; return;
} }
if (!I_GamepadHasLED(playernum))
{
return;
}
// so we can override this // so we can override this
skincolor = color ? color : G_GetSkinColorForGamepad(playernum); skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
byte_color = V_GetColor(colortranslations[skincolor][8]).s; byte_color = V_GetColor(colortranslations[skincolor][8]).s;
@@ -974,12 +980,22 @@ void G_DeviceLEDTick(void)
for (i = 0; i <= splitscreen; i++) for (i = 0; i <= splitscreen; i++)
{ {
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value) if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
{
continue; continue;
}
// does not have a configurable led! :c
if (!I_GamepadHasLED(i))
{
continue;
}
newcolor = G_GetSkinColorForGamepad(i); newcolor = G_GetSkinColorForGamepad(i);
if (curcolor[i] == newcolor) // dont update if same colour if (curcolor[i] == newcolor) // dont update if same colour
{
continue; continue;
}
G_SetPlayerGamepadIndicatorColor(i, newcolor); G_SetPlayerGamepadIndicatorColor(i, newcolor);
curcolor[i] = newcolor; curcolor[i] = newcolor;
@@ -1055,6 +1071,12 @@ void G_DeviceRumbleTick(void)
continue; continue;
} }
// does not support rumble! :c
if (!I_GamepadHasRumble(i))
{
continue;
}
if (camera[i].freecam) if (camera[i].freecam)
{ {
continue; continue;
+1
View File
@@ -116,6 +116,7 @@ extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadifunfocused;
extern consvar_t cv_gamepadledifunfocused; extern consvar_t cv_gamepadledifunfocused;
extern consvar_t cv_rumbleifunfocused; extern consvar_t cv_rumbleifunfocused;
-1
View File
@@ -52,7 +52,6 @@ typedef enum
} gameaction_t; } gameaction_t;
extern gamestate_t gamestate; extern gamestate_t gamestate;
extern UINT8 ultimatemode; // was sk_insane
extern gameaction_t gameaction; extern gameaction_t gameaction;
extern boolean botingame; extern boolean botingame;
+1 -1
View File
@@ -373,7 +373,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 count, poly_t *poly)
if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL) if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL)
gl_maphashorizonlines = true; gl_maphashorizonlines = true;
if (line->sidenum[1] != 0xffff) if (line->sidenum[1] != NO_INDEX)
{ {
if (sides[line->sidenum[0]].sector == sides[line->sidenum[1]].sector) if (sides[line->sidenum[0]].sector == sides[line->sidenum[1]].sector)
{ {
+10 -5
View File
@@ -446,7 +446,7 @@ typedef struct
} GLMapTextureSet_t; // idk i suck at naming things } GLMapTextureSet_t; // idk i suck at naming things
static size_t gl_numtextures = 0; // Texture count static size_t gl_numtextures = 0; // Texture count
static GLMapTextureSet_t *gl_textures; // For all textures static GLMapTextureSet_t *gl_textures = NULL; // For all textures
static void HWR_FreeTextureData(patch_t *patch) static void HWR_FreeTextureData(patch_t *patch)
{ {
@@ -570,7 +570,8 @@ void HWR_ClearAllTextures(void)
/*static void HWR_FreeColormapCache(void) /*static void HWR_FreeColormapCache(void)
{ {
HWR_FreePatchCache(false); HWR_FreePatchCache(false);
}*/ }
*/
void HWR_InitMapTextures(void) void HWR_InitMapTextures(void)
{ {
@@ -622,10 +623,12 @@ static void HWR_PrecacheLevelFlats(void)
{ {
// lookup for flats that may´ve been already loaded // lookup for flats that may´ve been already loaded
flatcheck flatpresent; flatcheck flatpresent;
flatcheck_init(&flatpresent);
size_t i, j; size_t i, j;
INT32 k; INT32 k;
flatcheck_init(&flatpresent);
flatcheck_reserve(&flatpresent, numlevelflats);
// special case for encore // special case for encore
#ifdef GLENCORE #ifdef GLENCORE
if (encoremap) if (encoremap)
@@ -726,7 +729,7 @@ static void HWR_PrecacheLevelTextures(void)
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
{ {
// check if single-sided linedef // check if single-sided linedef
if (line->sidenum[j] == 0xffff) if (line->sidenum[j] == NO_INDEX)
continue; continue;
const side_t *side = &sides[line->sidenum[j]]; const side_t *side = &sides[line->sidenum[j]];
@@ -989,7 +992,6 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
flat[steppy] = glMipmap->colormap->source[flat[steppy]]; flat[steppy] = glMipmap->colormap->source[flat[steppy]];
} }
#endif
if (haschromakey) if (haschromakey)
{ {
@@ -1001,6 +1003,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
glMipmap->flags &= ~TF_CHROMAKEYED; glMipmap->flags &= ~TF_CHROMAKEYED;
} }
} }
#endif
} }
// Download a Doom 'flat' to the hardware cache and make it ready for use // Download a Doom 'flat' to the hardware cache and make it ready for use
@@ -1127,7 +1130,9 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
HWR_UpdatePatchMipmap(patch, glMipmap); HWR_UpdatePatchMipmap(patch, glMipmap);
} }
else else
{
HWR_LoadPatchMipmap(patch, glMipmap); HWR_LoadPatchMipmap(patch, glMipmap);
}
return; return;
} }
+6 -5
View File
@@ -319,16 +319,17 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
double clipfov; double clipfov;
double floatangle; double floatangle;
angle_t a1; angle_t a1;
float tilt;
float tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
if (tilt > 90.0f)
tilt = 90.0f;
// If the pitch is larger than this you can look all around at a FOV of 90 // If the pitch is larger than this you can look all around at a FOV of 90
if (abs((signed)tiltangle) > 46 * ANG1) if (abs((signed)tiltangle) > 46 * ANG1)
return 0xffffffff; return 0xffffffff;
tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
if (tilt > 90.0f)
tilt = 90.0f;
// ok, this is a gross hack that barely works... // ok, this is a gross hack that barely works...
// but at least it doesn't overestimate too much... // but at least it doesn't overestimate too much...
clipfov = atan(1 / (GLdouble)projMatrix[0]) * 360.0 / M_PI; clipfov = atan(1 / (GLdouble)projMatrix[0]) * 360.0 / M_PI;
+24 -20
View File
@@ -32,20 +32,6 @@
#include <fcntl.h> #include <fcntl.h>
typedef struct
{
UINT8 id_field_length ; // 1
UINT8 color_map_type ; // 2
UINT8 image_type ; // 3
UINT8 dummy[5] ; // 4, 8
INT16 x_origin ; // 9, 10
INT16 y_origin ; //11, 12
INT16 width ; //13, 14
INT16 height ; //15, 16
UINT8 image_pix_size ; //17
UINT8 image_descriptor; //18
} ATTRPACK TGAHeader; // sizeof is 18
static const UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255}; 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_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 UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
@@ -57,8 +43,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
{ {
FOutVector v[4]; FOutVector v[4];
FBITFIELD flags; FBITFIELD flags;
float cx = FIXED_TO_FLOAT(x); float cx, cy;
float cy = FIXED_TO_FLOAT(y);
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT); UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT); UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT);
GLPatch_t *hwrPatch; GLPatch_t *hwrPatch;
@@ -72,6 +57,9 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
if (alphalevel >= 10 && alphalevel < 13) if (alphalevel >= 10 && alphalevel < 13)
return; return;
cx = FIXED_TO_FLOAT(x);
cy = FIXED_TO_FLOAT(y);
const float fvw = (float)vid.width; const float fvw = (float)vid.width;
const float fvh = (float)vid.height; const float fvh = (float)vid.height;
@@ -150,7 +138,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
if (!column->topdelta) if (!column->topdelta)
{ {
const UINT8 *source = (const UINT8 *)(column) + 3; const UINT8 *source = (const UINT8 *)(column) + 3;
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0])); HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
} }
} }
@@ -244,8 +232,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
{ {
FOutVector v[4]; FOutVector v[4];
FBITFIELD flags; FBITFIELD flags;
float cx = FIXED_TO_FLOAT(x); float cx, cy;
float cy = FIXED_TO_FLOAT(y);
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT); UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
GLPatch_t *hwrPatch; GLPatch_t *hwrPatch;
@@ -258,6 +245,9 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
if (alphalevel >= 10 && alphalevel < 13) if (alphalevel >= 10 && alphalevel < 13)
return; return;
cx = FIXED_TO_FLOAT(x);
cy = FIXED_TO_FLOAT(y);
const float fvw = (float)vid.width; const float fvw = (float)vid.width;
const float fvh = (float)vid.height; const float fvh = (float)vid.height;
@@ -302,7 +292,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
if (!column->topdelta) if (!column->topdelta)
{ {
const UINT8 *source = (const UINT8 *)(column) + 3; const UINT8 *source = (const UINT8 *)(column) + 3;
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0])); HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
} }
} }
@@ -964,6 +954,20 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
#endif #endif
#ifndef USE_PNG #ifndef USE_PNG
typedef struct
{
UINT8 id_field_length ; // 1
UINT8 color_map_type ; // 2
UINT8 image_type ; // 3
UINT8 dummy[5] ; // 4, 8
INT16 x_origin ; // 9, 10
INT16 y_origin ; //11, 12
INT16 width ; //13, 14
INT16 height ; //15, 16
UINT8 image_pix_size ; //17
UINT8 image_descriptor; //18
} ATTRPACK TGAHeader; // sizeof is 18
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// save screenshots with TGA format // save screenshots with TGA format
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
+6 -1
View File
@@ -32,8 +32,12 @@ void GL_SetSpecialState(hwdspecialstate_t IdState, INT32 Value);
void GL_SetTransform(FTransform *stransform); void GL_SetTransform(FTransform *stransform);
void GL_SetBlend(FBITFIELD PolyFlags); void GL_SetBlend(FBITFIELD PolyFlags);
void GL_SetPalette(RGBA_t *palette); void GL_SetPalette(RGBA_t *palette);
void GL_ClearBuffer(FBOOLEAN ColorMask, FBOOLEAN DepthMask, FBOOLEAN StencilMask, FRGBAFloat * ClearColor); void GL_ClearBuffer(FBOOLEAN ColorMask, FBOOLEAN DepthMask, FBOOLEAN StencilMask, FRGBAFloat * ClearColor);
void GL_EnableStencilTest(void);
void GL_DisableStencilTest(void);
void GL_DrawPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags); void GL_DrawPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags);
void GL_DrawIndexedTriangles(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, unsigned int *IndexArray); void GL_DrawIndexedTriangles(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, unsigned int *IndexArray);
void GL_Draw2DLine(F2DCoord *v1, F2DCoord *v2, RGBA_t Color); void GL_Draw2DLine(F2DCoord *v1, F2DCoord *v2, RGBA_t Color);
@@ -63,7 +67,7 @@ void GL_FlushScreenTextures(void);
void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags); void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags);
void GL_DoScreenWipe(int wipeStart, int wipeEnd); void GL_DoScreenWipe(int wipeStart, int wipeEnd);
void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize); void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize);
void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean useshader); void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height);
void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]); void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]);
@@ -72,6 +76,7 @@ void GL_LoadShader(int slot, char *code, hwdshaderstage_t stage);
boolean GL_CompileShader(int slot); boolean GL_CompileShader(int slot);
void GL_SetShader(int slot); void GL_SetShader(int slot);
void GL_UnSetShader(void); void GL_UnSetShader(void);
void GL_EnableShader(void);
void GL_SetShaderInfo(hwdshaderinfo_t info, INT32 value); void GL_SetShaderInfo(hwdshaderinfo_t info, INT32 value);
+2 -2
View File
@@ -34,8 +34,8 @@ typedef struct gl_vissprite_s
float gz, gzt; float gz, gzt;
float tz; float tz;
float scale; float scale;
float spritexscale, spriteyscale; //float spritexscale, spriteyscale;
float spritexoffset, spriteyoffset; //float spritexoffset, spriteyoffset;
patch_t *gpatch; patch_t *gpatch;
boolean flip; boolean flip;
UINT8 translucency; //alpha level 0-255 UINT8 translucency; //alpha level 0-255
+321 -497
View File
File diff suppressed because it is too large. Load diff
+8 -3
View File
@@ -102,7 +102,7 @@ void HWR_SetViewSize(void);
void HWR_AddCommands(void); void HWR_AddCommands(void);
void HWR_RenderPlayerView(void); void HWR_RenderPlayerView(void);
void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, int stencil_level, boolean allow_portals); void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, int stencil_level);
void HWR_ClearSkyDome(void); void HWR_ClearSkyDome(void);
void HWR_BuildSkyDome(void); void HWR_BuildSkyDome(void);
@@ -151,14 +151,19 @@ FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t do
GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize); GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize);
} }
FUNCINLINE static ATTRINLINE void HWR_MakeScreenTexture(void)
{
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
}
FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void) FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void)
{ {
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2); GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2);
} }
FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height, boolean useshader) FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height)
{ {
GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height, useshader); GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height);
} }
// hw_main.c: Segs // hw_main.c: Segs
+3 -4
View File
@@ -154,7 +154,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
char *buffer; char *buffer;
int surfEnd; int surfEnd;
int i, t; int i, t;
int matCount; //int matCount;
FILE *f; FILE *f;
if (!latlnginit) if (!latlnginit)
@@ -227,7 +227,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, NULL); retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, NULL);
matCount = 0; //matCount = 0;
for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++) for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++)
{ {
int j; int j;
@@ -237,7 +237,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
mdShader = (md3Shader*)((char*)mdS + mdS->offsetShaders); mdShader = (md3Shader*)((char*)mdS + mdS->offsetShaders);
for (j = 0; j < mdS->numShaders; j++, matCount++) for (j = 0; j < mdS->numShaders; j++ /*, matCount++*/)
{ {
size_t len = strlen(mdShader[j].name); size_t len = strlen(mdShader[j].name);
mdShader[j].name[len-1] = 'z'; mdShader[j].name[len-1] = 'z';
@@ -503,7 +503,6 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
} }
}*/ }*/
free(buffer); free(buffer);
return retModel; return retModel;
+7 -7
View File
@@ -80,8 +80,8 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
gl_portal_t *portal = HWR_Portal_Add(seg); gl_portal_t *portal = HWR_Portal_Add(seg);
// Offset the portal view by the linedef centers // Offset the portal view by the linedef centers
line_t* start = &lines[line1]; line_t* start = &lines[line1];
line_t* dest = &lines[line2]; line_t* dest = &lines[line2];
angle_t dangle = R_PointToAngle2(0, 0, dest->dx, dest->dy) - R_PointToAngle2(start->dx, start->dy, 0, 0); angle_t dangle = R_PointToAngle2(0, 0, dest->dx, dest->dy) - R_PointToAngle2(start->dx, start->dy, 0, 0);
@@ -99,7 +99,7 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
dest_c.y = dest->v1->y/2 + dest->v2->y/2; dest_c.y = dest->v1->y/2 + dest->v2->y/2;
disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy); disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy);
angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy); angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
angtopoint += dangle; angtopoint += dangle;
portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint); portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
@@ -170,7 +170,7 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
HWR_PortalFrame(portal); HWR_PortalFrame(portal);
// call HWR_RenderViewpoint // call HWR_RenderViewpoint
HWR_RenderPortalViewpoint(portal, stencil_level + 1, true); HWR_RenderPortalViewpoint(portal, stencil_level + 1);
// return to current frame // return to current frame
if (rootportal) if (rootportal)
@@ -220,9 +220,9 @@ boolean HWR_PortalCheckBBox(const fixed_t *bspcoord)
if (!portalclipline) if (!portalclipline)
return true; return true;
if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) || if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) ||
HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) || HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) ||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) || HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) ||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXBOTTOM])) HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXBOTTOM]))
{ {
return true; return true;
+8 -2
View File
@@ -365,13 +365,17 @@ static void HWR_CompileShader(int index)
if (vertex_source) if (vertex_source)
{ {
char *preprocessed = HWR_PreprocessShader(vertex_source); char *preprocessed = HWR_PreprocessShader(vertex_source);
if (!preprocessed) return; if (!preprocessed)
return;
GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_VERTEX); GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_VERTEX);
} }
if (fragment_source) if (fragment_source)
{ {
char *preprocessed = HWR_PreprocessShader(fragment_source); char *preprocessed = HWR_PreprocessShader(fragment_source);
if (!preprocessed) return; if (!preprocessed)
return;
GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_FRAGMENT); GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_FRAGMENT);
} }
@@ -387,8 +391,10 @@ void HWR_CompileShaders(void)
{ {
int custom_index = gl_shadertargets[i].custom_shader; int custom_index = gl_shadertargets[i].custom_shader;
HWR_CompileShader(i); HWR_CompileShader(i);
if (!gl_shaders[i].compiled) if (!gl_shaders[i].compiled)
CONS_Alert(CONS_ERROR, "HWR_CompileShaders: Compilation failed for base %s shader!\n", shaderxlat[i].type); CONS_Alert(CONS_ERROR, "HWR_CompileShaders: Compilation failed for base %s shader!\n", shaderxlat[i].type);
if (custom_index != -1) if (custom_index != -1)
{ {
HWR_CompileShader(custom_index); HWR_CompileShader(custom_index);
+14 -19
View File
@@ -76,35 +76,30 @@
// //
// Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro. // Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro.
// dither shader based on
// https://github.com/hughsk/glsl-dither/blob/master/8x8.glsl
// https://github.com/libretro/glsl-shaders/blob/master/dithering/shaders/bayer_4x4.glsl
// adapted and messed about to work with srb2 and scale per resolution
#define GLSL_DOOM_COLORMAP_DITHER \ #define GLSL_DOOM_COLORMAP_DITHER \
"float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \ "float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
"float endResolutionx = scr_resolution.x;\n" \ "float patscale = min(scr_resolution.x / 1280.0, scr_resolution.y / 720.0);\n" \
"float endResolutiony = scr_resolution.y;\n" \ "patscale = max(floor(patscale + 0.5), 1.0);\n" \
"if (scr_resolution.x > 1280.0) {\n" \ "patscale = 1.0 / patscale;\n" \
"endResolutionx = scr_resolution.x * 0.5;\n" \ "ivec2 p = ivec2(mod(floor(position * patscale), 4.0));\n" \
"}\n" \ "float depthfactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \
"if (scr_resolution.y > 720.0) {\n" \
"endResolutiony = scr_resolution.y * 0.5;\n" \
"}\n" \
"float zFactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \
"int scaleFactor = int(mix(1.0, 8.0, zFactor));\n" \
"endResolutionx = endResolutionx * scaleFactor;\n" \
"endResolutiony = endResolutiony * scaleFactor;\n" \
"vec2 normalizedPosition = position * vec2(endResolutionx / scr_resolution.x, endResolutiony / scr_resolution.y);\n" \
"int x = int(mod(normalizedPosition.x, 4.0));\n" \
"int y = int(mod(normalizedPosition.y, 4.0));\n" \
"float bayerMatrix[4*4] = float[4*4](\n" \ "float bayerMatrix[4*4] = float[4*4](\n" \
"0.0, 8.0, 2.0, 10.0,\n" \ "0.0, 8.0, 2.0, 10.0,\n" \
"12.0, 4.0, 14.0, 6.0,\n" \ "12.0, 4.0, 14.0, 6.0,\n" \
"3.0, 11.0, 1.0, 9.0,\n" \ "3.0, 11.0, 1.0, 9.0,\n" \
"15.0, 7.0, 13.0, 5.0\n" \ "15.0, 7.0, 13.0, 5.0\n" \
");\n" \ ");\n" \
"float threshold = 16.0;\n" \
"#ifdef SRB2_PALETTE_RENDERING\n" \ "#ifdef SRB2_PALETTE_RENDERING\n" \
"float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 11.0);\n" \ "threshold = 11.0;\n" \
"#else\n" \
"float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 16.0);\n" \
"#endif\n" \ "#endif\n" \
"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, zFactor);\n" "threshold = (1.0 - pow(depthfactor, 2.0)) * (bayerMatrix[p.y*4 + p.x] / threshold);\n" \
"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, depthfactor);\n"
#define GLSL_DOOM_COLORMAP_NODITHER \ #define GLSL_DOOM_COLORMAP_NODITHER \
"return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \ "return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
+38 -18
View File
@@ -1068,6 +1068,13 @@ void GL_SetShader(int slot)
gl_shadersenabled = false; gl_shadersenabled = false;
} }
void GL_EnableShader(void)
{
// we can just use GL_Shader_SetUniforms as itll enable the shader for us
// and handle any failures
GL_Shader_SetUniforms(NULL, NULL, NULL, NULL);
}
void GL_UnSetShader(void) void GL_UnSetShader(void)
{ {
if (gl_shadersenabled) // don't repeatedly call glUseProgram if not needed if (gl_shadersenabled) // don't repeatedly call glUseProgram if not needed
@@ -1115,7 +1122,7 @@ static void GL_Perspective(GLfloat fovy, GLfloat aspect)
const GLfloat deltaZ = FAR_CLIPPING_PLANE - NEAR_CLIPPING_PLANE; const GLfloat deltaZ = FAR_CLIPPING_PLANE - NEAR_CLIPPING_PLANE;
if ((fabsf((float)deltaZ) < 1.0E-36f) || fpclassify(aspect) == FP_ZERO) if ((fabsf(deltaZ) < 1.0E-36f) || fpclassify(aspect) == FP_ZERO)
{ {
return; return;
} }
@@ -1277,7 +1284,7 @@ void GL_SetStates(void)
pglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); pglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
pglEnable(GL_STENCIL_TEST); pglDisable(GL_STENCIL_TEST);
pglEnable(GL_DEPTH_TEST); // check the depth buffer pglEnable(GL_DEPTH_TEST); // check the depth buffer
pglDepthMask(GL_TRUE); // enable writing to depth buffer pglDepthMask(GL_TRUE); // enable writing to depth buffer
pglClearDepth(1.0f); pglClearDepth(1.0f);
@@ -1307,6 +1314,16 @@ void GL_SetStates(void)
#endif #endif
} }
void GL_EnableStencilTest(void)
{
pglEnable(GL_STENCIL_TEST);
}
void GL_DisableStencilTest(void)
{
pglDisable(GL_STENCIL_TEST);
}
// -----------------+ // -----------------+
// DeleteTexture : Deletes a texture from the GPU and frees its data // DeleteTexture : Deletes a texture from the GPU and frees its data
// -----------------+ // -----------------+
@@ -1566,6 +1583,7 @@ void GL_Draw2DLine(F2DCoord * v1, F2DCoord * v2, RGBA_t Color)
angle = atanf((v2->y-v1->y)/(v2->x-v1->x)); angle = atanf((v2->y-v1->y)/(v2->x-v1->x));
else else
angle = (float)N_PI_DEMI; angle = (float)N_PI_DEMI;
dx = sinf(angle) / (float)screen_width; dx = sinf(angle) / (float)screen_width;
dy = cosf(angle) / (float)screen_height; dy = cosf(angle) / (float)screen_height;
@@ -1680,7 +1698,7 @@ static void GL_SetBlendMode(FBITFIELD flags)
void GL_SetBlend(FBITFIELD PolyFlags) void GL_SetBlend(FBITFIELD PolyFlags)
{ {
const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;; const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;
if (Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Skydecal|PF_Invisible)) if (Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Skydecal|PF_Invisible))
{ {
@@ -3243,14 +3261,6 @@ static void GL_Framebuffer_Generate(void)
if (!framebufferobject.fboobj) if (!framebufferobject.fboobj)
pglGenFramebuffers(1, &framebufferobject.fboobj); pglGenFramebuffers(1, &framebufferobject.fboobj);
if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{
// if this fails, dont retry it a gazillion times
// this wouldnt recover
supportFBO = false;
return;
}
// Bind the framebuffer // Bind the framebuffer
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
@@ -3302,6 +3312,18 @@ static void GL_Framebuffer_Generate(void)
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0); pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
} }
if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{
//pglGetError(); TODO:implement this or smth
GL_MSG_Error("GL_Framebuffer_Generate: Failed to create Framebuffer Object");
// if this fails, dont retry it a gazillion times
// this wouldnt recover
supportFBO = false;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
return;
}
// Unbind the framebuffer // Unbind the framebuffer
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
@@ -3324,6 +3346,10 @@ void GL_Framebuffer_Enable(void)
GL_Framebuffer_Generate(); GL_Framebuffer_Generate();
// failed
if (!supportFBO || !framebufferobject.init)
return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj); pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
} }
@@ -3718,7 +3744,7 @@ void GL_MakeScreenTexture(int tex)
tex_downloaded = screenTextures[tex]; tex_downloaded = screenTextures[tex];
} }
void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean useshader) void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
{ {
float xfix, yfix; float xfix, yfix;
float origaspect, newaspect; float origaspect, newaspect;
@@ -3771,9 +3797,6 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]); pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]);
if (useshader)
pglUseProgram(gl_shaders[SHADER_PALETTE_POSTPROCESS].program); // Final postprocess step of palette rendering, after everything else has been drawn.
pglColor4ubv(white); pglColor4ubv(white);
pglTexCoordPointer(2, GL_FLOAT, 0, fix); pglTexCoordPointer(2, GL_FLOAT, 0, fix);
@@ -3781,9 +3804,6 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4); pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
if (useshader)
pglUseProgram(0);
tex_downloaded = screenTextures[tex]; tex_downloaded = screenTextures[tex];
} }
+132 -237
View File
@@ -97,7 +97,6 @@ static textinput_t w_chat;
static boolean headsupactive = false; static boolean headsupactive = false;
boolean hu_showscores = false; // draw rankings boolean hu_showscores = false; // draw rankings
static char hu_tick; static char hu_tick;
static tic_t hu_emoteanim = 0;
emote_autocomplete_t emote_autocomplete = {0}; emote_autocomplete_t emote_autocomplete = {0};
static huddrawlist_h luahuddrawlist_scores = NULL; static huddrawlist_h luahuddrawlist_scores = NULL;
@@ -116,155 +115,8 @@ static patch_t *songcreditbg = NULL;
// ------- // -------
static void HU_DrawRankings(void); static void HU_DrawRankings(void);
consvar_t cv_showspecstuff = {"showspecstuff", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showspecstuff = {"showspecstuff", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
//======================================================================
// KEYBOARD LAYOUTS FOR ENTERING TEXT
//======================================================================
char *shiftxform = NULL;
char english_shiftxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!', '"', '#', '$', '%', '&',
'"', // shift-'
'(', ')', '*', '+',
'<', // shift-,
'_', // shift--
'>', // shift-.
'?', // shift-/
')', // shift-0
'!', // shift-1
'@', // shift-2
'#', // shift-3
'$', // shift-4
'%', // shift-5
'^', // shift-6
'&', // shift-7
'*', // shift-8
'(', // shift-9
':',
':', // shift-;
'<',
'+', // shift-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', // shift-[
'|', // shift-backslash - OH MY GOD DOES WATCOM SUCK
'}', // shift-]
'"', '_',
'~', // shift-`
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127
};
char french_shiftxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ','$', //shift-!
'3', //shift-"
'#', '$', '%',
'1', //shift-&
'4', // shift-'
'5', // shift-(
')', // shift-)
'*', '+',
'?', // shift-,
'6', // shift--
'.', '/',
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9',
'/', // shitf-:
'.', // shift-;
'>', // shift-<
'+', // shift-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'[', '\\', ']', '^',
'8', //shift-_
'`',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127,
128, 129,
'2',
131, 132,
'0',
134,
'9',
136, 137,
'7',
139, 140,
'%'
};
char french_altgrxform[] =
{
0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!',
'#', //altgr-"
'#', '$', '%', '&',
'{', //altgr-'
'[', //altgr-(
']', //altgr-)
'*', '+', ',',
'|', //altg--
'.', '/',
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9',
':', ';', '<',
'}', //altgr-=
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'[', '\\', ']', '^',
'\\', //altgr-backslash
'`',
'a', 'b', 'c', 'd', 'E', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'{', '|', '}', '~', 127,
128, 129,
'~',
131, 132,
'@',
134,
'^',
136, 137,
'`',
139, 140,
KEY_FR_U_GRAVE
};
//fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
INT32 HU_FallBackFrSpecialLetter(INT32 key)
{
switch(key){
case KEY_FR_E_AIGUE: return 'e';
case KEY_FR_E_GRAVE: return 'e';
case KEY_FR_C_CEDILLE: return 'c';
case KEY_FR_A_GRAVE: return 'a';
case KEY_FR_U_GRAVE: return 'u';
default: return key;
}
}
static char cechotext[1024]; static char cechotext[1024];
static tic_t cechotimer = 0; static tic_t cechotimer = 0;
static tic_t cechoduration = 5*TICRATE; static tic_t cechoduration = 5*TICRATE;
@@ -281,6 +133,7 @@ static void Command_Say_f(void);
static void Command_Sayto_f(void); static void Command_Sayto_f(void);
static void Command_Sayteam_f(void); static void Command_Sayteam_f(void);
static void Command_CSay_f(void); static void Command_CSay_f(void);
static void Command_Mute_f(void);
static void Got_Saycmd(const UINT8 **p, INT32 playernum); static void Got_Saycmd(const UINT8 **p, INT32 playernum);
void HU_LoadGraphics(void) void HU_LoadGraphics(void)
@@ -408,8 +261,7 @@ void HU_Init(void)
COM_AddCommand("csay", Command_CSay_f); COM_AddCommand("csay", Command_CSay_f);
RegisterNetXCmd(XD_SAY, Got_Saycmd); RegisterNetXCmd(XD_SAY, Got_Saycmd);
// set shift translation table COM_AddCommand("muteplayer", Command_Mute_f);
shiftxform = english_shiftxform;
if (dedicated || rendermode == render_none) if (dedicated || rendermode == render_none)
return; return;
@@ -436,11 +288,6 @@ void HU_Start(void)
headsupactive = true; headsupactive = true;
} }
void HU_Shiftform(void)
{
shiftxform = (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
}
//====================================================================== //======================================================================
// EXECUTION // EXECUTION
//====================================================================== //======================================================================
@@ -544,6 +391,8 @@ void HU_AddChatText(const char *text, boolean playsound)
HU_removeChatText_Log(); HU_removeChatText_Log();
chat_log[chat_nummsg_log] = malloc(HU_MSGBUFSIZE); chat_log[chat_nummsg_log] = malloc(HU_MSGBUFSIZE);
if (!chat_log[chat_nummsg_log])
I_Error("HU_AddChatText: out of memory for chat log\n");
strcpy(chat_log[chat_nummsg_log], text); strcpy(chat_log[chat_nummsg_log], text);
++chat_nummsg_log; ++chat_nummsg_log;
@@ -626,7 +475,10 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
// with that logic, characters 4 and 5 are our numbers: // with that logic, characters 4 and 5 are our numbers:
const char *newmsg; const char *newmsg;
INT32 spc = 1; // used if nodenum[1] is a space. INT32 spc = 1; // used if nodenum[1] is a space.
CLEANUP(pfree) char *nodenum = (char*) malloc(3); CLEANUP(pfree) char *nodenum = (char*)malloc(3);
if (!nodenum)
I_Error("DoSayCommand: out of memory for sending pm\n");
memcpy(nodenum, msg+3, 2); memcpy(nodenum, msg+3, 2);
nodenum[2] = '\0'; nodenum[2] = '\0';
@@ -907,7 +759,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
target = READSINT8(*p); target = READSINT8(*p);
flags = READUINT8(*p); flags = READUINT8(*p);
msg = buf; msg = buf;
READSTRINGL(*p, msg, HU_MAXMSGLEN + 1); READSTRINGN(*p, msg, HU_MAXMSGLEN + 1);
if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum))) if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
{ {
@@ -1095,7 +947,6 @@ void HU_Ticker(void)
return; return;
hu_tick++; hu_tick++;
hu_emoteanim++;
hu_tick &= 7; // currently only to blink chat input cursor hu_tick &= 7; // currently only to blink chat input cursor
if (PLAYER1INPUTDOWN(gc_scores)) if (PLAYER1INPUTDOWN(gc_scores))
@@ -1131,7 +982,8 @@ void HU_Ticker(void)
} }
} }
if (cechotimer > 0) --cechotimer; if (cechotimer > 0)
--cechotimer;
// Animate the desynch dots // Animate the desynch dots
if (hu_resynching if (hu_resynching
@@ -1173,21 +1025,42 @@ static boolean HU_clearChatSpaces(void)
return nothingbutspaces; return nothingbutspaces;
} }
static void DoMute(const char *name) static void DoMute(const char *name, boolean chat)
{ {
INT32 pnum = D_LookupPlayer(name); INT32 pnum = D_LookupPlayer(name);
if (pnum < 0) // Shortcut to reuse this function for console and chat command
#define PRINT(msg, sound) do { \
if (chat) \
HU_AddChatText((msg), (sound)); \
else \
CONS_Printf("%s\n", msg); \
} while (0)
if (pnum < 0 || !playeringame[pnum])
{ {
HU_AddChatText("\x85""ERROR: \x80Player not found.", false); PRINT("\x85""ERROR: \x80Player not found.", false);
return; return;
} }
player_muted[pnum] = !player_muted[pnum]; player_muted[pnum] = !player_muted[pnum];
HU_AddChatText(va("Player '%s' has been %smuted.", player_names[pnum], player_muted[pnum] ? "" : "un"), false); PRINT(va("Player '%s' has been %smuted.", player_names[pnum], player_muted[pnum] ? "" : "un"), false);
if (player_muted[pnum]) if (player_muted[pnum])
HU_AddChatText("Use same command to unmute them.", false); PRINT("Use same command to unmute them.", false);
#undef PRINT
}
static void Command_Mute_f(void)
{
if (COM_Argc() < 2)
{
CONS_Printf(M_GetText("mute <playername|playernum>: mute/unmute a player\n"));
return;
}
DoMute(COM_Argv(1), false);
} }
static void HU_SendChatMessage(void) static void HU_SendChatMessage(void)
@@ -1221,7 +1094,7 @@ static void HU_SendChatMessage(void)
if (msglength >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute if (msglength >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
{ {
if (msglength > 6) if (msglength > 6)
DoMute(msg+6); DoMute(msg+6, true);
else else
HU_AddChatText("\x82NOTICE: \x80Usage: /mute <name|node>", false); HU_AddChatText("\x82NOTICE: \x80Usage: /mute <name|node>", false);
@@ -1232,7 +1105,9 @@ static void HU_SendChatMessage(void)
{ {
INT32 spc = 1; // used if nodenum[1] is a space. INT32 spc = 1; // used if nodenum[1] is a space.
const char *newmsg; const char *newmsg;
CLEANUP(pfree) char *nodenum = (char*) malloc(3); CLEANUP(pfree) char *nodenum = (char*)malloc(3);
if (!nodenum)
I_Error("HU_SendChatMessage: out of memory for sending pm\n");
// what we're gonna do now is check if the node exists // what we're gonna do now is check if the node exists
// with that logic, characters 4 and 5 are our numbers: // with that logic, characters 4 and 5 are our numbers:
@@ -1406,13 +1281,15 @@ boolean HU_Responder(event_t *ev)
chat_on = false; chat_on = false;
I_SetTextInput(false); I_SetTextInput(false);
} }
else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0 && !OLDCHAT) // CHAT SCROLLING YAYS! else if ((c == KEY_UPARROW || c == KEY_PGUP || c == KEY_MOUSEWHEELUP) &&
((chat_scroll > 0) && !OLDCHAT)) // CHAT SCROLLING YAYS!
{ {
chat_scroll--; chat_scroll--;
justscrolledup = true; justscrolledup = true;
chat_scrolltime = 4; chat_scrolltime = 4;
} }
else if ((c == KEY_DOWNARROW || c == KEY_MOUSEWHEELDOWN) && chat_scroll < chat_maxscroll && chat_maxscroll > 0 && !OLDCHAT) else if ((c == KEY_DOWNARROW || c == KEY_PGDN || c == KEY_MOUSEWHEELDOWN) &&
((chat_scroll < chat_maxscroll) && (chat_maxscroll > 0) && !OLDCHAT))
{ {
chat_scroll++; chat_scroll++;
justscrolleddown = true; justscrolleddown = true;
@@ -1576,7 +1453,6 @@ static void HU_drawMiniChat(void)
y = chaty - charheight*(msglines+1); y = chaty - charheight*(msglines+1);
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1584,7 +1460,6 @@ static void HU_drawMiniChat(void)
y += 16; y += 16;
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
dx = 0; dx = 0;
@@ -1682,18 +1557,15 @@ static void HU_drawChatLog(INT32 offset)
if (chat_scroll > chat_maxscroll) if (chat_scroll > chat_maxscroll)
chat_scroll = chat_maxscroll; chat_scroll = chat_maxscroll;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
boxh = max(6, boxh/2); boxh = max(6, boxh/2);
if (splitscreen > 1) if (splitscreen > 1)
boxw = max(64, boxw/2); boxw = max(64, boxw/2);
} }
#endif
y = chaty - offset*charheight - (chat_scroll*charheight) - boxh*charheight - 12; y = chaty - offset*charheight - (chat_scroll*charheight) - boxh*charheight - 12;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1701,7 +1573,6 @@ static void HU_drawChatLog(INT32 offset)
y += 16; y += 16;
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
@@ -1810,12 +1681,12 @@ static void HU_DrawChat(void)
INT32 t = 0, c = 0, y = chaty - (typelines*charheight); INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday! UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
INT32 cflag = 0; INT32 cflag = 0;
INT32 pm_offset = 0; // for cases when you type emote while also doing /pm
size_t select_start = 0, select_end = 0; size_t select_start = 0, select_end = 0;
const char *ntalk = "Say: ", *ttalk = "Team: "; const char *ntalk = "Say: ", *ttalk = "Team: ";
const char *talk = ntalk; const char *talk = ntalk;
const char *mute = "Chat has been muted."; const char *mute = "Chat has been muted.";
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1826,7 +1697,6 @@ static void HU_DrawChat(void)
} }
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
if (teamtalk) if (teamtalk)
@@ -1921,71 +1791,13 @@ static void HU_DrawChat(void)
} }
} }
if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
{
emote_t *suggest;
int skip = 0;
const char *complete;
int complete_len;
if (emote_autocomplete.complete[0])
{
complete = emote_autocomplete.complete;
complete_len = strlen(complete);
}
else
{
complete = &w_chat_buf[emote_autocomplete.emotestart];
complete_len = w_chat.cursor - emote_autocomplete.emotestart;
}
// A bit of copy-paste from /pm code :p
INT32 suggesty = chaty - charheight - 1;
size_t longest_suggestion_length = 0;
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
++skip;
}
skip = 0;
#ifdef NETSPLITSCREEN
if (splitscreen)
{
suggesty -= BASEVIDHEIGHT/2;
if (splitscreen > 1)
suggesty += 16;
}
else
#endif
suggesty -= (cv_kartspeedometer.value ? 16 : 0);
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*skip), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
// Highlight currently suggested emote
int hlflag = 0;
if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
hlflag = V_YELLOWMAP;
V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
M_DrawEmote(chatx + boxw + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
++skip;
}
}
// handle /pm list. It's messy, horrible and I don't care. // handle /pm list. It's messy, horrible and I don't care.
if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
{ {
INT32 count = 0; INT32 count = 0;
INT32 p_dispy = chaty - charheight - 1; INT32 p_dispy = chaty - charheight - 1;
size_t longest_name_length = 0; size_t longest_name_length = 0;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
p_dispy -= BASEVIDHEIGHT/2; p_dispy -= BASEVIDHEIGHT/2;
@@ -1993,13 +1805,13 @@ static void HU_DrawChat(void)
p_dispy += 16; p_dispy += 16;
} }
else else
#endif
p_dispy -= (cv_kartspeedometer.value ? 16 : 0); p_dispy -= (cv_kartspeedometer.value ? 16 : 0);
// Find longest player name, for drawing background for /pm list later // Find longest player name, for drawing background for /pm list later
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{ {
if (!playeringame[i]) continue; if (!playeringame[i])
continue;
longest_name_length = max(longest_name_length, strlen(player_names[i])); longest_name_length = max(longest_name_length, strlen(player_names[i]));
} }
@@ -2059,9 +1871,72 @@ static void HU_DrawChat(void)
if (count == 0) // no results. if (count == 0) // no results.
{ {
pm_offset = 48 + 2;
V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud. V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT."); V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
} }
else
{
pm_offset = (longest_name_length+4)*4 + 2;
}
}
if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
{
emote_t *suggest;
int skip = 0;
const char *complete;
int complete_len;
if (emote_autocomplete.complete[0])
{
complete = emote_autocomplete.complete;
complete_len = strlen(complete);
}
else
{
complete = &w_chat_buf[emote_autocomplete.emotestart];
complete_len = w_chat.cursor - emote_autocomplete.emotestart;
}
// A bit of copy-paste from /pm code :p
INT32 suggesty = chaty - charheight - 1;
size_t longest_suggestion_length = 0;
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
++skip;
}
INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
skip = 0;
if (splitscreen)
{
suggesty -= BASEVIDHEIGHT/2;
if (splitscreen > 1)
suggesty += 16;
}
else
suggesty -= (cv_kartspeedometer.value ? 16 : 0);
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
V_DrawFillConsoleMap(chatx + boxw + pm_offset + 2, suggesty - (7*skip), emote_suggest_boxw, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
// Highlight currently suggested emote
int hlflag = 0;
if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
hlflag = V_YELLOWMAP;
V_DrawSmallString(chatx + boxw + pm_offset + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
M_DrawEmote(chatx + boxw + pm_offset + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
++skip;
}
} }
HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space. HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.
@@ -2629,6 +2504,26 @@ void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags)
} }
} }
void HU_drawLocalPlayerPing(INT32 x, INT32 y, INT32 flags)
{
UINT32 lag = localplayerping;
const boolean gentleman = (cv_mindelay.value && (lag < (tic_t)simulated_lag));
if (gentleman)
{
lag = simulated_lag;
}
if (cv_pingstyle.value == 0) // kart
{
HU_drawKartPing(x, y, lag, flags, gentleman);
}
else if (cv_pingstyle.value == 1) // old style ping
{
HU_drawOldPing(x, y, lag, flags, gentleman);
}
}
// //
// HU_DrawSpectatorTicker // HU_DrawSpectatorTicker
// //
+1 -18
View File
@@ -42,15 +42,6 @@
#define CRED_FONTEND 'Z' // the last font character #define CRED_FONTEND 'Z' // the last font character
#define CRED_FONTSIZE (CRED_FONTEND - CRED_FONTSTART + 1) #define CRED_FONTSIZE (CRED_FONTEND - CRED_FONTSTART + 1)
extern char *shiftxform; // english translation shift table
extern char english_shiftxform[];
extern char french_shiftxform[];
extern char french_altgrxform[];
//fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
INT32 HU_FallBackFrSpecialLetter(INT32 key);
//------------------------------------ //------------------------------------
// sorted player lines // sorted player lines
//------------------------------------ //------------------------------------
@@ -68,12 +59,7 @@ typedef struct
#define HU_MAXMSGLEN 223 #define HU_MAXMSGLEN 223
#define HU_MSGBUFSIZE 255 #define HU_MSGBUFSIZE 255
#define MAX_CHAT_BUFSIZE 256 // that's enough messages, right? We'll delete the older ones when that gets out of hand. #define MAX_CHAT_BUFSIZE 256 // that's enough messages, right? We'll delete the older ones when that gets out of hand.
#define NETSPLITSCREEN // why the hell WOULDN'T we want this?
#ifdef NETSPLITSCREEN
#define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640) #define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
#else
#define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
#endif
#define CHAT_MUTE (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this still allows to open the chat but not to type. That's used for scrolling and whatnot. #define CHAT_MUTE (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this still allows to open the chat but not to type. That's used for scrolling and whatnot.
#define OLD_MUTE (OLDCHAT && cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this is used to prevent oldchat from opening when muted. #define OLD_MUTE (OLDCHAT && cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this is used to prevent oldchat from opening when muted.
@@ -110,8 +96,6 @@ void HU_LoadGraphics(void);
// reset heads up when consoleplayer respawns. // reset heads up when consoleplayer respawns.
void HU_Start(void); void HU_Start(void);
void HU_Shiftform(void);
boolean HU_Responder(event_t *ev); boolean HU_Responder(event_t *ev);
void HU_Ticker(void); void HU_Ticker(void);
void HU_TickSongCredits(void); void HU_TickSongCredits(void);
@@ -120,8 +104,7 @@ void HU_Drawer(void);
char HU_dequeueChatChar(void); char HU_dequeueChatChar(void);
void HU_clearChatChars(void); void HU_clearChatChars(void);
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags); // Lat': Ping drawer for scoreboard. void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags); // Lat': Ping drawer for scoreboard.
//void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer); void HU_drawLocalPlayerPing(INT32 x, INT32 y, INT32 flags);
//void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 hilicol); void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 hilicol);
void HU_DrawEmeralds(INT32 x, INT32 y, INT32 pemeralds); void HU_DrawEmeralds(INT32 x, INT32 y, INT32 pemeralds);
const char *HU_SkinColorToConsoleColor(skincolors_t color); const char *HU_SkinColorToConsoleColor(skincolors_t color);
+1 -22
View File
@@ -36,28 +36,7 @@ extern "C" {
"JOYBUTTONS is greater than INT64 bits can hold" "JOYBUTTONS is greater than INT64 bits can hold"
#endif #endif
/** \brief The struct JoyType_s #define DigitalGamepadStyle(i) (cv_joyscale[i].value == 0)
share some joystick information (maybe 2 for splitscreen), to the game input code,
actually, we need to know if it is a gamepad or analog controls
*/
struct JoyType_s
{
/*! if true, we MUST Poll() to get new joystick data,
that is: we NEED the DIRECTINPUTDEVICE2 ! (watchout NT compatibility) */
INT32 bJoyNeedPoll;
/*! this joystick is a gamepad, read: digital axes
if FALSE, interpret the joystick event data as JOYAXISRANGE (see above) */
INT32 bGamepadStyle;
};
typedef struct JoyType_s JoyType_t;
/** \brief Joystick info
for palyer[sic] 1-4's joystick/gamepad
*/
extern JoyType_t Joystick[MAXSPLITSCREENPLAYERS];
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
+10
View File
@@ -148,6 +148,11 @@ extern INT32 numcontrollers;
*/ */
const char *I_GetJoyName(INT32 joyindex); const char *I_GetJoyName(INT32 joyindex);
void I_SetJoystickFocus(void);
boolean I_GamepadHasLED(INT32 playernum);
boolean I_GamepadHasRumble(INT32 playernum);
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration); void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue); void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue);
@@ -198,6 +203,11 @@ void I_ShutdownSystem(void);
/** \brief To check if a Interrupt or Terminate Signal was fired /** \brief To check if a Interrupt or Terminate Signal was fired
*/ */
boolean I_Interrupted(void); boolean I_Interrupted(void);
static inline void I_HandleInterrupt(void)
{
if (I_Interrupted())
I_Quit();
}
/** \brief The I_GetDiskFreeSpace function /** \brief The I_GetDiskFreeSpace function
+3
View File
@@ -392,6 +392,9 @@ static const char *SOCK_GetNodeAddress(INT32 node)
if (node == 0) if (node == 0)
return "self"; return "self";
if (node < 0 || node > MAXNETNODES)
return NULL;
if (!nodeconnected[node]) if (!nodeconnected[node])
return NULL; return NULL;
+6
View File
@@ -446,6 +446,12 @@ void K_UpdateDirector(void)
} }
} }
// not sure if we should just stop here?
if (targetposition == MAXPLAYERS)
{
break;
}
target = directorinfo.sortedplayers[targetposition]; target = directorinfo.sortedplayers[targetposition];
// stop here since we're already viewing this player // stop here since we're already viewing this player
+131 -173
View File
@@ -83,6 +83,7 @@ IMPL_HUD_OFFSET(stat); // Stats
// extra hud things // extra hud things
consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showstats_skinname = {"showstats_skinname", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead
@@ -92,6 +93,7 @@ consvar_t cv_showinput = {"showinput", "Off", CV_SAVE, inputdisplay_cons_t, NULL
static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}}; static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}};
consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showminimapfinished = {"showminimapfinished", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF];
consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -108,6 +110,11 @@ consvar_t cv_fancyroulette = {"animatedroulette", "Off", CV_SAVE, CV_OnOff, NULL
consvar_t cv_darkitembox = {"darkitembox", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // itembox gets a dark border with specific items consvar_t cv_darkitembox = {"darkitembox", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // itembox gets a dark border with specific items
consvar_t cv_multiitemicon = {"multiitemicon", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_multiitemicon = {"multiitemicon", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
enum { ROULETTECOLOR_NONE = -1, ROULETTECOLOR_HUD, ROULETTECOLOR_PLAYER, ROULETTECOLOR_ITEM };
static CV_PossibleValue_t roulettecolor_cons_t[] = {
{ROULETTECOLOR_NONE, "None"}, {ROULETTECOLOR_HUD, "Hud"}, {ROULETTECOLOR_PLAYER, "Player"}, {ROULETTECOLOR_ITEM, "Item"}, {0, NULL}};
consvar_t cv_roulettecolor = {"roulettecolor", "Hud", CV_SAVE, roulettecolor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showlaptimes = {"showlaptimes", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showlaptimes = {"showlaptimes", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_biglaps = {"biglaphud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // here for ppl who dont want to make 2 more patches for their custom hud consvar_t cv_biglaps = {"biglaphud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // here for ppl who dont want to make 2 more patches for their custom hud
@@ -207,6 +214,7 @@ void K_RegisterKartHudStuff(void)
CV_RegisterVar(&cv_kartspeedometer); CV_RegisterVar(&cv_kartspeedometer);
CV_RegisterVar(&cv_showstats); CV_RegisterVar(&cv_showstats);
CV_RegisterVar(&cv_showstats_skinname);
CV_RegisterVar(&cv_showinput); CV_RegisterVar(&cv_showinput);
CV_RegisterVar(&cv_posanim); CV_RegisterVar(&cv_posanim);
@@ -221,6 +229,7 @@ void K_RegisterKartHudStuff(void)
CV_RegisterVar(&cv_minihead); CV_RegisterVar(&cv_minihead);
CV_RegisterVar(&cv_showminimapnames); CV_RegisterVar(&cv_showminimapnames);
CV_RegisterVar(&cv_showminimapfinished);
CV_RegisterVar(&cv_showminimapangle); CV_RegisterVar(&cv_showminimapangle);
CV_RegisterVar(&cv_showlapemblem); CV_RegisterVar(&cv_showlapemblem);
@@ -239,6 +248,8 @@ void K_RegisterKartHudStuff(void)
CV_RegisterVar(&cv_multiitemicon); CV_RegisterVar(&cv_multiitemicon);
CV_RegisterVar(&cv_huditemamount); CV_RegisterVar(&cv_huditemamount);
CV_RegisterVar(&cv_roulettecolor);
CV_RegisterVar(&cv_highresportrait); CV_RegisterVar(&cv_highresportrait);
CV_RegisterVar(&cv_nametag); CV_RegisterVar(&cv_nametag);
@@ -270,7 +281,6 @@ void K_RegisterKartHudStuff(void)
// Smol speedo // Smol speedo
static patch_t *skp_smallsticker = NULL; static patch_t *skp_smallsticker = NULL;
static patch_t *skp_smallsticker3 = NULL;
static patch_t *skp_speedpatches[5] = {NULL}; static patch_t *skp_speedpatches[5] = {NULL};
@@ -308,7 +318,6 @@ static patch_t *kp_bumperstickerwideclr = NULL;
static patch_t *kp_karmastickerclr = NULL; static patch_t *kp_karmastickerclr = NULL;
static patch_t *kp_timeoutstickerclr = NULL; static patch_t *kp_timeoutstickerclr = NULL;
static patch_t *skp_smallstickerclr = NULL; static patch_t *skp_smallstickerclr = NULL;
static patch_t *skp_smallstickerclr3 = NULL;
static patch_t *kp_itemmulstickerclr[2] = {NULL}; static patch_t *kp_itemmulstickerclr[2] = {NULL};
static patch_t *kp_itembgclr[4] = {NULL}; static patch_t *kp_itembgclr[4] = {NULL};
@@ -474,11 +483,6 @@ static void K_LoadSaturnHUDGraphics(void)
skp_smallstickerclr = (patch_t *)W_CachePatchName("SC_SMSTC", PU_HUDGFX); skp_smallstickerclr = (patch_t *)W_CachePatchName("SC_SMSTC", PU_HUDGFX);
} }
if (xtra_speedo_clr3)
{
skp_smallstickerclr3 = (patch_t *)W_CachePatchName("SC_SM3TC", PU_HUDGFX);
}
if (achi_speedo_clr) if (achi_speedo_clr)
{ {
skp_smallstickerachiclr = (patch_t *)W_CachePatchName("SC_AMSTC", PU_HUDGFX); skp_smallstickerachiclr = (patch_t *)W_CachePatchName("SC_AMSTC", PU_HUDGFX);
@@ -533,14 +537,6 @@ static void K_LoadSaturnHUDGraphics(void)
kp_itemmulstickerclr[0] = (patch_t *)W_CachePatchName("K_ITMULC", PU_HUDGFX); kp_itemmulstickerclr[0] = (patch_t *)W_CachePatchName("K_ITMULC", PU_HUDGFX);
} }
} }
if (found_extra3_kart)
{
if (xtra_speedo3) // 80x11 patch scaled to size
{
skp_smallsticker3 = (patch_t *)W_CachePatchName("SP_SM3TC", PU_HUDGFX);
}
}
} }
// -- Kart patches -- // -- Kart patches --
@@ -875,7 +871,7 @@ void K_LoadKartHUDGraphics(void)
kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX); kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX);
if (found_extra_kart || found_extra2_kart || found_extra3_kart) if (found_extra_kart || found_extra2_kart)
K_LoadSaturnHUDGraphics(); K_LoadSaturnHUDGraphics();
} }
@@ -1145,7 +1141,6 @@ enum
SPEEDO_DIAL, SPEEDO_DIAL,
SPEEDO_PMETER, SPEEDO_PMETER,
SPEEDO_PMETERSMOL, SPEEDO_PMETERSMOL,
SPEEDO_EXTRA3,
}; };
static SINT8 K_GetSpeedometerStyle(void) static SINT8 K_GetSpeedometerStyle(void)
@@ -1160,8 +1155,6 @@ static SINT8 K_GetSpeedometerStyle(void)
return SPEEDO_PMETER; return SPEEDO_PMETER;
else if (cv_newspeedometer.value == 6 && kartz_speedo_smol) else if (cv_newspeedometer.value == 6 && kartz_speedo_smol)
return SPEEDO_PMETERSMOL; return SPEEDO_PMETERSMOL;
else if (cv_newspeedometer.value == 7 && xtra_speedo3)
return SPEEDO_EXTRA3;
else else
return SPEEDO_VANILLA; return SPEEDO_VANILLA;
} }
@@ -1179,8 +1172,6 @@ static boolean K_UseColorSpeedo(int speedostyle)
return achi_speedo_clr; return achi_speedo_clr;
case SPEEDO_DIAL: case SPEEDO_DIAL:
return dial_speedo_clr; return dial_speedo_clr;
case SPEEDO_EXTRA3:
return xtra_speedo_clr3;
default: default:
return false; return false;
} }
@@ -1192,7 +1183,6 @@ enum
GAUGE_SMALL, GAUGE_SMALL,
GAUGE_BIGNUM, GAUGE_BIGNUM,
GAUGE_NUMONLY, GAUGE_NUMONLY,
GAUGE_EXTRA,
}; };
static SINT8 K_GetDriftgaugeStyle(void) static SINT8 K_GetDriftgaugeStyle(void)
@@ -1205,8 +1195,6 @@ static SINT8 K_GetDriftgaugeStyle(void)
return GAUGE_SMALL; return GAUGE_SMALL;
else if (cv_driftgaugestyle.value == 3) else if (cv_driftgaugestyle.value == 3)
return GAUGE_BIGNUM; return GAUGE_BIGNUM;
else if (cv_driftgaugestyle.value == 5 && xtra_speedo3)
return GAUGE_EXTRA;
} }
// Fallback // Fallback
@@ -1358,10 +1346,12 @@ INT32 K_getMinimapTrans(void)
return -1; return -1;
if (timeinmap <= 113) if (timeinmap <= 113)
{
minimaptrans = ((((INT32)timeinmap) - 105)*minimaptrans)/(113-105); minimaptrans = ((((INT32)timeinmap) - 105)*minimaptrans)/(113-105);
if (!minimaptrans) if (!minimaptrans)
return -1; return -1;
}
return (10-minimaptrans)<<FF_TRANSSHIFT; return (10-minimaptrans)<<FF_TRANSSHIFT;
} }
@@ -1403,7 +1393,6 @@ static void K_drawKartStats(void)
{ {
case SPEEDO_EXTRA: case SPEEDO_EXTRA:
case SPEEDO_ACHII: case SPEEDO_ACHII:
case SPEEDO_EXTRA3:
spdoffset = -10; spdoffset = -10;
break; break;
case SPEEDO_DIAL: case SPEEDO_DIAL:
@@ -1434,13 +1423,16 @@ static void K_drawKartStats(void)
fakeskin = K_GetPlayerSkin(stplyr); fakeskin = K_GetPlayerSkin(stplyr);
// Skin name // Skin name
if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel if (cv_showstats_skinname.value)
{ {
V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname); if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
} {
else V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
{ }
V_DrawThinString(x+20, y+7, flags2, fakeskin->realname); else
{
V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
}
} }
// Icon and stats // Icon and stats
@@ -1522,74 +1514,77 @@ static void K_drawKartItem(void)
if (stplyr->kartstuff[k_itemroulette]) if (stplyr->kartstuff[k_itemroulette])
{ {
localcolor = K_GetHudColor(); if (cv_roulettecolor.value == ROULETTECOLOR_PLAYER)
localcolor = stplyr->skincolor;
else if (cv_roulettecolor.value != ROULETTECOLOR_NONE)
localcolor = K_GetHudColor();
switch ((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3) switch ((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3)
{ {
// Each case is handled in threes, to give three frames of in-game time to see the item on the roulette // Each case is handled in threes, to give three frames of in-game time to see the item on the roulette
case 0: // Sneaker case 0: // Sneaker
localpatch = kp_sneaker[offset]; localpatch = kp_sneaker[offset];
//localcolor = SKINCOLOR_RASPBERRY; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_RASPBERRY;
break; break;
case 1: // Banana case 1: // Banana
localpatch = kp_banana[offset]; localpatch = kp_banana[offset];
//localcolor = SKINCOLOR_YELLOW; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_YELLOW;
break; break;
case 2: // Orbinaut case 2: // Orbinaut
localpatch = kp_orbinaut[3+offset]; localpatch = kp_orbinaut[3+offset];
//localcolor = SKINCOLOR_STEEL; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
break; break;
case 3: // Mine case 3: // Mine
localpatch = kp_mine[offset]; localpatch = kp_mine[offset];
//localcolor = SKINCOLOR_JET; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JET;
break; break;
case 4: // Grow case 4: // Grow
localpatch = kp_grow[offset]; localpatch = kp_grow[offset];
//localcolor = SKINCOLOR_TEAL; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TEAL;
break; break;
case 5: // Hyudoro case 5: // Hyudoro
localpatch = kp_hyudoro[offset]; localpatch = kp_hyudoro[offset];
//localcolor = SKINCOLOR_STEEL; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
break; break;
case 6: // Rocket Sneaker case 6: // Rocket Sneaker
localpatch = kp_rocketsneaker[offset]; localpatch = kp_rocketsneaker[offset];
//localcolor = SKINCOLOR_TANGERINE; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TANGERINE;
break; break;
case 7: // Jawz case 7: // Jawz
localpatch = kp_jawz[offset]; localpatch = kp_jawz[offset];
//localcolor = SKINCOLOR_JAWZ; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JAWZ;
break; break;
case 8: // Self-Propelled Bomb case 8: // Self-Propelled Bomb
localpatch = kp_selfpropelledbomb[offset]; localpatch = kp_selfpropelledbomb[offset];
//localcolor = SKINCOLOR_JET; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JET;
break; break;
case 9: // Shrink case 9: // Shrink
localpatch = kp_shrink[offset]; localpatch = kp_shrink[offset];
//localcolor = SKINCOLOR_ORANGE; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_ORANGE;
break; break;
case 10: // Invincibility case 10: // Invincibility
localpatch = localinv; localpatch = localinv;
//localcolor = SKINCOLOR_GREY; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_GREY;
break; break;
case 11: // Eggman Monitor case 11: // Eggman Monitor
localpatch = kp_eggman[offset]; localpatch = kp_eggman[offset];
//localcolor = SKINCOLOR_ROSE; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_ROSE;
break; break;
case 12: // Ballhog case 12: // Ballhog
localpatch = kp_ballhog[offset]; localpatch = kp_ballhog[offset];
//localcolor = SKINCOLOR_LILAC; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_LILAC;
break; break;
case 13: // Thunder Shield case 13: // Thunder Shield
localpatch = kp_thundershield[offset]; localpatch = kp_thundershield[offset];
//localcolor = SKINCOLOR_CYAN; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_CYAN;
break; break;
/*case 14: // Pogo Spring /*case 14: // Pogo Spring
localpatch = kp_pogospring[offset]; localpatch = kp_pogospring[offset];
localcolor = SKINCOLOR_TANGERINE; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TANGERINE;
break; break;
case 15: // Kitchen Sink case 15: // Kitchen Sink
localpatch = kp_kitchensink[offset]; localpatch = kp_kitchensink[offset];
localcolor = SKINCOLOR_STEEL; if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
break;*/ break;*/
default: default:
break; break;
@@ -2094,7 +2089,7 @@ static void K_DrawKartPositionNum(INT32 num)
fy = POSI_Y; fy = POSI_Y;
fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom.
flipdraw = true; flipdraw = true;
if (num && num >= 10) if (num >= 10)
fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen. fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen.
} }
else // else, that means we're P2 or P4. else // else, that means we're P2 or P4.
@@ -2176,8 +2171,9 @@ static boolean K_drawKartPositionFaces(void)
UINT8 *colormap; UINT8 *colormap;
ranklines = 0; ranklines = 0;
memset(completed, 0, sizeof (completed));
memset(rankplayer, 0, sizeof (rankplayer)); if (!LUA_HudEnabled(hud_minirankings))
return false; // Don't proceed but still return true for free play above if HUD is disabled.
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{ {
@@ -2192,8 +2188,7 @@ static boolean K_drawKartPositionFaces(void)
if (numplayersingame <= 1) if (numplayersingame <= 1)
return true; return true;
if (!LUA_HudEnabled(hud_minirankings)) memset(completed, 0, sizeof (completed));
return false; // Don't proceed but still return true for free play above if HUD is disabled.
for (j = 0; j < numplayersingame; j++) for (j = 0; j < numplayersingame; j++)
{ {
@@ -2250,6 +2245,7 @@ static boolean K_drawKartPositionFaces(void)
if (!playeringame[rankplayer[i]]) if (!playeringame[rankplayer[i]])
continue; continue;
if (player->spectator || !player->mo) if (player->spectator || !player->mo)
continue; continue;
@@ -2427,7 +2423,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
static boolean K_BigLap(void) static boolean K_BigLap(void)
{ {
return (cv_biglaps.value && (cv_numlaps.value > 9) && (K_UseColorHud() ? big_lap_color : big_lap) && (!stplyr->exiting)); return (cv_biglaps.value && (cv_numlaps.value > 9) && !stplyr->exiting && (K_UseColorHud() ? big_lap_color : big_lap));
} }
static void K_drawKartLaps(void) static void K_drawKartLaps(void)
@@ -2636,7 +2632,7 @@ static void K_drawKartSpeedometer(void)
return; return;
// index 0 is the raw value, index 1 is the converted value // index 0 is the raw value, index 1 is the converted value
fixed_t convSpeed[2] = {0,0}; fixed_t convSpeed[2] = {0, 0};
#ifdef ROTSPRITE #ifdef ROTSPRITE
fixed_t dial_divisor = DIALSPDDIV; fixed_t dial_divisor = DIALSPDDIV;
#endif #endif
@@ -2705,34 +2701,28 @@ static void K_drawKartSpeedometer(void)
V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric); V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric);
} }
else if (speedostyle == SPEEDO_EXTRA) // why bother if we dont? else if (speedostyle == SPEEDO_EXTRA || speedostyle == SPEEDO_ACHII) // why bother if we dont?
{ {
if (K_UseColorSpeedo(SPEEDO_EXTRA)) //Colourized hud patch_t *speedopat;
UINT8 *colormap = NULL;
if (K_UseColorSpeedo(speedostyle)) //Colourized hud
{ {
UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE); colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerclr, colormap);
speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_smallstickerclr : skp_smallstickerachiclr);
V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat, colormap);
speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_speedpatches[cv_kartspeedometer.value] : skp_speedpatchesachiclr[cv_kartspeedometer.value]);
} }
else else
V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallsticker); {
speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_smallsticker : skp_smallstickerachi);
V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat);
speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_speedpatches[cv_kartspeedometer.value] : skp_speedpatchesachi[cv_kartspeedometer.value]);
}
V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL); V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]); V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat, colormap);
}
else if (speedostyle == SPEEDO_ACHII) // why bother if we dont?
{
if (K_UseColorSpeedo(SPEEDO_ACHII)) //Colourized hud
{
UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachiclr, colormap);
V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachiclr[cv_kartspeedometer.value], colormap);
}
else
{
V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachi);
V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachi[cv_kartspeedometer.value]);
}
} }
#ifdef ROTSPRITE #ifdef ROTSPRITE
else if (speedostyle == SPEEDO_DIAL) // why bother if we dont? else if (speedostyle == SPEEDO_DIAL) // why bother if we dont?
@@ -2745,46 +2735,36 @@ static void K_drawKartSpeedometer(void)
(K_UseColorSpeedo(SPEEDO_DIAL))); (K_UseColorSpeedo(SPEEDO_DIAL)));
} }
#endif #endif
else if (speedostyle == SPEEDO_EXTRA3) // why bother if we dont?
{
if (K_UseColorSpeedo(SPEEDO_EXTRA3)) //Colourized hud
{
UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
V_DrawStretchyFixedPatch((SPDM_X-1)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallstickerclr3, colormap, 0);
}
else
V_DrawStretchyFixedPatch((SPDM_X-1)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallsticker3, NULL, 0);
V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]);
}
// Kart Z speedo bullshit... // Kart Z speedo bullshit...
// Draw the Speed counter. // Draw the Speed counter.
else if ((speedostyle == SPEEDO_PMETER) || (speedostyle == SPEEDO_PMETERSMOL)) else if ((speedostyle == SPEEDO_PMETER) || (speedostyle == SPEEDO_PMETERSMOL))
{ {
fixed_t fuspeed = 0;
INT32 spdpatch = 0; INT32 spdpatch = 0;
static const INT32 speedIntervals[22] = {2, 5, 7, 10, 12, 15, 17, static const INT32 spdinterval[22] = { 2, 5, 7, 10,
20, 22, 25, 27, 30, 32, 12, 15, 17, 20,
35, 37, 40, 42, 45, 47, 22, 25, 27, 30,
50, 52, 55}; 32, 35, 37, 40,
42, 45, 47, 50,
52, 55};
fuspeed = FixedDiv(stplyr->speed, mapobjectscale)/FRACUNIT; const fixed_t spd = FixedDiv(stplyr->speed, mapobjectscale) / FRACUNIT;
for (INT32 i = 0; i < 22; ++i) if (spd > 54)
{ {
if (fuspeed < speedIntervals[i]) spdpatch = (leveltime & 4) ? 24 : 23;
}
else
{
for (INT32 i = 0; i < 22; ++i)
{ {
spdpatch = i; if (spd < spdinterval[i])
break; {
spdpatch = i;
break;
}
} }
} }
if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && (leveltime & 4))
spdpatch = 24;
else if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && !(leveltime & 4))
spdpatch = 23;
V_DrawScaledPatch(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, (speedostyle == SPEEDO_PMETER) ? kp_kartzspeedo[spdpatch] : kp_kartzspeedo_smol[spdpatch]); V_DrawScaledPatch(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, (speedostyle == SPEEDO_PMETER) ? kp_kartzspeedo[spdpatch] : kp_kartzspeedo_smol[spdpatch]);
} }
} }
@@ -2812,7 +2792,7 @@ static void K_drawKartBumpersOrKarma(void)
{ {
const UINT8 speedostyle = K_GetSpeedometerStyle(); const UINT8 speedostyle = K_GetSpeedometerStyle();
if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII) || (speedostyle == SPEEDO_EXTRA3)) if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII))
fy += 5; fy += 5;
else else
fy += 7; fy += 7;
@@ -2904,10 +2884,12 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
x = (fixed_t)(viewangle - R_PointToAngle(targx, targy)); x = (fixed_t)(viewangle - R_PointToAngle(targx, targy));
distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK); distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK);
if (!distfact) distfact = 1; if (!distfact)
distfact = 1;
if (encoremode) if (encoremode)
x = -x; x = -x;
if (x < (fixed_t)ANGLE_270 || x > (fixed_t)ANGLE_90) if (x < (fixed_t)ANGLE_270 || x > (fixed_t)ANGLE_90)
return false; return false;
@@ -2989,7 +2971,7 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
if (stplyrnum > 0) if (stplyrnum > 0)
y = y + yres; y = y + yres;
} }
if (splitscreen >= 2) // 3P or 4P else if (splitscreen >= 2) // 3P or 4P
{ {
x = x>>1; x = x>>1;
y = y>>1; y = y>>1;
@@ -3049,9 +3031,11 @@ static void K_drawNameTags(void)
if (players[i].kartstuff[k_hyudorotimer]) // player is invisible if (players[i].kartstuff[k_hyudorotimer]) // player is invisible
continue; continue;
if (maxdistance) if (maxdistance)
{
distance = R_PointToDist(players[i].mo->x, players[i].mo->y); distance = R_PointToDist(players[i].mo->x, players[i].mo->y);
if (distance > maxdistance) if (distance > maxdistance)
continue; continue;
}
if (!P_CheckSightFast(stplyr->mo, players[i].mo)) if (!P_CheckSightFast(stplyr->mo, players[i].mo))
continue; continue;
@@ -3260,13 +3244,12 @@ static void K_drawDriftGauge(void)
if (!splitscreen && !camera->chase) if (!splitscreen && !camera->chase)
return; return;
if (forceshowhud) // i will skip the drift early return and you cant stop me!
goto skipcrap; // i will skip the drift early return and you cant stop me! if (!forceshowhud)
{
if (!stplyr->kartstuff[k_drift]) if (!stplyr->kartstuff[k_drift])
return; return;
}
skipcrap:
if (P_MobjWasRemoved(stplyr->mo)) if (P_MobjWasRemoved(stplyr->mo))
return; return;
@@ -3291,12 +3274,11 @@ skipcrap:
{ {
case GAUGE_DEFAULT: case GAUGE_DEFAULT:
case GAUGE_SMALL: case GAUGE_SMALL:
case GAUGE_EXTRA:
case GAUGE_BIGNUM: case GAUGE_BIGNUM:
{ {
patch_t *driftpatch = NULL; patch_t *driftpatch = NULL;
if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM || gaugestyle == GAUGE_EXTRA) if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM)
{ {
barx = basex - vid.dup*23; barx = basex - vid.dup*23;
BAR_WIDTH = vid.dup*47; BAR_WIDTH = vid.dup*47;
@@ -3309,30 +3291,15 @@ skipcrap:
bary = basey - vid.dup*2; bary = basey - vid.dup*2;
if (gaugestyle == GAUGE_EXTRA) // i hate hud code i hate hud code i hate hud code i hate hud code i hate hud code..... if (K_UseColorHud()) // Colourized hud
{ {
if (K_UseColorSpeedo(SPEEDO_EXTRA3)) // We reuse the extra speedometer patch hence this check colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
{ driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
driftpatch = skp_smallstickerclr3;
}
else
driftpatch = skp_smallsticker3;
V_DrawStretchyFixedPatch((basex - vid.dup*30)<<FRACBITS, ((basey<<FRACBITS) - FixedMul(vid.dup<<FRACBITS, 21*FRACUNIT/10)), XTRA3PSCALE, XTRA3VSCALE, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap, 0);
} }
else else
{ driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmall : driftgauge);
if (K_UseColorHud()) // Colourized hud
{
colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
}
else
driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmall : driftgauge);
V_DrawMappedPatch(gaugestyle == GAUGE_SMALL ? basex + vid.dup*11 : basex, basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap); V_DrawMappedPatch(gaugestyle == GAUGE_SMALL ? basex + vid.dup*11 : basex, basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap);
}
if (driftcharge >= driftval*4) // rainbow sparks if (driftcharge >= driftval*4) // rainbow sparks
{ {
@@ -3630,7 +3597,7 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
V_DrawCenteredSmallStringAtFixed(amxpos + (4*FRACUNIT), amypos - (3*FRACUNIT), V_ALLOWLOWERCASE|flags|V_SkinColorToHighlightcolor(mo->color), player_names[player - players]); V_DrawCenteredSmallStringAtFixed(amxpos + (4*FRACUNIT), amypos - (3*FRACUNIT), V_ALLOWLOWERCASE|flags|V_SkinColorToHighlightcolor(mo->color), player_names[player - players]);
} }
const boolean minihead = K_useSmallMinimapHead(mo->player); const boolean minihead = K_useSmallMinimapHead(player);
// thx wanted reticle for having weird offsets very cool // thx wanted reticle for having weird offsets very cool
wntdamxpos = minihead ? amxpos + (1<<FRACBITS) : amxpos - (4<<FRACBITS); wntdamxpos = minihead ? amxpos + (1<<FRACBITS) : amxpos - (4<<FRACBITS);
@@ -3772,6 +3739,9 @@ static void K_drawKartMinimap(void)
if (!players[i].mo || players[i].spectator) if (!players[i].mo || players[i].spectator)
continue; continue;
if (!cv_showminimapfinished.value && players[i].exiting)
continue;
if (P_IsDisplayPlayer(&players[i])) if (P_IsDisplayPlayer(&players[i]))
{ {
// Draw display players on top of everything else // Draw display players on top of everything else
@@ -4012,6 +3982,7 @@ static void K_drawBattleFullscreen(void)
{ {
if (stplyrnum == 0) if (stplyrnum == 0)
V_DrawFadeScreen(0xFF00, 16); V_DrawFadeScreen(0xFF00, 16);
if (stplyr->exiting < 6*TICRATE && !stplyr->spectator) if (stplyr->exiting < 6*TICRATE && !stplyr->spectator)
{ {
if (stplyr->kartstuff[k_position] == 1) if (stplyr->kartstuff[k_position] == 1)
@@ -4076,7 +4047,7 @@ static void K_drawBattleFullscreen(void)
{ {
if (i == displayplayers[0]) if (i == displayplayers[0])
continue; continue;
if (playeringame[i] && !stplyr->spectator) if (playeringame[i])
return; return;
} }
@@ -4293,6 +4264,7 @@ static void K_drawInput(void)
y -= FRACUNIT; y -= FRACUNIT;
// stick displays
if (cv_showinput.value == 2 || cv_showinput.value == 3) if (cv_showinput.value == 2 || cv_showinput.value == 3)
{ {
INT32 axis; INT32 axis;
@@ -4302,7 +4274,7 @@ static void K_drawInput(void)
const INT32 joyy = y>>FRACBITS; const INT32 joyy = y>>FRACBITS;
static const INT32 joyxoffs = -8; static const INT32 joyxoffs = -8;
static const INT32 joyyoffs = -24; static const INT32 joyyoffs = -24;
const boolean usejoysprite = (cv_showinput.value == 3 && joystickicon); const boolean usejoysprite = (cv_showinput.value == 3 && joystickicon);
// O backing // O backing
if (usejoysprite) if (usejoysprite)
@@ -4320,39 +4292,20 @@ static void K_drawInput(void)
// kart does not have anything we can get analogue joystick y axis values from // kart does not have anything we can get analogue joystick y axis values from
// during normal gameplay, so replicate shit here // during normal gameplay, so replicate shit here
// this is horrid but we cant get actual input in replays so uhh const boolean analogjoystickmove = (!demo.playback && P_IsLocalPlayer(stplyr) && cv_usejoystick[stplyrnum].value && !DigitalGamepadStyle(stplyrnum));
if (demo.playback || !P_IsLocalPlayer(stplyr)) // yeah........... axis = analogjoystickmove ? JoyAxis(AXISAIM, stplyrnum+1) : 0;
if (axis != 0)
{ {
hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN; hudforward -= ((axis * KART_FULLTURN) / JOYAXISRANGE);
} }
else else
{ {
const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle; hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN;
const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle;
const UINT8 ssplayer = stplyrnum+1;
axis = JoyAxis(AXISAIM, ssplayer);
if (analogjoystickmove && axis != 0)
{
// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
hudforward -= ((axis * KART_FULLTURN) / (JOYAXISRANGE-1));
}
else
{
if (InputDown(gc_aimforward, ssplayer) || (gamepadjoystickmove && axis < 0))
{
hudforward += KART_FULLTURN;
}
if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0))
{
hudforward-= KART_FULLTURN;
}
}
hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN);
} }
hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN);
if (cmd->driftturn || hudforward) if (cmd->driftturn || hudforward)
{ {
INT16 turning = encoremode ? -cmd->driftturn : cmd->driftturn; INT16 turning = encoremode ? -cmd->driftturn : cmd->driftturn;
@@ -4385,7 +4338,7 @@ static void K_drawInput(void)
} }
} }
} }
else else // wheel
{ {
if (!cmd->driftturn) // no turn if (!cmd->driftturn) // no turn
target = 0; target = 0;
@@ -4432,6 +4385,7 @@ static void K_drawChallengerScreen(void)
19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact 19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact
21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold 21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold
}; };
const UINT8 offset = min(52-1, (3*TICRATE)-mapreset); const UINT8 offset = min(52-1, (3*TICRATE)-mapreset);
V_DrawFadeScreen(0xFF00, 16); // Fade out V_DrawFadeScreen(0xFF00, 16); // Fade out
@@ -4485,7 +4439,7 @@ static void K_drawLapStartAnim(void)
char *lapnum = va("%02d", stplyr->laps + 1); char *lapnum = va("%02d", stplyr->laps + 1);
const size_t laplength = strlen(lapnum); const size_t laplength = strlen(lapnum);
for (int i = 0; i < (int)laplength; i++) for (size_t i = 0; i < laplength; i++)
{ {
int digit = lapnum[i] - '0'; int digit = lapnum[i] - '0';
int frame = min(2, progress/2 - 8 - (i*2)); int frame = min(2, progress/2 - 8 - (i*2));
@@ -4533,6 +4487,7 @@ static void K_drawDistributionDebugger(void)
kp_orbinaut[4], kp_orbinaut[4],
kp_jawz[1] kp_jawz[1]
}; };
INT32 useodds = 0; INT32 useodds = 0;
INT32 pingame = 0, bestbumper = 0; INT32 pingame = 0, bestbumper = 0;
INT32 i; INT32 i;
@@ -4549,8 +4504,10 @@ static void K_drawDistributionDebugger(void)
if (!playeringame[i] || players[i].spectator) if (!playeringame[i] || players[i].spectator)
continue; continue;
pingame++; pingame++;
if (players[i].exiting) if (players[i].exiting)
dontforcespb = true; dontforcespb = true;
if (players[i].kartstuff[k_bumper] > bestbumper) if (players[i].kartstuff[k_bumper] > bestbumper)
bestbumper = players[i].kartstuff[k_bumper]; bestbumper = players[i].kartstuff[k_bumper];
} }
@@ -4704,6 +4661,7 @@ void K_drawKartHUD(void)
{ {
if (LUA_HudEnabled(hud_battlefullscreen)) if (LUA_HudEnabled(hud_battlefullscreen))
K_drawBattleFullscreen(); K_drawBattleFullscreen();
return; return;
} }
+2
View File
@@ -35,11 +35,13 @@ extern consvar_t cv_darkitembox;
extern consvar_t cv_biglaps; extern consvar_t cv_biglaps;
extern consvar_t cv_highresportrait; extern consvar_t cv_highresportrait;
extern consvar_t cv_showstats; extern consvar_t cv_showstats;
extern consvar_t cv_showstats_skinname;
extern consvar_t cv_fancyroulette; extern consvar_t cv_fancyroulette;
extern consvar_t cv_showlaptimes; extern consvar_t cv_showlaptimes;
extern consvar_t cv_battlespeedo; extern consvar_t cv_battlespeedo;
extern consvar_t cv_multiitemicon; extern consvar_t cv_multiitemicon;
extern consvar_t cv_huditemamount; extern consvar_t cv_huditemamount;
extern consvar_t cv_roulettecolor;
// for use in timeattack menu // for use in timeattack menu
extern patch_t *kp_facenum[MAXPLAYERS+1]; extern patch_t *kp_facenum[MAXPLAYERS+1];
+767 -660
View File
File diff suppressed because it is too large. Load diff
+42 -13
View File
@@ -358,7 +358,8 @@ static int lib_cvRegisterVar(lua_State *L)
#define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1))) #define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 1)) { while (lua_next(L, 1))
{
// stack: cvar table, cvar userdata, key/index, value // stack: cvar table, cvar userdata, key/index, value
// 1 2 3 4 // 1 2 3 4
i = 0; i = 0;
@@ -368,26 +369,40 @@ static int lib_cvRegisterVar(lua_State *L)
else if (lua_isstring(L, 3)) else if (lua_isstring(L, 3))
k = lua_tostring(L, 3); k = lua_tostring(L, 3);
if (i == 1 || (k && fasticmp(k, "name"))) { if (i == 1 || (k && fasticmp(k, "name")))
{
if (!lua_isstring(L, 4)) if (!lua_isstring(L, 4))
TYPEERROR("name", LUA_TSTRING) TYPEERROR("name", LUA_TSTRING)
cvar->name = Z_StrDup(lua_tostring(L, 4)); cvar->name = Z_StrDup(lua_tostring(L, 4));
} else if (i == 2 || (k && fasticmp(k, "defaultvalue"))) { }
else if (i == 2 || (k && fasticmp(k, "defaultvalue")))
{
if (!lua_isstring(L, 4)) if (!lua_isstring(L, 4))
TYPEERROR("defaultvalue", LUA_TSTRING) TYPEERROR("defaultvalue", LUA_TSTRING)
cvar->defaultvalue = Z_StrDup(lua_tostring(L, 4)); cvar->defaultvalue = Z_StrDup(lua_tostring(L, 4));
} else if (i == 3 || (k && fasticmp(k, "flags"))) { }
else if (i == 3 || (k && fasticmp(k, "flags")))
{
if (!lua_isnumber(L, 4)) if (!lua_isnumber(L, 4))
TYPEERROR("flags", LUA_TNUMBER) TYPEERROR("flags", LUA_TNUMBER)
cvar->flags = (INT32)lua_tointeger(L, 4); cvar->flags = (INT32)lua_tointeger(L, 4);
} else if (i == 4 || (k && fasticmp(k, "PossibleValue"))) { }
if (lua_islightuserdata(L, 4)) { else if (i == 4 || (k && fasticmp(k, "PossibleValue")))
{
if (lua_islightuserdata(L, 4))
{
CV_PossibleValue_t *pv = lua_touserdata(L, 4); CV_PossibleValue_t *pv = lua_touserdata(L, 4);
if (pv == CV_OnOff || pv == CV_YesNo || pv == CV_Unsigned || pv == CV_Natural) if (pv == CV_OnOff || pv == CV_YesNo || pv == CV_Unsigned || pv == CV_Natural)
cvar->PossibleValue = pv; cvar->PossibleValue = pv;
else else
FIELDERROR("PossibleValue", "CV_PossibleValue_t expected, got unrecognised pointer") FIELDERROR("PossibleValue", "CV_PossibleValue_t expected, got unrecognised pointer")
} else if (lua_istable(L, 4)) { }
else if (lua_istable(L, 4))
{
// Accepts tables in the form of {MIN=0, MAX=9999} or {Red=0, Green=1, Blue=2} // Accepts tables in the form of {MIN=0, MAX=9999} or {Red=0, Green=1, Blue=2}
// and converts them to CV_PossibleValue_t {{0,"MIN"},{9999,"MAX"}} or {{0,"Red"},{1,"Green"},{2,"Blue"}} // and converts them to CV_PossibleValue_t {{0,"MIN"},{9999,"MAX"}} or {{0,"Red"},{1,"Green"},{2,"Blue"}}
// //
@@ -398,7 +413,9 @@ static int lib_cvRegisterVar(lua_State *L)
CV_PossibleValue_t *cvpv; CV_PossibleValue_t *cvpv;
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 4)) {
while (lua_next(L, 4))
{
count++; count++;
lua_pop(L, 1); lua_pop(L, 1);
} }
@@ -412,7 +429,9 @@ static int lib_cvRegisterVar(lua_State *L)
i = 0; i = 0;
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 4)) {
while (lua_next(L, 4))
{
// stack: [...] PossibleValue table, index, value // stack: [...] PossibleValue table, index, value
// 4 5 6 // 4 5 6
if (lua_type(L, 5) != LUA_TSTRING if (lua_type(L, 5) != LUA_TSTRING
@@ -423,14 +442,19 @@ static int lib_cvRegisterVar(lua_State *L)
i++; i++;
lua_pop(L, 1); lua_pop(L, 1);
} }
cvpv[i].value = 0; cvpv[i].value = 0;
cvpv[i].strvalue = NULL; cvpv[i].strvalue = NULL;
cvar->PossibleValue = cvpv; cvar->PossibleValue = cvpv;
} else }
else
FIELDERROR("PossibleValue", va("%s or CV_PossibleValue_t expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1))) FIELDERROR("PossibleValue", va("%s or CV_PossibleValue_t expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1)))
} else if (i == 5 || (k && fasticmp(k, "func"))) { }
else if (i == 5 || (k && fasticmp(k, "func")))
{
if (!lua_isfunction(L, 4)) if (!lua_isfunction(L, 4))
TYPEERROR("func", LUA_TFUNCTION) TYPEERROR("func", LUA_TFUNCTION)
lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange"); lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange");
I_Assert(lua_istable(L, 5)); I_Assert(lua_istable(L, 5));
lua_pushlightuserdata(L, cvar); lua_pushlightuserdata(L, cvar);
@@ -438,9 +462,13 @@ static int lib_cvRegisterVar(lua_State *L)
lua_rawset(L, 5); lua_rawset(L, 5);
lua_pop(L, 1); lua_pop(L, 1);
cvar->func = Lua_OnChange; cvar->func = Lua_OnChange;
if (i == 5 && !(cvar->flags & CV_CALL))
{
category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
}
} }
else if (((i == 5 && !(cvar->flags & CV_CALL)) else if ((cvar->flags & CV_CALL && i == 6)
|| (cvar->flags & CV_CALL && i == 6))
|| (k && fasticmp(k, "category"))) || (k && fasticmp(k, "category")))
{ {
category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4); category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
@@ -451,6 +479,7 @@ static int lib_cvRegisterVar(lua_State *L)
{ {
menu_name = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4); menu_name = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
} }
lua_pop(L, 1); lua_pop(L, 1);
} }
#undef FIELDERROR #undef FIELDERROR
+17 -27
View File
@@ -199,7 +199,7 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type) FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
{ {
mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL); mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t"); luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t");
@@ -293,18 +293,17 @@ typedef struct Hook_State Hook_State;
typedef void (*Hook_Callback)(Hook_State *); typedef void (*Hook_Callback)(Hook_State *);
struct Hook_State { struct Hook_State {
INT32 status;/* return status to calling function */ INT32 status; /* return status to calling function */
void * userdata; void * userdata;
int hook_type; int hook_type;
mobjtype_t mobj_type;/* >0 if mobj hook */ mobjtype_t mobj_type; /* < NUMMOBJTYPES if mobj hook */
boolean force_mobj;// allows mobj_type equal 0 const char * string; /* used to fetch table, ran first if set */
const char * string;/* used to fetch table, ran first if set */ int top; /* index of last argument passed to hook */
int top;/* index of last argument passed to hook */ int id; /* id to fetch ref */
int id;/* id to fetch ref */ bool important; /* is this hook from local addon */
boolean important;/* is this hook from local addon */ int values; /* num arguments passed to hook */
int values;/* num arguments passed to hook */ int results; /* num values returned by hook */
int results;/* num values returned by hook */ Hook_Callback results_handler; /* callback when hook successfully returns */
Hook_Callback results_handler;/* callback when hook successfully returns */
}; };
enum { enum {
@@ -364,10 +363,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_hook
int default_status, int default_status,
int hook_type int hook_type
){ ){
hook->force_mobj = false;
return init_hook_type(hook, default_status, return init_hook_type(hook, default_status,
hook_type, 0, NULL, hook_type, NUMMOBJTYPES, NULL,
hookIds[hook_type].numHooks); hookIds[hook_type].numHooks);
} }
@@ -381,8 +378,6 @@ FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
const mobjtype_t mobj_type = const mobjtype_t mobj_type =
primary_mobj ? primary_mobj->type : NUMMOBJTYPES; primary_mobj ? primary_mobj->type : NUMMOBJTYPES;
hook->force_mobj = true;
return init_hook_type(hook, default_status, return init_hook_type(hook, default_status,
hook_type, mobj_type, NULL, hook_type, mobj_type, NULL,
mobj_hook_available(hook_type, mobj_type)); mobj_hook_available(hook_type, mobj_type));
@@ -395,10 +390,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_string_hook
int hook_type, int hook_type,
const char * string const char * string
){ ){
hook->force_mobj = false;
if (init_hook_type(hook, default_status, if (init_hook_type(hook, default_status,
hook_type, 0, string, hook_type, NUMMOBJTYPES, string,
stringHooks[hook_type].ref)) stringHooks[hook_type].ref))
{ {
lua_pushstring(gL, string); lua_pushstring(gL, string);
@@ -414,7 +407,7 @@ FUNCINLINE static ATTRINLINE boolean prepare_hud_hook
int hook_type int hook_type
){ ){
return init_hook_type(hook, 0, return init_hook_type(hook, 0,
hook_type, 0, NULL, hook_type, NUMMOBJTYPES, NULL,
hudHookIds[hook_type].numHooks); hudHookIds[hook_type].numHooks);
} }
@@ -554,14 +547,11 @@ static int call_hooks
{ {
calls += call_string_hooks(hook); calls += call_string_hooks(hook);
} }
else if (hook->force_mobj) else if (hook->mobj_type < NUMMOBJTYPES)
{ {
/* call generic mobj hooks first */ /* call generic mobj hooks first */
calls += call_mobj_type_hooks(hook, MT_NULL); calls += call_mobj_type_hooks(hook, MT_NULL);
calls += call_mobj_type_hooks(hook, hook->mobj_type);
if (hook->mobj_type < NUMMOBJTYPES)
calls += call_mobj_type_hooks(hook, hook->mobj_type);
ps_lua_mobjhooks.value.i += calls; ps_lua_mobjhooks.value.i += calls;
} }
else else
+1 -1
View File
@@ -1297,7 +1297,7 @@ static int lib_hudsetvotebackground(lua_State *L)
if (strlen(prefix) != 4) if (strlen(prefix) != 4)
{ {
return luaL_argerror(L, 1, "prefix should 4 characters wide"); return luaL_argerror(L, 1, "prefix should be 4 characters wide");
} }
strncpy(VoteScreen.luaPrefix, prefix, 4); strncpy(VoteScreen.luaPrefix, prefix, 4);
+28 -29
View File
@@ -650,34 +650,34 @@ void LUA_HUD_DrawList(huddrawlist_h list)
case DI_DrawString: case DI_DrawString:
switch(item->align) switch(item->align)
{ {
// hu_font // hu_font
case align_left: case align_left:
V_DrawString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_center: case align_center:
V_DrawCenteredString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawCenteredString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_right: case align_right:
V_DrawRightAlignedString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_fixed: case align_fixed:
V_DrawStringAtFixed(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawStringAtFixed(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
// hu_font, 0.5x scale // hu_font, 0.5x scale
case align_small: case align_small:
V_DrawSmallString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawSmallString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_smallright: case align_smallright:
V_DrawRightAlignedSmallString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedSmallString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
// tny_font // tny_font
case align_thin: case align_thin:
V_DrawThinString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawThinString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_thinright: case align_thinright:
V_DrawRightAlignedThinString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedThinString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
} }
break; break;
case DI_DrawKartString: case DI_DrawKartString:
V_DrawKartString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawKartString(LERPS(x), LERPS(y), item->flags, itemstr);
@@ -690,7 +690,6 @@ void LUA_HUD_DrawList(huddrawlist_h list)
break; break;
default: default:
I_Error("can't draw draw list item: invalid draw list item type"); I_Error("can't draw draw list item: invalid draw list item type");
continue;
} }
} }
} }
+15 -15
View File
@@ -652,7 +652,7 @@ static int line_get(lua_State *L)
LUA_PushUserdata(L, &sides[line->sidenum[0]], META_SIDE); LUA_PushUserdata(L, &sides[line->sidenum[0]], META_SIDE);
return 1; return 1;
case line_backside: // backside case line_backside: // backside
if (line->sidenum[1] == 0xffff) if (line->sidenum[1] == NO_INDEX)
return 0; return 0;
LUA_PushUserdata(L, &sides[line->sidenum[1]], META_SIDE); LUA_PushUserdata(L, &sides[line->sidenum[1]], META_SIDE);
return 1; return 1;
@@ -1506,7 +1506,6 @@ enum mapheaderinfo_e
mapheaderinfo_saveoverride, mapheaderinfo_saveoverride,
mapheaderinfo_levelflags, mapheaderinfo_levelflags,
mapheaderinfo_menuflags, mapheaderinfo_menuflags,
//mapheaderinfo_automap,
mapheaderinfo_mobj_scale, mapheaderinfo_mobj_scale,
}; };
@@ -1542,7 +1541,6 @@ static const char *const mapheaderinfo_opt[] = {
"saveoverride", "saveoverride",
"levelflags", "levelflags",
"menuflags", "menuflags",
//"automap",
"mobj_scale", "mobj_scale",
NULL, NULL,
}; };
@@ -1584,10 +1582,11 @@ static int mapheaderinfo_get(lua_State *L)
lua_pushinteger(L, header->muspos); lua_pushinteger(L, header->muspos);
break; break;
case mapheaderinfo_musinterfadeout: case mapheaderinfo_musinterfadeout:
lua_pushinteger(L, header->musinterfadeout); lua_pushinteger(L, 0); // unused
break; break;
case mapheaderinfo_musintername: case mapheaderinfo_musintername:
lua_pushstring(L, header->musintername); // uhh psure its fine to just push nil instead of empty string?
lua_pushstring(L, NULL);
break; break;
case mapheaderinfo_forcecharacter: case mapheaderinfo_forcecharacter:
lua_pushstring(L, header->forcecharacter); lua_pushstring(L, header->forcecharacter);
@@ -1641,10 +1640,10 @@ static int mapheaderinfo_get(lua_State *L)
lua_pushinteger(L, header->levelselect); lua_pushinteger(L, header->levelselect);
break; break;
case mapheaderinfo_bonustype: case mapheaderinfo_bonustype:
lua_pushinteger(L, header->bonustype); lua_pushinteger(L, 0); // unused
break; break;
case mapheaderinfo_saveoverride: case mapheaderinfo_saveoverride:
lua_pushinteger(L, header->saveoverride); lua_pushinteger(L, SAVE_DEFAULT); // unused
break; break;
case mapheaderinfo_levelflags: case mapheaderinfo_levelflags:
lua_pushinteger(L, header->levelflags); lua_pushinteger(L, header->levelflags);
@@ -1652,28 +1651,29 @@ static int mapheaderinfo_get(lua_State *L)
case mapheaderinfo_menuflags: case mapheaderinfo_menuflags:
lua_pushinteger(L, header->menuflags); lua_pushinteger(L, header->menuflags);
break; break;
/*case mapheaderinfo_automap:
lua_pushstring(L, header->selectheading);
break;*/
case mapheaderinfo_mobj_scale: case mapheaderinfo_mobj_scale:
lua_pushfixed(L, header->mobj_scale); lua_pushfixed(L, header->mobj_scale);
break; break;
// TODO add support for reading numGradedMares and grades
default: default:
{ {
// Read custom vars now // Read custom vars now
// (note: don't include the "LUA." in your lua scripts!) // (note: don't include the "LUA." in your lua scripts!)
UINT8 j = 0; if (!header->numCustomOptions) {
for (;j < header->numCustomOptions && !fastcmp(lua_tostring(L, 2), header->customopts[j].option); ++j); lua_pushnil(L);
break;
}
if(j < header->numCustomOptions) UINT8 j = 0;
const char *cusoptstr = lua_tostring(L, 2);
for (;j < header->numCustomOptions && !fastcmp(cusoptstr, header->customopts[j].option); ++j);
if (j < header->numCustomOptions)
lua_pushstring(L, header->customopts[j].value); lua_pushstring(L, header->customopts[j].value);
else else
lua_pushnil(L); lua_pushnil(L);
} }
} }
return 1; return 1;
} }
int LUA_MapLib(lua_State *L) int LUA_MapLib(lua_State *L)
+13 -8
View File
@@ -979,7 +979,7 @@ static void ArchiveExtVars(UINT8 **p, void *pointer, const char *ptype)
if (!gL) if (!gL)
{ {
if (fastcmp(ptype,"player")) // players must always be included, even if no vars if (fastcmp(ptype, "player")) // players must always be included, even if no vars
WRITEUINT16(*p, 0); WRITEUINT16(*p, 0);
return; return;
} }
@@ -995,7 +995,7 @@ static void ArchiveExtVars(UINT8 **p, void *pointer, const char *ptype)
if (!lua_istable(gL, -1)) if (!lua_istable(gL, -1))
{ // no extra values table { // no extra values table
lua_pop(gL, 1); lua_pop(gL, 1);
if (fastcmp(ptype,"player")) // players must always be included, even if no vars if (fastcmp(ptype, "player")) // players must always be included, even if no vars
WRITEUINT16(*p, 0); WRITEUINT16(*p, 0);
return; return;
} }
@@ -1007,13 +1007,13 @@ static void ArchiveExtVars(UINT8 **p, void *pointer, const char *ptype)
// skip anything that has an empty table and isn't a player. // skip anything that has an empty table and isn't a player.
if (i == 0) if (i == 0)
{ {
if (fastcmp(ptype,"player")) // always include players even if they have no extra variables if (fastcmp(ptype, "player")) // always include players even if they have no extra variables
WRITEUINT16(*p, 0); WRITEUINT16(*p, 0);
lua_pop(gL, 1); lua_pop(gL, 1);
return; return;
} }
if (fastcmp(ptype,"mobj")) // mobjs must write their mobjnum as a header if (fastcmp(ptype, "mobj")) // mobjs must write their mobjnum as a header
WRITEUINT32(*p, ((mobj_t *)pointer)->mobjnum); WRITEUINT32(*p, ((mobj_t *)pointer)->mobjnum);
WRITEUINT16(*p, i); WRITEUINT16(*p, i);
@@ -1065,8 +1065,9 @@ static void ArchiveTables(UINT8 **p)
n++; // the table contained a new table we'll have to archive. :( n++; // the table contained a new table we'll have to archive. :(
else if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise) else if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
{ {
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i); lua_pushvalue(gL, -2); // copy key for error message (lua_tostring may mutate it which confuses lua_next)
lua_pop(gL, 1); 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, 2); // pop key copy and value
continue; continue;
} }
else if (e == 3) // nil key due to invalid userdata. NOT an error. else if (e == 3) // nil key due to invalid userdata. NOT an error.
@@ -1080,11 +1081,15 @@ static void ArchiveTables(UINT8 **p)
if (e == 1) if (e == 1)
n++; // the table contained a new table we'll have to archive. :( n++; // the table contained a new table we'll have to archive. :(
else if (e == 2) // invalid value type else if (e == 2) // invalid value type
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_pushvalue(gL, -2); // copy key for error message (same as above)
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, -2));
lua_pop(gL, 1); // pop key copy
}
lua_pop(gL, 1); lua_pop(gL, 1);
} }
lua_pop(gL, 1); lua_pop(gL, 1);
WRITEUINT8(*p, ARCH_TEND); WRITEUINT8(*p, ARCH_TEND);
} }
-8
View File
@@ -249,9 +249,6 @@ boolean cht_Responder(event_t *ev)
#define REQUIRE_SINGLEPLAYER if (netgame || multiplayer)\ #define REQUIRE_SINGLEPLAYER if (netgame || multiplayer)\
{ CONS_Printf(M_GetText("This only works in single player.\n")); return; } { CONS_Printf(M_GetText("This only works in single player.\n")); return; }
#define REQUIRE_NOULTIMATE if (ultimatemode)\
{ CONS_Printf(M_GetText("You're too good to be cheating!\n")); return; }
// command that can be typed at the console! // command that can be typed at the console!
void Command_CheatNoClip_f(void) void Command_CheatNoClip_f(void)
{ {
@@ -259,7 +256,6 @@ void Command_CheatNoClip_f(void)
REQUIRE_INLEVEL; REQUIRE_INLEVEL;
REQUIRE_SINGLEPLAYER; REQUIRE_SINGLEPLAYER;
REQUIRE_NOULTIMATE;
plyr = &players[consoleplayer]; plyr = &players[consoleplayer];
plyr->pflags ^= PF_NOCLIP; plyr->pflags ^= PF_NOCLIP;
@@ -274,7 +270,6 @@ void Command_CheatGod_f(void)
REQUIRE_INLEVEL; REQUIRE_INLEVEL;
REQUIRE_SINGLEPLAYER; REQUIRE_SINGLEPLAYER;
REQUIRE_NOULTIMATE;
plyr = &players[consoleplayer]; plyr = &players[consoleplayer];
plyr->pflags ^= PF_GODMODE; plyr->pflags ^= PF_GODMODE;
@@ -289,7 +284,6 @@ void Command_CheatNoTarget_f(void)
REQUIRE_INLEVEL; REQUIRE_INLEVEL;
REQUIRE_SINGLEPLAYER; REQUIRE_SINGLEPLAYER;
REQUIRE_NOULTIMATE;
plyr = &players[consoleplayer]; plyr = &players[consoleplayer];
plyr->pflags ^= PF_INVIS; plyr->pflags ^= PF_INVIS;
@@ -593,7 +587,6 @@ void Command_Devmode_f(void)
#ifndef _DEBUG #ifndef _DEBUG
REQUIRE_SINGLEPLAYER; REQUIRE_SINGLEPLAYER;
#endif #endif
REQUIRE_NOULTIMATE;
if (COM_Argc() > 1) if (COM_Argc() > 1)
{ {
@@ -1048,7 +1041,6 @@ void Command_ObjectPlace_f(void)
{ {
REQUIRE_INLEVEL; REQUIRE_INLEVEL;
REQUIRE_SINGLEPLAYER; REQUIRE_SINGLEPLAYER;
REQUIRE_NOULTIMATE;
G_SetGameModified(multiplayer, true); G_SetGameModified(multiplayer, true);
-9
View File
@@ -29,7 +29,6 @@ void Command_ObjectPlace_f(void);
void Command_Writethings_f(void); void Command_Writethings_f(void);
extern consvar_t cv_opflags, cv_mapthingnum, cv_speed; extern consvar_t cv_opflags, cv_mapthingnum, cv_speed;
//extern consvar_t cv_snapto, cv_grid;
extern boolean objectplacing; extern boolean objectplacing;
extern mobjtype_t op_currentthing; extern mobjtype_t op_currentthing;
@@ -48,18 +47,10 @@ void Command_CheatNoClip_f(void);
void Command_CheatGod_f(void); void Command_CheatGod_f(void);
void Command_CheatNoTarget_f(void); void Command_CheatNoTarget_f(void);
void Command_Savecheckpoint_f(void); void Command_Savecheckpoint_f(void);
/*void Command_Getallemeralds_f(void);
void Command_Resetemeralds_f(void);
void Command_Setrings_f(void);
void Command_Setlives_f(void);
void Command_Setcontinues_f(void);*/
void Command_Devmode_f(void); void Command_Devmode_f(void);
void Command_Scale_f(void); void Command_Scale_f(void);
void Command_Gravflip_f(void); void Command_Gravflip_f(void);
void Command_Hurtme_f(void); void Command_Hurtme_f(void);
/*void Command_JumpToAxis_f(void);
void Command_Charability_f(void);
void Command_Charspeed_f(void);*/
void Command_Teleport_f(void); void Command_Teleport_f(void);
void Command_RTeleport_f(void); void Command_RTeleport_f(void);
void Command_Skynum_f(void); void Command_Skynum_f(void);
+3 -22
View File
@@ -479,32 +479,13 @@ UINT8 M_CheckLevelEmblems(void)
// Update Score, Time, Rings emblems // Update Score, Time, Rings emblems
for (i = 0; i < numemblems; ++i) for (i = 0; i < numemblems; ++i)
{ {
if (emblemlocations[i].type <= ET_SKIN || emblemlocations[i].collected) // Requires time on map <= x
if (emblemlocations[i].type != ET_TIME || emblemlocations[i].collected)
continue; continue;
levelnum = emblemlocations[i].level; levelnum = emblemlocations[i].level;
valToReach = emblemlocations[i].var; valToReach = emblemlocations[i].var;
res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
switch (emblemlocations[i].type)
{
/*case ET_SCORE: // Requires score on map >= x
res = (G_GetBestScore(levelnum) >= (unsigned)valToReach);
break;*/
case ET_TIME: // Requires time on map <= x
res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
break;
/*case ET_RINGS: // Requires rings on map >= x
res = (G_GetBestRings(levelnum) >= valToReach);
break;
case ET_NGRADE: // Requires NiGHTS grade on map >= x
res = (G_GetBestNightsGrade(levelnum, 0) >= valToReach);
break;
case ET_NTIME: // Requires NiGHTS time on map <= x
res = (G_GetBestNightsTime(levelnum, 0) <= (unsigned)valToReach);
break;*/
default: // unreachable but shuts the compiler up.
continue;
}
emblemlocations[i].collected = res; emblemlocations[i].collected = res;
if (res) if (res)
-10
View File
@@ -27,21 +27,11 @@ typedef enum
UC_MATCHESPLAYED, // SRB2Kart: MATCHESPLAYED [x played] UC_MATCHESPLAYED, // SRB2Kart: MATCHESPLAYED [x played]
UC_GAMECLEAR, // GAMECLEAR <x times> UC_GAMECLEAR, // GAMECLEAR <x times>
UC_ALLEMERALDS, // ALLEMERALDS <x times> UC_ALLEMERALDS, // ALLEMERALDS <x times>
//UC_ULTIMATECLEAR, // ULTIMATECLEAR <x times>
//UC_OVERALLSCORE, // OVERALLSCORE [score to beat]
UC_OVERALLTIME, // OVERALLTIME [time to beat, tics] UC_OVERALLTIME, // OVERALLTIME [time to beat, tics]
//UC_OVERALLRINGS, // OVERALLRINGS [rings to beat]
UC_MAPVISITED, // MAPVISITED [map number] UC_MAPVISITED, // MAPVISITED [map number]
UC_MAPBEATEN, // MAPBEATEN [map number] UC_MAPBEATEN, // MAPBEATEN [map number]
UC_MAPALLEMERALDS, // MAPALLEMERALDS [map number] UC_MAPALLEMERALDS, // MAPALLEMERALDS [map number]
//UC_MAPULTIMATE, // MAPULTIMATE [map number]
//UC_MAPPERFECT, // MAPPERFECT [map number]
//UC_MAPSCORE, // MAPSCORE [map number] [score to beat]
UC_MAPTIME, // MAPTIME [map number] [time to beat, tics] UC_MAPTIME, // MAPTIME [map number] [time to beat, tics]
//UC_MAPRINGS, // MAPRINGS [map number] [rings to beat]
//UC_NIGHTSSCORE, // NIGHTSSCORE [map number] <mare, omit or "0" for overall> [score to beat]
//UC_NIGHTSTIME, // NIGHTSTIME [map number] <mare, omit "0" overall> [time to beat, tics]
//UC_NIGHTSGRADE, // NIGHTSGRADE [map number] <mare, omit "0" overall> [grade]
UC_TRIGGER, // TRIGGER [trigger number] UC_TRIGGER, // TRIGGER [trigger number]
UC_TOTALEMBLEMS, // TOTALEMBLEMS [number of emblems] UC_TOTALEMBLEMS, // TOTALEMBLEMS [number of emblems]
UC_EMBLEM, // EMBLEM [emblem number] UC_EMBLEM, // EMBLEM [emblem number]
+1 -1
View File
@@ -278,7 +278,7 @@ void M_DrawScaledEmote(fixed_t x, fixed_t y, fixed_t scale, emote_t *emote, INT3
static void Command_ListEmotes_f(void) static void Command_ListEmotes_f(void)
{ {
const int EMOTES_PER_PAGE = 24; const int EMOTES_PER_PAGE = 24;
const int NUMPAGES = std::max<int>(emotes.size()/EMOTES_PER_PAGE, 1); const int NUMPAGES = emotes.size()/EMOTES_PER_PAGE + (emotes.size() % EMOTES_PER_PAGE != 0 ? 1 : 0);
int page = 1; int page = 1;
if (COM_Argc() > 1) if (COM_Argc() > 1)
+7
View File
@@ -62,6 +62,9 @@ FUNCMATH fixed_t FixedHypot(fixed_t x, fixed_t y)
angle_t angle; angle_t angle;
fixed_t dist; fixed_t dist;
I_Assert(x != INT32_MIN);
I_Assert(y != INT32_MIN);
x = abs(x); x = abs(x);
y = abs(y); y = abs(y);
@@ -77,6 +80,10 @@ FUNCMATH fixed_t FixedHypot(fixed_t x, fixed_t y)
if (!y) if (!y)
return x; return x;
// prevent underflow
if (y == INT32_MIN)
return INT32_MAX;
angle = (tantoangle[FixedDiv(y, x)>>DBITS] + ANGLE_90) >> ANGLETOFINESHIFT; angle = (tantoangle[FixedDiv(y, x)>>DBITS] + ANGLE_90) >> ANGLETOFINESHIFT;
// use as cosine // use as cosine
+76 -170
View File
@@ -149,9 +149,6 @@ M_waiting_mode_t m_waiting_mode = M_NOT_WAITING;
const char *quitmsg[NUM_QUITMESSAGES] = {}; const char *quitmsg[NUM_QUITMESSAGES] = {};
// Stuff for customizing the player select screen Tails 09-22-2003
description_t description[MAXSKINS] = {};
INT32 mapwads[NUMMAPS] = {}; INT32 mapwads[NUMMAPS] = {};
boolean browselocalskins = false; boolean browselocalskins = false;
@@ -186,8 +183,8 @@ static INT16 itemOn = 1; // menu item skull is on, Hack by Tails 09-18-2002
static INT16 skullAnimCounter = 10; // skull animation counter static INT16 skullAnimCounter = 10; // skull animation counter
static boolean interpTimerHackAllow = 0; static boolean interpTimerHackAllow = 0;
static UINT8 setupcontrolplayer; static UINT8 setupcontrolplayer;
static INT32 (*setupcontrols)[2]; // pointer to the gamecontrols of the player being edited static INT32 (*setupcontrols)[2]; // pointer to the gamecontrols of the player being edited
// shhh... what am I doing... nooooo! // shhh... what am I doing... nooooo!
static INT32 vidm_testingmode = 0; static INT32 vidm_testingmode = 0;
@@ -201,8 +198,8 @@ static char setupm_ip[64];
static textinput_t setupm_input_ip; static textinput_t setupm_input_ip;
static fixed_t multi_tics; static fixed_t multi_tics;
static state_t *multi_state; static state_t *multi_state;
// this is set before entering the MultiPlayer setup menu, // this is set before entering the MultiPlayer setup menu,
// for either player 1 or 2 // for either player 1 or 2
@@ -499,32 +496,6 @@ static consvar_t cv_dummystaff = {"dummystaff", "0", CV_HIDEN|CV_CALL, dummystaf
// all the menu definitions and onchanges reside in here now // all the menu definitions and onchanges reside in here now
#include "m_menudefs.c" #include "m_menudefs.c"
static INT32 M_ShiftChar(INT32 ch)
{
if (I_UseNativeKeyboard())
return ch;
if (cv_keyboardlayout.value == 3)
{
if (ch >= 32 && ch <= 141)
{
if (shiftdown)
ch = shiftxform[ch];
else if (altdown & 0x2)
ch = french_altgrxform[ch];
else
ch = HU_FallBackFrSpecialLetter(ch);
}
}
else
{
if (shiftdown && ch >= 32 && ch <= 127)
ch = shiftxform[ch];
}
return ch;
}
// //
// M_GetGametypeColor // M_GetGametypeColor
// //
@@ -1024,9 +995,9 @@ boolean M_Responder(event_t *ev)
//case KEY_JOY1 + 2: //case KEY_JOY1 + 2:
ch = KEY_ENTER; ch = KEY_ENTER;
break; break;
/*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now. /*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now.
ch = 'n'; ch = 'n';
break;*/ break;*/
case KEY_MOUSE1 + 1: case KEY_MOUSE1 + 1:
//case KEY_JOY1 + 1: //case KEY_JOY1 + 1:
ch = KEY_BACKSPACE; ch = KEY_BACKSPACE;
@@ -1054,11 +1025,12 @@ boolean M_Responder(event_t *ev)
const INT32 jxdeadzone = ((JOYAXISRANGE-1) * max(cv_xdeadzone[0].value, FRACUNIT/2)) >> FRACBITS; const INT32 jxdeadzone = ((JOYAXISRANGE-1) * max(cv_xdeadzone[0].value, FRACUNIT/2)) >> FRACBITS;
const INT32 jydeadzone = ((JOYAXISRANGE-1) * max(cv_ydeadzone[0].value, FRACUNIT/2)) >> FRACBITS; const INT32 jydeadzone = ((JOYAXISRANGE-1) * max(cv_ydeadzone[0].value, FRACUNIT/2)) >> FRACBITS;
INT32 accelaxis = abs(cv_moveaxis[0].value); INT32 accelaxis = abs(cv_moveaxis[0].value);
if (ev->data1 == 0) if (ev->data1 == 0)
{ {
if (ev->data3 != INT32_MAX) if (ev->data3 != INT32_MAX)
{ {
if (Joystick[0].bGamepadStyle || abs(ev->data3) > jydeadzone) if (DigitalGamepadStyle(0) || abs(ev->data3) > jydeadzone)
{ {
if (joywaity < thistime if (joywaity < thistime
&& (pjoyy == 0 || (ev->data3 < 0) != (pjoyy < 0))) // no previous direction OR change direction && (pjoyy == 0 || (ev->data3 < 0) != (pjoyy < 0))) // no previous direction OR change direction
@@ -1074,7 +1046,7 @@ boolean M_Responder(event_t *ev)
if (ev->data2 != INT32_MAX && joywaitx < thistime) if (ev->data2 != INT32_MAX && joywaitx < thistime)
{ {
if (Joystick[0].bGamepadStyle || abs(ev->data2) > jxdeadzone) if (DigitalGamepadStyle(0) || abs(ev->data2) > jxdeadzone)
{ {
if (joywaitx < thistime if (joywaitx < thistime
&& (pjoyx == 0 || (ev->data2 < 0) != (pjoyx < 0))) // no previous direction OR change direction && (pjoyx == 0 || (ev->data2 < 0) != (pjoyx < 0))) // no previous direction OR change direction
@@ -1093,19 +1065,22 @@ boolean M_Responder(event_t *ev)
// The following borrows heavily from Joy1Axis. // The following borrows heavily from Joy1Axis.
const boolean xmode = (accelaxis%2); const boolean xmode = (accelaxis%2);
INT32 retaxis = 0; INT32 retaxis = 0;
if (!xmode) if (!xmode)
accelaxis--; accelaxis--;
accelaxis /= 2; accelaxis /= 2;
if (ev->data1 == accelaxis) if (ev->data1 == accelaxis)
{ {
const INT32 jacceldeadzone = xmode ? jxdeadzone : jydeadzone; const INT32 jacceldeadzone = xmode ? jxdeadzone : jydeadzone;
retaxis = xmode ? ev->data2 : ev->data3; retaxis = xmode ? ev->data2 : ev->data3;
if (retaxis != INT32_MAX) if (retaxis != INT32_MAX)
{ {
if (cv_moveaxis[0].value < 0) if (cv_moveaxis[0].value < 0)
retaxis = -retaxis; retaxis = -retaxis;
if (Joystick[0].bGamepadStyle || retaxis > jacceldeadzone) if (DigitalGamepadStyle(0) || retaxis > jacceldeadzone)
{ {
if (joywaitaccel < thistime && retaxis > pjoyaccel) // only on upwards event if (joywaitaccel < thistime && retaxis > pjoyaccel) // only on upwards event
{ {
@@ -1253,7 +1228,7 @@ boolean M_Responder(event_t *ev)
// Handle menuitems which need a specific key handling // Handle menuitems which need a specific key handling
if (routine && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_KEYHANDLER) if (routine && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_KEYHANDLER)
{ {
ch = M_ShiftChar(ch); ch = CON_ShiftChar(ch);
routine(ch); routine(ch);
return true; return true;
} }
@@ -1283,6 +1258,7 @@ boolean M_Responder(event_t *ev)
void (*otherroutine)(event_t *sev) = currentMenu->menuitems[itemOn].itemaction; void (*otherroutine)(event_t *sev) = currentMenu->menuitems[itemOn].itemaction;
otherroutine(ev); //Alam: what a hack otherroutine(ev); //Alam: what a hack
} }
return true; return true;
} }
} }
@@ -1305,12 +1281,21 @@ boolean M_Responder(event_t *ev)
{ {
playback_last_menu_interaction_leveltime = leveltime; playback_last_menu_interaction_leveltime = leveltime;
// Flip left/right with up/down for the playback menu, since it's a horizontal icon row. // Flip left/right with up/down for the playback menu, since it's a horizontal icon row.
switch (ch) switch (ch)
{ {
case KEY_LEFTARROW: ch = KEY_UPARROW; break; case KEY_LEFTARROW:
case KEY_UPARROW: ch = KEY_RIGHTARROW; break; ch = KEY_UPARROW;
case KEY_RIGHTARROW: ch = KEY_DOWNARROW; break; break;
case KEY_DOWNARROW: ch = KEY_LEFTARROW; break; case KEY_UPARROW:
ch = KEY_RIGHTARROW;
break;
case KEY_RIGHTARROW:
ch = KEY_DOWNARROW;
break;
case KEY_DOWNARROW:
ch = KEY_LEFTARROW;
break;
// arbitrary keyboard shortcuts because fuck you // arbitrary keyboard shortcuts because fuck you
@@ -1361,7 +1346,8 @@ boolean M_Responder(event_t *ev)
G_AdjustView(4, 1, true); G_AdjustView(4, 1, true);
break; break;
default: break; default:
break;
} }
} }
@@ -1486,6 +1472,7 @@ boolean M_Responder(event_t *ev)
} }
return false; return false;
break;
default: default:
CON_Responder(ev); CON_Responder(ev);
@@ -1985,8 +1972,6 @@ void M_Ticker(void)
// //
void M_Init(void) void M_Init(void)
{ {
UINT8 i;
COM_AddCommand("manual", Command_Manual_f); COM_AddCommand("manual", Command_Manual_f);
CV_RegisterVar(&cv_nextmap); CV_RegisterVar(&cv_nextmap);
@@ -2032,15 +2017,6 @@ void M_Init(void)
quitmsg[QUIT3MSG5] = M_GetText("You'll be back to play soon, though...\n...right?\n\n(Press 'Y' to quit)"); quitmsg[QUIT3MSG5] = M_GetText("You'll be back to play soon, though...\n...right?\n\n(Press 'Y' to quit)");
quitmsg[QUIT3MSG6] = M_GetText("Aww, is Eggman's Nightclub too\ndifficult for you?\n\n(Press 'Y' to quit)"); quitmsg[QUIT3MSG6] = M_GetText("Aww, is Eggman's Nightclub too\ndifficult for you?\n\n(Press 'Y' to quit)");
// Setup PlayerMenu table
for (i = 0; i < MAXSKINS; i++)
{
PlayerMenu[i].status = (i == 0 ? IT_CALL : IT_DISABLED);
PlayerMenu[i].patch = PlayerMenu[i].text = NULL;
PlayerMenu[i].itemaction = M_ChoosePlayer;
PlayerMenu[i].alphaKey = 0;
}
#ifdef HWRENDER #ifdef HWRENDER
// Permanently hide some options based on render mode // Permanently hide some options based on render mode
if (rendermode == render_soft) if (rendermode == render_soft)
@@ -2064,7 +2040,6 @@ void M_Init(void)
OP_OpenGLOptionsMenu[op_gl_shader].status = IT_GRAYEDOUT; OP_OpenGLOptionsMenu[op_gl_shader].status = IT_GRAYEDOUT;
OP_OpenGLOptionsMenu[op_gl_lightdither].status = IT_GRAYEDOUT; OP_OpenGLOptionsMenu[op_gl_lightdither].status = IT_GRAYEDOUT;
OP_OpenGLOptionsMenu[op_gl_palrender].status = IT_GRAYEDOUT; OP_OpenGLOptionsMenu[op_gl_palrender].status = IT_GRAYEDOUT;
OP_OpenGLOptionsMenu[op_gl_flashpal].status = IT_GRAYEDOUT;
OP_ExpOptionsMenu[op_exp_paldepth].status = IT_GRAYEDOUT; OP_ExpOptionsMenu[op_exp_paldepth].status = IT_GRAYEDOUT;
} }
@@ -2096,55 +2071,6 @@ void M_Init(void)
M_TextInputInit(&menuinput, menu_text_input_buf, sizeof menu_text_input_buf); M_TextInputInit(&menuinput, menu_text_input_buf, sizeof menu_text_input_buf);
} }
void M_InitCharacterTables(void)
{
UINT8 i;
// Setup PlayerMenu table
for (i = 0; i < MAXSKINS; i++)
{
PlayerMenu[i].status = (i < 4 ? IT_CALL : IT_DISABLED);
PlayerMenu[i].patch = PlayerMenu[i].text = NULL;
PlayerMenu[i].itemaction = M_ChoosePlayer;
PlayerMenu[i].alphaKey = 0;
}
// Setup description table
for (i = 0; i < MAXSKINS; i++)
{
if (i == 0)
{
strcpy(description[i].notes, "\x82Sonic\x80 is the fastest of the three, but also the hardest to control. Beginners beware, but experts will find Sonic very powerful.\n\n\x82""Ability:\x80 Speed Thok\nDouble jump to zoom forward with a huge burst of speed.\n\n\x82Tip:\x80 Simply letting go of forward does not slow down in SRB2. To slow down, hold the opposite direction.");
strcpy(description[i].picname, "");
strcpy(description[i].skinname, "sonic");
}
else if (i == 1)
{
strcpy(description[i].notes, "\x82Tails\x80 is the most mobile of the three, but has the slowest speed. Because of his mobility, he's well-\nsuited to beginners.\n\n\x82""Ability:\x80 Fly\nDouble jump to start flying for a limited time. Repetitively hit the jump button to ascend.\n\n\x82Tip:\x80 To quickly descend while flying, hit the spin button.");
strcpy(description[i].picname, "");
strcpy(description[i].skinname, "tails");
}
else if (i == 2)
{
strcpy(description[i].notes, "\x82Knuckles\x80 is well-\nrounded and can destroy breakable walls simply by touching them, but he can't jump as high as the other two.\n\n\x82""Ability:\x80 Glide & Climb\nDouble jump to glide in the air as long as jump is held. Glide into a wall to climb it.\n\n\x82Tip:\x80 Press spin while climbing to jump off the wall; press jump instead to jump off\nand face away from\nthe wall.");
strcpy(description[i].picname, "");
strcpy(description[i].skinname, "knuckles");
}
else if (i == 3)
{
strcpy(description[i].notes, "\x82Sonic & Tails\x80 team up to take on Dr. Eggman!\nControl Sonic while Tails desperately struggles to keep up.\n\nPlayer 2 can control Tails directly by setting the controls in the options menu.\nTails's directional controls are relative to Player 1's camera.\n\nTails can pick up Sonic while flying and carry him around.");
strcpy(description[i].picname, "CHRS&T");
strcpy(description[i].skinname, "sonic&tails");
}
else
{
strcpy(description[i].notes, "???");
strcpy(description[i].picname, "");
strcpy(description[i].skinname, "");
}
}
}
// ========================================================================== // ==========================================================================
// SPECIAL MENU OPTION DRAW ROUTINES GO HERE // SPECIAL MENU OPTION DRAW ROUTINES GO HERE
// ========================================================================== // ==========================================================================
@@ -4113,6 +4039,9 @@ static void AddCheckedReplay(void)
// Check up to maxnum replays if they match with query // Check up to maxnum replays if they match with query
static void M_HutCheckReplays(size_t maxnum) static void M_HutCheckReplays(size_t maxnum)
{ {
// Stripped of color codes
char demo_title[sizeof(demolist_all[0].title)];
if (!replaynamesloaded) if (!replaynamesloaded)
return; return;
@@ -4145,7 +4074,9 @@ static void M_HutCheckReplays(size_t maxnum)
case MD_NOTLOADED: case MD_NOTLOADED:
case MD_OUTDATED: case MD_OUTDATED:
case MD_LOADED: case MD_LOADED:
if (demolist_all[replayquerycheck].title[0] && strcasestr(demolist_all[replayquerycheck].title, replayqueryinput.buffer) != NULL) StripColors(demo_title, demolist_all[replayquerycheck].title, sizeof(demo_title));
if (demolist_all[replayquerycheck].title[0] && strcasestr(demo_title, replayqueryinput.buffer) != NULL)
AddCheckedReplay(); // It matches, add it! AddCheckedReplay(); // It matches, add it!
else else
replayquerycheck++; // Doesn't match, moving on... replayquerycheck++; // Doesn't match, moving on...
@@ -4905,6 +4836,7 @@ static void M_HutStartReplay(INT32 choice)
demo.loadfiles = (itemOn == 0); demo.loadfiles = (itemOn == 0);
demo.ignorefiles = (itemOn != 0); demo.ignorefiles = (itemOn != 0);
CONS_Printf(M_GetText("Playing back demo '%s'.\n"), demolist[dir_on[menudepthleft]].filepath);
G_DoPlayDemo(demolist[dir_on[menudepthleft]].filepath); G_DoPlayDemo(demolist[dir_on[menudepthleft]].filepath);
} }
@@ -5402,7 +5334,7 @@ void M_SlotCvarIntoModMenu(consvar_t* cvar, const char* category, const char* na
} }
if (cvar->flags & CV_NETVAR) if (cvar->flags & CV_NETVAR)
OP_CustomCvarMenu[ccvarposition] = (menuitem_t){ IT_STRING | IT_CVAR , NULL, Z_StrDup(va("\x85 %s", name)), cvar, ccvaralphakey }; OP_CustomCvarMenu[ccvarposition] = (menuitem_t){ IT_STRING | IT_CVAR, NULL, Z_StrDup(va("\x85 %s", name)), cvar, ccvaralphakey };
else else
OP_CustomCvarMenu[ccvarposition] = (menuitem_t){ IT_STRING | IT_CVAR, NULL, Z_StrDup(name), cvar, ccvaralphakey }; OP_CustomCvarMenu[ccvarposition] = (menuitem_t){ IT_STRING | IT_CVAR, NULL, Z_StrDup(name), cvar, ccvaralphakey };
@@ -6466,7 +6398,7 @@ static void M_ChooseTimeAttack(INT32 choice)
static void M_HandleStaffReplay(INT32 choice) static void M_HandleStaffReplay(INT32 choice)
{ {
boolean exitmenu = false; // exit to previous menu boolean exitmenu = false; // exit to previous menu
lumpnum_t l = W_CheckNumForName(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value)); lumpnum_t l = W_CheckNumForName(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
switch (choice) switch (choice)
{ {
@@ -6496,7 +6428,7 @@ static void M_HandleStaffReplay(INT32 choice)
M_ClearMenus(true); M_ClearMenus(true);
modeattacking = ATTACKING_RECORD; modeattacking = ATTACKING_RECORD;
demo.loadfiles = false; demo.ignorefiles = true; // Just assume that record attack replays have the files needed demo.loadfiles = false; demo.ignorefiles = true; // Just assume that record attack replays have the files needed
G_DoPlayDemo(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value)); G_DoPlayDemo(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
break; break;
default: default:
break; break;
@@ -7937,25 +7869,24 @@ static void M_DrawSetupMultiPlayerMenu(void)
INT32 tw = 0; INT32 tw = 0;
spritedef_t *sprdef; spritedef_t *sprdef;
spriteframe_t *sprframe; spriteframe_t *sprframe;
patch_t *statbg = (patch_t *)W_CachePatchName("K_STATBG", PU_PATCH);
patch_t *statlr = (patch_t *)W_CachePatchName("K_STATLR", PU_PATCH);
patch_t *statud = (patch_t *)W_CachePatchName("K_STATUD", PU_PATCH);
patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0", PU_PATCH);
patch_t *patch; patch_t *patch;
UINT8 frame; UINT8 frame;
UINT8 speed; UINT8 speed;
UINT8 weight; UINT8 weight;
UINT8 i; UINT8 i;
UINT8 s, w; UINT8 s, w;
const UINT8 *flashcol = V_GetStringColormap(highlightflags);
INT32 skinnum = 0; INT32 skinnum = 0;
INT32 statx, staty; INT32 statx, staty;
UINT32 speenframe; UINT32 speenframe;
INT32 sltw, actw, hetw; INT32 sltw, actw, hetw;
UINT8 skintodisplay; UINT8 skintodisplay;
INT32 nameboxaddy = 0; INT32 nameboxaddy = 0;
int statoffset = 0;
int gridyoffset = 0; const UINT8 *flashcol = V_GetStringColormap(highlightflags);
patch_t *statbg = (patch_t *)W_CachePatchName("K_STATBG", PU_PATCH);
patch_t *statlr = (patch_t *)W_CachePatchName("K_STATLR", PU_PATCH);
patch_t *statud = (patch_t *)W_CachePatchName("K_STATUD", PU_PATCH);
patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0" , PU_PATCH);
mx = MP_PlayerSetupDef.x; mx = MP_PlayerSetupDef.x;
my = MP_PlayerSetupDef.y; my = MP_PlayerSetupDef.y;
@@ -7970,8 +7901,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
switch (cv_skinselectmenu.value) switch (cv_skinselectmenu.value)
{ {
case SKINMENUTYPE_EXTENDED: case SKINMENUTYPE_EXTENDED:
nameboxaddy = 6;
break;
case SKINMENUTYPE_GRID: case SKINMENUTYPE_GRID:
nameboxaddy = 6; nameboxaddy = 6;
break; break;
@@ -7987,39 +7916,23 @@ static void M_DrawSetupMultiPlayerMenu(void)
else else
M_DrawTextInput(mx + 40, my + nameboxaddy, &setupm_input, 0); M_DrawTextInput(mx + 40, my + nameboxaddy, &setupm_input, 0);
#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].realname : skins[setupm_fakeskin].realname)
#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
// draw skin string // draw skin string
st = V_StringWidth(skins[setupm_fakeskin].realname, 0); st = V_StringWidth(skins[setupm_fakeskin].realname, 0);
switch (cv_skinselectmenu.value) switch (cv_skinselectmenu.value)
{ {
case SKINMENUTYPE_EXTENDED: case SKINMENUTYPE_EXTENDED:
#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].realname : skins[setupm_fakeskin].realname) V_DrawString(statx - (statdp ? 50 : 113), staty - 10, V_6WIDTHSPACE, va("\x84%dS \x87%dW", GETSELECTEDSPEED, GETSELECTEDWEIGHT));
#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed) /* FALLTHRU */
#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0);
st = V_StringWidth(GETSELECTEDSKINNAME, 0);
V_DrawString((mx+(tw/2)) - (st/2), my + 37,
((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
GETSELECTEDSKINNAME);
if (statdp == true)
statoffset = 50;
else
statoffset = 113;
V_DrawString(statx - statoffset, staty - 10, V_6WIDTHSPACE, va("\x84%dS \x87%dW", GETSELECTEDSPEED, GETSELECTEDWEIGHT));
#undef GETSELECTEDSKINNAME
#undef GETSELECTEDSPEED
#undef GETSELECTEDWEIGHT
break;
case SKINMENUTYPE_GRID: case SKINMENUTYPE_GRID:
#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].realname : skins[setupm_fakeskin].realname) tw = V_StringWidth("Character", 0);
tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0);
st = V_StringWidth(GETSELECTEDSKINNAME, 0); st = V_StringWidth(GETSELECTEDSKINNAME, 0);
V_DrawString((mx+(tw/2)) - (st/2), my + 37, V_DrawString((mx+(tw/2)) - (st/2), my + 37,
((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE, ((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
GETSELECTEDSKINNAME); GETSELECTEDSKINNAME);
#undef GETSELECTEDSKINNAME
break; break;
case SKINMENUTYPE_2D: case SKINMENUTYPE_2D:
@@ -8097,8 +8010,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
break; break;
} }
#define GRIDSTATOFFSET 0
switch (cv_skinselectmenu.value) switch (cv_skinselectmenu.value)
{ {
case SKINMENUTYPE_EXTENDED: case SKINMENUTYPE_EXTENDED:
@@ -8110,9 +8021,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
if (itemOn == 1) if (itemOn == 1)
V_DrawSmallString(statx+101, staty-37, V_6WIDTHSPACE|highlightflags, "BS: change"); V_DrawSmallString(statx+101, staty-37, V_6WIDTHSPACE|highlightflags, "BS: change");
#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
if (statdp == true) if (statdp == true)
{ {
//Background //Background
@@ -8142,22 +8050,19 @@ static void M_DrawSetupMultiPlayerMenu(void)
} }
} }
#undef GETSELECTEDSPEED
#undef GETSELECTEDWEIGHT
break; break;
case SKINMENUTYPE_GRID: case SKINMENUTYPE_GRID:
// SRB2Kart: draw the stat backer // SRB2Kart: draw the stat backer
// labels // labels
V_DrawSmallString(statx+12+GRIDSTATOFFSET, staty+67, V_6WIDTHSPACE|highlightflags, "Acceleration"); V_DrawSmallString(statx+12, staty+67, V_6WIDTHSPACE|highlightflags, "Acceleration");
V_DrawSmallString(statx+76+GRIDSTATOFFSET, staty+67, V_6WIDTHSPACE|highlightflags, "Max Speed"); V_DrawSmallString(statx+76, staty+67, V_6WIDTHSPACE|highlightflags, "Max Speed");
V_DrawSmallString(statx+14+GRIDSTATOFFSET, staty+75, V_6WIDTHSPACE|highlightflags, "Handling"); V_DrawSmallString(statx+14, staty+75, V_6WIDTHSPACE|highlightflags, "Handling");
V_DrawSmallString(statx+21+GRIDSTATOFFSET, staty+108, V_6WIDTHSPACE|highlightflags, "Weight"); V_DrawSmallString(statx+21, staty+108, V_6WIDTHSPACE|highlightflags, "Weight");
// label arrows // label arrows
V_DrawFixedPatch(((statx+61+GRIDSTATOFFSET)<<FRACBITS) + (FRACUNIT>>1), (staty+67)<<FRACBITS, FRACUNIT>>1, 0, statlr, flashcol); V_DrawFixedPatch(((statx+61)<<FRACBITS) + (FRACUNIT>>1), (staty+67)<<FRACBITS, FRACUNIT>>1, 0, statlr, flashcol);
V_DrawFixedPatch((statx+40+GRIDSTATOFFSET)<<FRACBITS, (staty+80)<<FRACBITS, FRACUNIT>>1, 0, statud, flashcol); V_DrawFixedPatch((statx+40)<<FRACBITS, (staty+80)<<FRACBITS, FRACUNIT>>1, 0, statud, flashcol);
// bg // bg
V_DrawFixedPatch(((statx+48+GRIDSTATOFFSET)<<FRACBITS)+(FRACUNIT>>1), (staty+73)<<FRACBITS, FRACUNIT>>1, 0, statbg, NULL); V_DrawFixedPatch(((statx+48)<<FRACBITS)+(FRACUNIT>>1), (staty+73)<<FRACBITS, FRACUNIT>>1, 0, statbg, NULL);
for (i = 0; i < numskins; i++) // draw the stat dots for (i = 0; i < numskins; i++) // draw the stat dots
{ {
@@ -8165,7 +8070,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
{ {
speed = skins[i].kartspeed; speed = skins[i].kartspeed;
weight = skins[i].kartweight; weight = skins[i].kartweight;
V_DrawFixedPatch((((statx+46+GRIDSTATOFFSET) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL); V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
} }
} }
@@ -8191,9 +8096,9 @@ static void M_DrawSetupMultiPlayerMenu(void)
#define TEXTVERTSHIFT 10 #define TEXTVERTSHIFT 10
DRAWSLOW(statx - sltw - 2, staty); DRAWSLOW(statx - sltw - 2, staty);
DRAWSLOW(statx - sltw - 2, staty - TEXTVERTSHIFT+ (9 * 18) - 11); DRAWSLOW(statx - sltw - 2, staty - TEXTVERTSHIFT + (9 * 18) - 11);
DRAWFAST(statx + (9 * 18), staty); DRAWFAST(statx + (9 * 18), staty);
DRAWFAST(statx + (9 * 18), staty - TEXTVERTSHIFT+ (9 * 18) - 11); DRAWFAST(statx + (9 * 18), staty - TEXTVERTSHIFT + (9 * 18) - 11);
DRAWACCEL(statx - actw - 2, staty + TEXTVERTSHIFT); DRAWACCEL(statx - actw - 2, staty + TEXTVERTSHIFT);
DRAWACCEL(statx + (9 * 18), staty + TEXTVERTSHIFT); DRAWACCEL(statx + (9 * 18), staty + TEXTVERTSHIFT);
DRAWHEAVY(statx - hetw - 2, staty + (9 * 18) - 11); DRAWHEAVY(statx - hetw - 2, staty + (9 * 18) - 11);
@@ -8230,15 +8135,18 @@ static void M_DrawSetupMultiPlayerMenu(void)
break; break;
} }
#undef GETSELECTEDSKINNAME
#undef GETSELECTEDSPEED
#undef GETSELECTEDWEIGHT
switch (cv_skinselectmenu.value) switch (cv_skinselectmenu.value)
{ {
//Skin grid stuff //Skin grid stuff
case SKINMENUTYPE_EXTENDED: case SKINMENUTYPE_EXTENDED:
gridyoffset = 10;
for (s = 0; s < SKINGRIDNEWWIDTH*SKINGRIDNEWHEIGHT; s++) for (s = 0; s < SKINGRIDNEWWIDTH*SKINGRIDNEWHEIGHT; s++)
{ {
INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4; INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + gridyoffset); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4; INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + 10); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH); INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH);
INT32 skinn; INT32 skinn;
patch_t *face; patch_t *face;
@@ -8264,7 +8172,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
{ {
patch_t *cursor; patch_t *cursor;
INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20; INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ gridyoffset); INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ 10);
UINT8 cursorframe = (I_GetTime() / 4) % 7; UINT8 cursorframe = (I_GetTime() / 4) % 7;
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH); cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
@@ -8324,13 +8232,13 @@ static void M_DrawSetupMultiPlayerMenu(void)
weight = skins[selectedskin].kartweight; weight = skins[selectedskin].kartweight;
statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH); statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
V_DrawFixedPatch((((statx+46+GRIDSTATOFFSET) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, flashcol); V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, flashcol);
else else
V_DrawFixedPatch((((statx+46+GRIDSTATOFFSET) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL); V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
if (setupm_fakecolor) if (setupm_fakecolor)
V_DrawFixedPatch((((statx+46+GRIDSTATOFFSET) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE)); V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
} }
break; break;
case SKINMENUTYPE_2D: case SKINMENUTYPE_2D:
@@ -8381,7 +8289,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
} }
} }
break; break;
#undef GRIDSTATOFFSET
#undef SKINXSHIFT #undef SKINXSHIFT
default: default:
speed = skins[setupm_fakeskin].kartspeed; speed = skins[setupm_fakeskin].kartspeed;
@@ -10041,7 +9948,6 @@ static void M_DrawVideoMode(void)
va("Wait %d second%s", testtime, (testtime > 1) ? "s" : "")); va("Wait %d second%s", testtime, (testtime > 1) ? "s" : ""));
M_CentreText(OP_VideoModeDef.y + 158, M_CentreText(OP_VideoModeDef.y + 158,
"or press ESC to return"); "or press ESC to return");
} }
else else
{ {
-22
View File
@@ -50,9 +50,6 @@ void M_Drawer(void);
// Called by D_SRB2Main, loads the config file. // Called by D_SRB2Main, loads the config file.
void M_Init(void); void M_Init(void);
// Called by D_SRB2Main also, sets up the playermenu and description tables.
void M_InitCharacterTables(void);
// Called by intro code to force menu up upon a keypress, // Called by intro code to force menu up upon a keypress,
// does nothing if menu is already up. // does nothing if menu is already up.
void M_StartControlPanel(void); void M_StartControlPanel(void);
@@ -84,11 +81,6 @@ typedef enum
} menumessagetype_t; } menumessagetype_t;
void M_StartMessage(const char *string, void *routine, menumessagetype_t itemtype); void M_StartMessage(const char *string, void *routine, menumessagetype_t itemtype);
extern boolean DPADUPSCROLL;
extern boolean DPADDOWNSCROLL;
extern boolean DPADLEFTSCROLL;
extern boolean DPADRIGHTSCROLL;
typedef enum typedef enum
{ {
M_NOT_WAITING, M_NOT_WAITING,
@@ -168,8 +160,6 @@ boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt);
#define MAXMENUCCVARS 999 #define MAXMENUCCVARS 999
#define MAXTOOLTIPS 255
typedef union typedef union
{ {
struct menu_s *submenu; // IT_SUBMENU struct menu_s *submenu; // IT_SUBMENU
@@ -195,8 +185,6 @@ typedef struct menuitem_s
UINT16 alphaKey; UINT16 alphaKey;
} menuitem_t; } menuitem_t;
extern menuitem_t PlayerMenu[MAXSKINS];
typedef struct menu_s typedef struct menu_s
{ {
const char *menutitlepic; const char *menutitlepic;
@@ -227,14 +215,6 @@ extern menu_t SP_LoadDef;
void M_SetupJoystickMenu(INT32 choice); void M_SetupJoystickMenu(INT32 choice);
extern menu_t OP_JoystickSetDef; extern menu_t OP_JoystickSetDef;
// Stuff for customizing the player select screen
typedef struct
{
char notes[441];
char picname[8];
char skinname[SKINNAMESIZE*2+2]; // skin&skin\0
} description_t;
// mode descriptions for video mode menu // mode descriptions for video mode menu
typedef struct typedef struct
{ {
@@ -262,8 +242,6 @@ typedef struct
extern INT32 mapwads[NUMMAPS]; extern INT32 mapwads[NUMMAPS];
extern description_t description[MAXSKINS];
extern consvar_t cv_replaysearchrate; extern consvar_t cv_replaysearchrate;
extern consvar_t cv_showfocuslost; extern consvar_t cv_showfocuslost;
extern consvar_t cv_newgametype, cv_nextmap, cv_chooseskin, cv_serversort; extern consvar_t cv_newgametype, cv_nextmap, cv_chooseskin, cv_serversort;
+82 -81
View File
@@ -495,12 +495,6 @@ static menuitem_t SP_LevelStatsMenu[] =
{IT_KEYHANDLER | IT_NOTHING, NULL, "", M_HandleLevelStats, '\0'}, // dummy menuitem for the control func {IT_KEYHANDLER | IT_NOTHING, NULL, "", M_HandleLevelStats, '\0'}, // dummy menuitem for the control func
}; };
// A rare case.
// External files modify this menu, so we can't call it static.
// And I'm too lazy to go through and rename it everywhere. ARRGH!
#define M_ChoosePlayer NULL
menuitem_t PlayerMenu[MAXSKINS];
// ----------------------------------- // -----------------------------------
// Multiplayer and all of its submenus // Multiplayer and all of its submenus
// ----------------------------------- // -----------------------------------
@@ -1024,17 +1018,17 @@ static menuitem_t OP_OpenGLOptionsMenu[] =
{IT_STRING | IT_CVAR, NULL, "Shaders", &cv_glshaders, 25}, {IT_STRING | IT_CVAR, NULL, "Shaders", &cv_glshaders, 25},
{IT_STRING | IT_CVAR, NULL, "Palette Rendering", &cv_glpaletterendering, 30}, {IT_STRING | IT_CVAR, NULL, "Palette Rendering", &cv_glpaletterendering, 30},
{IT_STRING | IT_CVAR, NULL, "Texture Quality", &cv_gltexturedepth, 45}, {IT_STRING | IT_CVAR, NULL, "Texture Quality", &cv_gltexturedepth, 40},
{IT_STRING | IT_CVAR, NULL, "Texture Filter", &cv_glfiltermode, 50}, {IT_STRING | IT_CVAR, NULL, "Texture Filter", &cv_glfiltermode, 45},
{IT_STRING | IT_CVAR, NULL, "Anisotropic", &cv_glanisotropicmode, 55}, {IT_STRING | IT_CVAR, NULL, "Anisotropic", &cv_glanisotropicmode, 50},
{IT_STRING | IT_CVAR, NULL, "Visual Portals", &cv_glportals, 60}, {IT_STRING | IT_CVAR, NULL, "Visual Portals", &cv_glportals, 55},
{IT_STRING | IT_CVAR, NULL, "Wall Contrast Style", &cv_glfakecontrast, 70}, {IT_STRING | IT_CVAR, NULL, "Wall Contrast Style", &cv_glfakecontrast, 65},
{IT_STRING | IT_CVAR, NULL, "Slope Contrast", &cv_glslopecontrast, 75}, {IT_STRING | IT_CVAR, NULL, "Slope Contrast", &cv_glslopecontrast, 70},
{IT_STRING | IT_CVAR, NULL, "Dithered Lightning", &cv_gllightdither, 80}, {IT_STRING | IT_CVAR, NULL, "Dithered Lightning", &cv_gllightdither, 75},
{IT_STRING | IT_CVAR, NULL, "Sprite Billboarding", &cv_glspritebillboarding, 85}, {IT_STRING | IT_CVAR, NULL, "Sprite Billboarding", &cv_glspritebillboarding, 80},
{IT_STRING | IT_CVAR, NULL, "Software Perspective", &cv_glshearing, 90}, {IT_STRING | IT_CVAR, NULL, "Software Perspective", &cv_glshearing, 85},
{IT_STRING | IT_CVAR, NULL, "Rendering Distance", &cv_glrenderdistance, 95}, {IT_STRING | IT_CVAR, NULL, "Rendering Distance", &cv_glrenderdistance, 90},
}; };
static const char* OP_OpenGLTooltips[] = static const char* OP_OpenGLTooltips[] =
@@ -1043,7 +1037,6 @@ static const char* OP_OpenGLTooltips[] =
"Fallback 3D model for characters that don't have any.", "Fallback 3D model for characters that don't have any.",
"Graphical Shaders.", "Graphical Shaders.",
"Recreates the look of software mode.", "Recreates the look of software mode.",
"Flash palettes for palette rendering.",
"Bit-depth of textures.", "Bit-depth of textures.",
"Filter to use on textures.", "Filter to use on textures.",
"Anisotropic filtering.", "Anisotropic filtering.",
@@ -1062,7 +1055,6 @@ enum
op_gl_falbckmdls, op_gl_falbckmdls,
op_gl_shader, op_gl_shader,
op_gl_palrender, op_gl_palrender,
op_gl_flashpal,
op_gl_scrdepth, op_gl_scrdepth,
op_gl_filter, op_gl_filter,
op_gl_anis, op_gl_anis,
@@ -1193,20 +1185,20 @@ static menuitem_t OP_FocusOptionsMenu[] =
{ {
{IT_HEADER, NULL, "Game Focus Options", NULL, 0}, {IT_HEADER, NULL, "Game Focus Options", NULL, 0},
{IT_STRING|IT_CVAR, NULL, "Play Music While Unfocused", &cv_playmusicifunfocused, 30}, {IT_STRING|IT_CVAR, NULL, "Play Music While Unfocused", &cv_playmusicifunfocused, 10},
{IT_STRING|IT_CVAR, NULL, "Play SFX While Unfocused", &cv_playsoundifunfocused, 40}, {IT_STRING|IT_CVAR, NULL, "Play SFX While Unfocused", &cv_playsoundifunfocused, 20},
{IT_STRING|IT_CVAR, NULL, "Pause Game While Unfocused", &cv_pauseifunfocused, 60}, {IT_STRING|IT_CVAR, NULL, "Pause Game While Unfocused", &cv_pauseifunfocused, 40},
{IT_STRING|IT_CVAR, NULL, "Background FPS Cap", &cv_fpscapbg, 80}, {IT_STRING|IT_CVAR, NULL, "Background FPS Cap", &cv_fpscapbg, 60},
{IT_STRING|IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 100}, {IT_STRING|IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 80},
{IT_STRING|IT_CVAR, NULL, "Visible Mouse", &cv_mousevisible, 120}, {IT_STRING|IT_CVAR, NULL, "Visible Mouse", &cv_mousevisible, 100},
{IT_STRING|IT_CVAR, NULL, "Gamepad LED Color While Unfocused ", &cv_gamepadledifunfocused, 140},
{IT_STRING|IT_CVAR, NULL, "Gamepad Rumble While Unfocused", &cv_rumbleifunfocused, 150},
{IT_STRING|IT_CVAR, NULL, "Gamepad Inputs While Unfocused", &cv_gamepadifunfocused, 120},
{IT_STRING|IT_CVAR, NULL, "Gamepad LED Color While Unfocused ", &cv_gamepadledifunfocused, 130},
{IT_STRING|IT_CVAR, NULL, "Gamepad Rumble While Unfocused", &cv_rumbleifunfocused, 140},
}; };
static const char* OP_FocusOptionsTooltips[] = static const char* OP_FocusOptionsTooltips[] =
@@ -1218,6 +1210,7 @@ static const char* OP_FocusOptionsTooltips[] =
"Set manual framerate cap while the game is unfocused.", "Set manual framerate cap while the game is unfocused.",
"Should the FOCUS LOST window appear\n while the game is unfocused?", "Should the FOCUS LOST window appear\n while the game is unfocused?",
"Displays the mouse cursor while the game is in focus.", "Displays the mouse cursor while the game is in focus.",
"Should gamepad still control the game when unfocused?",
"Should gamepad LED indicator change color when unfocused?", "Should gamepad LED indicator change color when unfocused?",
"Should gamepad rumble apply when unfocused?", "Should gamepad rumble apply when unfocused?",
}; };
@@ -1312,29 +1305,29 @@ static menuitem_t OP_DiscordOptionsMenu[] =
static menuitem_t OP_HUDOptionsMenu[] = static menuitem_t OP_HUDOptionsMenu[] =
{ {
{IT_STRING | IT_CVAR, NULL, "Show HUD (F3)", &cv_showhud, 10}, {IT_STRING | IT_CVAR, NULL, "Show HUD (F3)", &cv_showhud, 10},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, {IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "HUD Visibility", &cv_translucenthud, 20}, NULL, "HUD Visibility", &cv_translucenthud, 20},
{IT_STRING | IT_SUBMENU, NULL, "Online HUD options...", &OP_ChatOptionsDef, 35}, {IT_STRING | IT_SUBMENU, NULL, "Online HUD options...", &OP_ChatOptionsDef, 35},
{IT_STRING | IT_CVAR, NULL, "Background Glass", &cons_backcolor, 45}, {IT_STRING | IT_CVAR, NULL, "Background Glass", &cons_backcolor, 45},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, {IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "Minimap Visibility", &cv_kartminimap, 60}, NULL, "Minimap Visibility", &cv_kartminimap, 60},
{IT_STRING | IT_CVAR, NULL, "Speedometer Display", &cv_kartspeedometer, 70}, {IT_STRING | IT_CVAR, NULL, "Speedometer Display", &cv_kartspeedometer, 70},
{IT_STRING | IT_CVAR, NULL, "Show \"CHECK\"", &cv_kartcheck, 80}, {IT_STRING | IT_CVAR, NULL, "Show \"CHECK\"", &cv_kartcheck, 80},
{IT_STRING | IT_CVAR, NULL, "Menu Highlights", &cons_menuhighlight, 95}, {IT_STRING | IT_CVAR, NULL, "Menu Highlights", &cons_menuhighlight, 95},
// highlight info - (GOOD HIGHLIGHT, WARNING HIGHLIGHT) - 110 (see M_DrawHUDOptions) // highlight info - (GOOD HIGHLIGHT, WARNING HIGHLIGHT) - 110 (see M_DrawHUDOptions)
{IT_STRING | IT_CVAR, NULL, "Console Text Size", &cv_constextsize, 120}, {IT_STRING | IT_CVAR, NULL, "Console Text Size", &cv_constextsize, 120},
{IT_STRING | IT_CVAR, NULL, "Show Console Prints in Menu",&cons_consoleprintinmenu, 130}, {IT_STRING | IT_CVAR, NULL, "Show Console Prints in Menu",&cons_consoleprintinmenu, 130},
{IT_STRING | IT_CVAR, NULL, "Show Track Addon Name", &cv_showtrackaddon, 145}, {IT_STRING | IT_CVAR, NULL, "Show Track Addon Name", &cv_showtrackaddon, 145},
{IT_STRING | IT_CVAR, NULL, "Show All Maps", &cv_showallmaps, 155}, {IT_STRING | IT_CVAR, NULL, "Show All Maps", &cv_showallmaps, 155},
{IT_STRING | IT_CVAR, NULL, "2D character select", &cv_skinselectmenu, 165}, {IT_STRING | IT_CVAR, NULL, "2D character select", &cv_skinselectmenu, 165},
}; };
static menuitem_t OP_CamOptionsMenu[] = static menuitem_t OP_CamOptionsMenu[] =
@@ -1696,29 +1689,30 @@ static menuitem_t OP_SaturnMenu[] =
{IT_STRING | IT_CVAR, NULL, "Minimum Input Delay", &cv_mindelay, 20}, {IT_STRING | IT_CVAR, NULL, "Minimum Input Delay", &cv_mindelay, 20},
{IT_STRING | IT_CVAR, NULL, "Gentlemens Ping", &cv_gentlemens, 25}, {IT_STRING | IT_CVAR, NULL, "Gentlemens Ping", &cv_gentlemens, 25},
{IT_STRING | IT_CVAR, NULL, "Server Info Screen", &cv_serverinfoscreen, 30}, {IT_STRING | IT_CVAR, NULL, "Server Info Screen", &cv_serverinfoscreen, 30},
{IT_STRING | IT_CVAR, NULL, "Server Addons Info", &cv_serveraddoninfo, 35},
{IT_STRING | IT_CVAR, NULL, "Skin Select Spinning Speed", &cv_skinselectspin, 40}, {IT_STRING | IT_CVAR, NULL, "Skin Select Spinning Speed", &cv_skinselectspin, 45},
{IT_STRING | IT_CVAR, NULL, "Colorized Speedlines", &cv_coloredspeedlines, 50}, {IT_STRING | IT_CVAR, NULL, "Colorized Speedlines", &cv_coloredspeedlines, 55},
{IT_STRING | IT_CVAR, NULL, "Colorized Sneakertrails", &cv_coloredsneakertrail, 55}, {IT_STRING | IT_CVAR, NULL, "Colorized Sneakertrails", &cv_coloredsneakertrail, 60},
{IT_STRING | IT_CVAR, NULL, "Player Blendeffects", &cv_playerblendeffects, 65}, {IT_STRING | IT_CVAR, NULL, "Player Blendeffects", &cv_playerblendeffects, 70},
{IT_STRING | IT_CVAR, NULL, "Bananadrag Jitter", &cv_bananajitter, 75}, {IT_STRING | IT_CVAR, NULL, "Bananadrag Jitter", &cv_bananajitter, 80},
{IT_STRING | IT_CVAR, NULL, "Midair Driftsparks", &cv_airsparks, 85}, {IT_STRING | IT_CVAR, NULL, "Midair Driftsparks", &cv_airsparks, 90},
{IT_STRING | IT_CVAR, NULL, "Show Localskin Menus", &cv_showlocalskinmenus, 95}, {IT_STRING | IT_CVAR, NULL, "Show Localskin Menus", &cv_showlocalskinmenus, 100},
{IT_STRING | IT_CVAR, NULL, "Uppercase Menu", &cv_menucaps, 105}, {IT_STRING | IT_CVAR, NULL, "Uppercase Menu", &cv_menucaps, 110},
{IT_STRING | IT_CVAR, NULL, "Keyboard Layout", &cv_keyboardlayout, 115}, {IT_STRING | IT_CVAR, NULL, "Keyboard Layout", &cv_keyboardlayout, 120},
{IT_STRING | IT_CVAR, NULL, "Less Midnight Channel Flicker", &cv_lessflicker, 125}, {IT_STRING | IT_CVAR, NULL, "Less Midnight Channel Flicker", &cv_lessflicker, 130},
{IT_SUBMENU|IT_STRING, NULL, "Saturn Hud...", &OP_SaturnHudDef, 135}, {IT_SUBMENU|IT_STRING, NULL, "Saturn Hud...", &OP_SaturnHudDef, 140},
{IT_SUBMENU|IT_STRING, NULL, "Sprite Distortion...", &OP_PlayerDistortDef, 140}, {IT_SUBMENU|IT_STRING, NULL, "Sprite Distortion...", &OP_PlayerDistortDef, 145},
{IT_SUBMENU|IT_STRING, NULL, "Saturn Credits", &OP_SaturnCreditsDef, 145}, // uwu {IT_SUBMENU|IT_STRING, NULL, "Saturn Credits", &OP_SaturnCreditsDef, 150}, // uwu
}; };
static const char* OP_SaturnTooltips[] = static const char* OP_SaturnTooltips[] =
@@ -1728,6 +1722,7 @@ static const char* OP_SaturnTooltips[] =
"Practice for online play! 0 = instant response.", "Practice for online play! 0 = instant response.",
"Simulate online input delay when hosting a server.\nValue choosen by Player with the lowest ping", "Simulate online input delay when hosting a server.\nValue choosen by Player with the lowest ping",
"Show a screen before joining a server displaying important information about it", "Show a screen before joining a server displaying important information about it",
"Show amount and types of addons that are loaded by server when joining",
"How much speen do you want?", "How much speen do you want?",
"Colourize the speedlines in your skincolor if you go fast enough!", "Colourize the speedlines in your skincolor if you go fast enough!",
"Colourize the sneaker flame trails in your skincolor!", "Colourize the sneaker flame trails in your skincolor!",
@@ -1830,47 +1825,51 @@ static menuitem_t OP_SaturnHudMenu[] =
{ {
{IT_HEADER, NULL, "Saturn Hud Options", NULL, 0}, {IT_HEADER, NULL, "Saturn Hud Options", NULL, 0},
{IT_STRING|IT_CVAR, NULL, "Speedometer Style", &cv_newspeedometer, 10}, {IT_STRING|IT_CVAR, NULL, "Speedometer Style", &cv_newspeedometer, 10},
{IT_STRING|IT_CVAR, NULL, "Battle Speedometer", &cv_battlespeedo, 15}, {IT_STRING|IT_CVAR, NULL, "Battle Speedometer", &cv_battlespeedo, 15},
{IT_STRING|IT_CVAR, NULL, "Colourized HUD", &cv_colorizedhud, 25}, {IT_STRING|IT_CVAR, NULL, "Colourized HUD", &cv_colorizedhud, 25},
{IT_STRING|IT_CVAR, NULL, "Colourized Itembox", &cv_colorizeditembox, 30}, {IT_STRING|IT_CVAR, NULL, "Colourized Itembox", &cv_colorizeditembox, 30},
{IT_STRING|IT_CVAR, NULL, "Colourized HUD Color", &cv_colorizedhudcolor, 35}, {IT_STRING|IT_CVAR, NULL, "Colourized HUD Color", &cv_colorizedhudcolor, 35},
{IT_STRING|IT_CVAR, NULL, "Input Display", &cv_showinput, 45}, {IT_STRING|IT_CVAR, NULL, "Input Display", &cv_showinput, 45},
{IT_STRING|IT_CVAR, NULL, "Stat Display", &cv_showstats, 55}, {IT_STRING|IT_CVAR, NULL, "Stat Display", &cv_showstats, 55},
{IT_STRING|IT_CVAR, NULL, "Skin Name in Stat Display", &cv_showstats_skinname, 60},
{IT_STRING|IT_CVAR, NULL, "Higher Resolution Portraits", &cv_highresportrait, 65}, {IT_STRING|IT_CVAR, NULL, "Higher Resolution Portraits", &cv_highresportrait, 70},
{IT_STRING|IT_CVAR, NULL, "Small Positionnumber", &cv_smallposnum, 75}, {IT_STRING|IT_CVAR, NULL, "Small Positionnumber", &cv_smallposnum, 80},
{IT_STRING|IT_CVAR, NULL, "Positionnumber Animation", &cv_posanim, 80}, {IT_STRING|IT_CVAR, NULL, "Positionnumber Animation", &cv_posanim, 85},
{IT_STRING|IT_CVAR, NULL, "Flash Lap Times", &cv_showlaptimes, 90}, {IT_STRING|IT_CVAR, NULL, "Flash Lap Times", &cv_showlaptimes, 95},
{IT_STRING|IT_CVAR, NULL, "Multi-Item icons", &cv_multiitemicon, 100}, {IT_STRING|IT_CVAR, NULL, "Multi-Item icons", &cv_multiitemicon, 105},
{IT_STRING|IT_CVAR, NULL, "Item Amount Number", &cv_huditemamount, 105}, {IT_STRING|IT_CVAR, NULL, "Item Amount Number", &cv_huditemamount, 110},
{IT_STRING|IT_CVAR, NULL, "Animated Roulette", &cv_fancyroulette, 110}, {IT_STRING|IT_CVAR, NULL, "Animated Roulette", &cv_fancyroulette, 115},
{IT_STRING|IT_CVAR, NULL, "Show Lap Emblem", &cv_showlapemblem, 120}, {IT_STRING|IT_CVAR, NULL, "Item Roulette Color", &cv_roulettecolor, 120},
{IT_STRING|IT_CVAR, NULL, "Show Cecho Messages", &cv_cechotoggle, 125},
{IT_STRING|IT_CVAR, NULL, "Show Names on Minimap", &cv_showminimapnames, 135}, {IT_STRING|IT_CVAR, NULL, "Show Lap Emblem", &cv_showlapemblem, 130},
{IT_STRING|IT_CVAR, NULL, "Small Minimap Players", &cv_minihead, 140}, {IT_STRING|IT_CVAR, NULL, "Show Cecho Messages", &cv_cechotoggle, 135},
{IT_STRING|IT_CVAR, NULL, "Spin Minimap Icons", &cv_spinoutroll, 145},
{IT_STRING|IT_CVAR, NULL, "Player Angle Visual", &cv_showminimapangle, 150},
{IT_STRING|IT_CVAR, NULL, "Music Credits", &cv_songcredits, 160}, {IT_STRING|IT_CVAR, NULL, "Show Names on Minimap", &cv_showminimapnames, 145},
{IT_STRING|IT_CVAR, NULL, "Music Credits on Pause", &cv_pausesongcredits, 165}, {IT_STRING|IT_CVAR, NULL, "Show Finished on Minimap", &cv_showminimapfinished, 150},
{IT_STRING|IT_CVAR, NULL, "Small Minimap Players", &cv_minihead, 155},
{IT_STRING|IT_CVAR, NULL, "Spin Minimap Icons", &cv_spinoutroll, 160},
{IT_STRING|IT_CVAR, NULL, "Player Angle Visual", &cv_showminimapangle, 165},
{IT_STRING|IT_CVAR, NULL, "Beta Intermissionscreen", &cv_betainterscreen, 175}, {IT_STRING|IT_CVAR, NULL, "Music Credits", &cv_songcredits, 175},
{IT_STRING|IT_CVAR, NULL, "Music Credits on Pause", &cv_pausesongcredits, 180},
{IT_STRING|IT_CVAR, NULL, "Show Director Prompt", &cv_showdirectorhud, 185}, {IT_STRING|IT_CVAR, NULL, "Beta Intermissionscreen", &cv_betainterscreen, 190},
{IT_STRING|IT_SUBMENU, NULL, "Nametags...", &OP_NametagDef, 195}, {IT_STRING|IT_CVAR, NULL, "Show Director Prompt", &cv_showdirectorhud, 200},
{IT_STRING|IT_SUBMENU, NULL, "Driftgauge...", &OP_DriftGaugeDef, 200},
{IT_SUBMENU|IT_STRING, NULL, "Hud Offsets...", &OP_HudOffsetDef, 210}, {IT_STRING|IT_SUBMENU, NULL, "Nametags...", &OP_NametagDef, 210},
{IT_STRING|IT_SUBMENU, NULL, "Driftgauge...", &OP_DriftGaugeDef, 215},
{IT_SUBMENU|IT_STRING, NULL, "Hud Offsets...", &OP_HudOffsetDef, 225},
}; };
static const char* OP_SaturnHudTooltips[] = static const char* OP_SaturnHudTooltips[] =
@@ -1883,6 +1882,7 @@ static const char* OP_SaturnHudTooltips[] =
"The color to use instead of the player color when\ncolourized hud is enabled.", "The color to use instead of the player color when\ncolourized hud is enabled.",
"Displays the input display and lets you choose its style.", "Displays the input display and lets you choose its style.",
"Enable the stat display.", "Enable the stat display.",
"Show skin name in the stat display.",
"Enable the use of the higher resolution want icons instead of rank\nfor some places.", "Enable the use of the higher resolution want icons instead of rank\nfor some places.",
"Make the Postionnumber half the size.", "Make the Postionnumber half the size.",
"Disable the animation of the Positionnumber\nwhen overtaking someone.", "Disable the animation of the Positionnumber\nwhen overtaking someone.",
@@ -1890,9 +1890,11 @@ static const char* OP_SaturnHudTooltips[] =
"Use extra graphics for multiple sneakers, bananas and jawz.", "Use extra graphics for multiple sneakers, bananas and jawz.",
"Change when the item amount is to be displayed.\nMultiple will always display the number.\nWhen you have multiple of the same Item.\nAlways will always display the number regardless of Item amount.", "Change when the item amount is to be displayed.\nMultiple will always display the number.\nWhen you have multiple of the same Item.\nAlways will always display the number regardless of Item amount.",
"Enables an animation while the roulette is active.", "Enables an animation while the roulette is active.",
"Changes the way items are colorized in roulette.",
"Show the big 'LAP' text on a lap change.", "Show the big 'LAP' text on a lap change.",
"Show the big Cecho Messages.", "Show the big Cecho Messages.",
"Show player names on the minimap.", "Show player names on the minimap.",
"Show players that have finished already on the minimap.",
"Minimize the player icons on the minimap.", "Minimize the player icons on the minimap.",
"Erratically rotate player icons during spinouts.", "Erratically rotate player icons during spinouts.",
"Visualize the player facing angle.", "Visualize the player facing angle.",
@@ -2772,6 +2774,5 @@ void M_UpdateOGLMenu(void)
OP_OpenGLOptionsMenu[op_gl_lightdither].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR; OP_OpenGLOptionsMenu[op_gl_lightdither].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
OP_OpenGLOptionsMenu[op_gl_palrender].status = (cv_glscreentextures.value != 2 || !HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR; OP_OpenGLOptionsMenu[op_gl_palrender].status = (cv_glscreentextures.value != 2 || !HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
OP_OpenGLOptionsMenu[op_gl_flashpal].status = (!HWR_ShouldUsePaletteRendering()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
} }
#endif #endif
+6 -6
View File
@@ -256,7 +256,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
return true; return true;
} }
if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown)) if (ctrldown && (cv_keyboardlayout.value != 3 || !altdown))
{ {
if (key == 'x' || key == 'X') if (key == 'x' || key == 'X')
{ {
@@ -381,10 +381,10 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
// allow people to use keypad in console (good for typing IP addresses) - Calum // allow people to use keypad in console (good for typing IP addresses) - Calum
if (key >= KEY_KEYPAD7 && key <= KEY_KPADDEL) if (key >= KEY_KEYPAD7 && key <= KEY_KPADDEL)
{ {
char keypad_translation[] = {'7','8','9','-', const char keypad_translation[] = {'7','8','9','-',
'4','5','6','+', '4','5','6','+',
'1','2','3', '1','2','3',
'0','.'}; '0', '.'};
key = keypad_translation[key - KEY_KEYPAD7]; key = keypad_translation[key - KEY_KEYPAD7];
} }
@@ -392,7 +392,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
key = '/'; key = '/';
// same capslock code as hu_stuff.c's HU_responder. Check there for details. // same capslock code as hu_stuff.c's HU_responder. Check there for details.
key = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(key) : CON_ShiftChar(key); key = CON_ShiftChar(key);
// enter a char into the command prompt // enter a char into the command prompt
if (key < 32 || key > 127) if (key < 32 || key > 127)
+5
View File
@@ -599,9 +599,14 @@ Update_parameters (void)
delayed = MSInProgress; delayed = MSInProgress;
if (delayed)/* do another update after the current one */ if (delayed)/* do another update after the current one */
{
registered = 0;
MSUpdateAgain = true; MSUpdateAgain = true;
}
else else
{
registered = MSRegistered; registered = MSRegistered;
}
} }
Unlock_state(); Unlock_state();
+28 -62
View File
@@ -306,7 +306,6 @@ void P_NewChaseDir(mobj_t *actor)
dirtype_t d[3]; dirtype_t d[3];
dirtype_t tdir = DI_NODIR, olddir, turnaround; dirtype_t tdir = DI_NODIR, olddir, turnaround;
I_Assert(actor->target != NULL);
I_Assert(!P_MobjWasRemoved(actor->target)); I_Assert(!P_MobjWasRemoved(actor->target));
olddir = actor->movedir; olddir = actor->movedir;
@@ -329,7 +328,7 @@ void P_NewChaseDir(mobj_t *actor)
else else
d[1] = DI_NODIR; d[1] = DI_NODIR;
if (twodlevel || actor->flags2 & MF2_TWOD) if (UNLIKELY(twodlevel || actor->flags2 & MF2_TWOD))
d[2] = DI_NODIR; d[2] = DI_NODIR;
if (deltay < -FixedMul(10*FRACUNIT, actor->scale)) if (deltay < -FixedMul(10*FRACUNIT, actor->scale))
d[2] = DI_SOUTH; d[2] = DI_SOUTH;
@@ -619,7 +618,6 @@ void A_Chase(void *thing)
if (LUA_CallAction(A_CHASE, actor)) if (LUA_CallAction(A_CHASE, actor))
return; return;
I_Assert(actor != NULL);
I_Assert(!P_MobjWasRemoved(actor)); I_Assert(!P_MobjWasRemoved(actor));
if (actor->reactiontime) if (actor->reactiontime)
@@ -874,7 +872,7 @@ void A_PointyThink(void *thing)
TVector v; TVector v;
TVector *res; TVector *res;
angle_t fa; angle_t fa;
fixed_t radius = FixedMul(actor->info->radius*actor->info->reactiontime, actor->scale); fixed_t radius;
boolean firsttime = true; boolean firsttime = true;
INT32 sign; INT32 sign;
@@ -932,6 +930,8 @@ void A_PointyThink(void *thing)
if (!actor->tracer) // For some reason we do not have spike balls... if (!actor->tracer) // For some reason we do not have spike balls...
return; return;
radius = FixedMul(actor->info->radius*actor->info->reactiontime, actor->scale);
// Position spike balls relative to the value of 'lastlook'. // Position spike balls relative to the value of 'lastlook'.
ball = actor->tracer; ball = actor->tracer;
@@ -1531,10 +1531,7 @@ void A_LobShot(void *thing)
if (!(actor->flags & MF_BOSS)) if (!(actor->flags & MF_BOSS))
{ {
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
} }
} }
@@ -1570,10 +1567,7 @@ void A_FireShot(void *thing)
if (!(actor->flags & MF_BOSS)) if (!(actor->flags & MF_BOSS))
{ {
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
} }
} }
@@ -1613,10 +1607,7 @@ void A_SuperFireShot(void *thing)
if (!(actor->flags & MF_BOSS)) if (!(actor->flags & MF_BOSS))
{ {
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
} }
} }
@@ -2770,9 +2761,11 @@ void A_Invincibility(void *thing)
if (P_IsLocalPlayer(player) && !player->powers[pw_super]) if (P_IsLocalPlayer(player) && !player->powers[pw_super])
{ {
S_StopMusic(); S_StopMusic();
if (mariomode)
if (UNLIKELY(mariomode))
G_GhostAddColor((INT32) (player - players), GHC_INVINCIBLE); G_GhostAddColor((INT32) (player - players), GHC_INVINCIBLE);
S_ChangeMusicInternal((mariomode) ? "minvnc" : "invinc", false);
S_ChangeMusicInternal((UNLIKELY(mariomode)) ? "minvnc" : "invinc", false);
} }
} }
@@ -2870,12 +2863,6 @@ void A_ExtraLife(void *thing)
if (actor->type == MT_1UPICO && !actor->tracer) if (actor->type == MT_1UPICO && !actor->tracer)
actor->frame -= 2; // No lives icon for this player, use the default. actor->frame -= 2; // No lives icon for this player, use the default.
if (ultimatemode) //I don't THINK so!
{
S_StartSound(player->mo, sfx_lose);
return;
}
// In shooter gametypes, give the player 100 rings instead of an extra life. // In shooter gametypes, give the player 100 rings instead of an extra life.
if (gametype != GT_COOP && gametype != GT_COMPETITION) if (gametype != GT_COOP && gametype != GT_COMPETITION)
P_GivePlayerRings(player, 100); P_GivePlayerRings(player, 100);
@@ -3650,7 +3637,7 @@ static inline boolean PIT_GrenadeRing(mobj_t *thing)
return true; return true;
if (thing->player && (thing->player->kartstuff[k_hyudorotimer] if (thing->player && (thing->player->kartstuff[k_hyudorotimer]
|| (G_BattleGametype() && thing->player && thing->player->kartstuff[k_bumper] <= 0 && thing->player->kartstuff[k_comebacktimer]))) || (G_BattleGametype() && thing->player->kartstuff[k_bumper] <= 0 && thing->player->kartstuff[k_comebacktimer])))
return true; return true;
if ((gametype == GT_CTF || gametype == GT_TEAMMATCH) if ((gametype == GT_CTF || gametype == GT_TEAMMATCH)
@@ -4015,26 +4002,13 @@ void A_JetChase(void *thing)
} }
// chase towards player // chase towards player
if (ultimatemode) P_Thrust(actor, actor->angle, FixedMul(actor->info->speed/4, actor->scale));
P_Thrust(actor, actor->angle, FixedMul(actor->info->speed/2, actor->scale));
else
P_Thrust(actor, actor->angle, FixedMul(actor->info->speed/4, actor->scale));
// must adjust height // must adjust height
if (ultimatemode) if (actor->z < (actor->target->z + actor->target->height + FixedMul((32<<FRACBITS), actor->scale)))
{ actor->momz += FixedMul(FRACUNIT/2, actor->scale);
if (actor->z < (actor->target->z + actor->target->height + FixedMul((64<<FRACBITS), actor->scale)))
actor->momz += FixedMul(FRACUNIT/2, actor->scale);
else
actor->momz -= FixedMul(FRACUNIT/2, actor->scale);
}
else else
{ actor->momz -= FixedMul(FRACUNIT/2, actor->scale);
if (actor->z < (actor->target->z + actor->target->height + FixedMul((32<<FRACBITS), actor->scale)))
actor->momz += FixedMul(FRACUNIT/2, actor->scale);
else
actor->momz -= FixedMul(FRACUNIT/2, actor->scale);
}
} }
// Function: A_JetbThink // Function: A_JetbThink
@@ -4137,10 +4111,7 @@ void A_JetgShoot(void *thing)
A_FaceTarget(actor); A_FaceTarget(actor);
P_SpawnMissile(actor, actor->target, (mobjtype_t)actor->info->raisestate); P_SpawnMissile(actor, actor->target, (mobjtype_t)actor->info->raisestate);
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
if (actor->info->attacksound) if (actor->info->attacksound)
S_StartSound(actor, actor->info->attacksound); S_StartSound(actor, actor->info->attacksound);
@@ -5301,7 +5272,7 @@ void A_MixUp(void *thing)
if (playeringame[i] && players[i].mo && players[i].mo->health > 0 && players[i].playerstate == PST_LIVE if (playeringame[i] && players[i].mo && players[i].mo->health > 0 && players[i].playerstate == PST_LIVE
&& !players[i].exiting && !players[i].powers[pw_super]) && !players[i].exiting && !players[i].powers[pw_super])
{ {
if ((netgame || multiplayer) && players[i].spectator) // Ignore spectators if (netgame && players[i].spectator) // Ignore spectators
continue; continue;
numplayers++; numplayers++;
@@ -5344,6 +5315,11 @@ void A_MixUp(void *thing)
} }
} }
// idk if we ever really end up here
// but bad things would happen if we do without this
if (one == -1)
return;
//get this done first! //get this done first!
tempthing = players[one].mo->tracer; tempthing = players[one].mo->tracer;
P_SetTarget(&players[one].mo->tracer, players[two].mo->tracer); P_SetTarget(&players[one].mo->tracer, players[two].mo->tracer);
@@ -6458,12 +6434,8 @@ void A_BuzzFly(void *thing)
// chase towards player // chase towards player
{ {
INT32 dist, realspeed; INT32 dist, realspeed;
const fixed_t mf = 5*(FRACUNIT/4);
if (ultimatemode) realspeed = FixedMul(actor->info->speed, actor->scale);
realspeed = FixedMul(FixedMul(actor->info->speed,mf), actor->scale);
else
realspeed = FixedMul(actor->info->speed, actor->scale);
dist = P_AproxDistance(P_AproxDistance(actor->target->x - actor->x, dist = P_AproxDistance(P_AproxDistance(actor->target->x - actor->x,
actor->target->y - actor->y), actor->target->z - actor->z); actor->target->y - actor->y), actor->target->z - actor->z);
@@ -7918,7 +7890,7 @@ void A_ItemPop(void *thing)
if (!(actor->target && actor->target->player)) if (!(actor->target && actor->target->player))
{ {
if (cv_debug && !(actor->target && actor->target->player)) if (cv_debug)
CONS_Printf("ERROR: Powerup has no target!\n"); CONS_Printf("ERROR: Powerup has no target!\n");
return; return;
} }
@@ -8780,7 +8752,7 @@ void A_ReaperThinker(void *thing)
actor->angle = R_PointToAngle2(actor->x, actor->y, actor->target->x, actor->target->y); actor->angle = R_PointToAngle2(actor->x, actor->y, actor->target->x, actor->target->y);
// The player we should target if it's near us: // The player we should target if it's near us:
for (i = 0; i<MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{ {
if (!playeringame[i]) if (!playeringame[i])
@@ -9251,10 +9223,7 @@ void A_MultiShot(void *thing)
if (!(actor->flags & MF_BOSS)) if (!(actor->flags & MF_BOSS))
{ {
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
} }
} }
@@ -10863,10 +10832,7 @@ void A_BrakFireShot(void *thing)
if (!(actor->flags & MF_BOSS)) if (!(actor->flags & MF_BOSS))
{ {
if (ultimatemode) actor->reactiontime = actor->info->reactiontime*TICRATE*2;
actor->reactiontime = actor->info->reactiontime*TICRATE;
else
actor->reactiontime = actor->info->reactiontime*TICRATE*2;
} }
} }
+12 -8
View File
@@ -845,7 +845,7 @@ void T_BounceCheese(levelspecthink_t *bouncer)
T_MovePlane(bouncer->sector, 0, bouncer->sector->ceilingheight, 0, 1, -1); // update things on ceiling T_MovePlane(bouncer->sector, 0, bouncer->sector->ceilingheight, 0, 1, -1); // update things on ceiling
T_MovePlane(bouncer->sector, 0, bouncer->sector->floorheight, 0, 0, -1); // update things on floor T_MovePlane(bouncer->sector, 0, bouncer->sector->floorheight, 0, 0, -1); // update things on floor
bouncer->sector->ceilingdata = NULL; bouncer->sector->ceilingdata = NULL;
bouncer->sector->floordata = NULL;; bouncer->sector->floordata = NULL;
bouncer->sector->moved = true; bouncer->sector->moved = true;
P_RemoveThinker(&bouncer->thinker); // remove bouncer from actives P_RemoveThinker(&bouncer->thinker); // remove bouncer from actives
} }
@@ -1107,14 +1107,13 @@ void T_SpikeSector(levelspecthink_t *spikes)
if (affectsec == spikes->sector) // Applied to an actual sector if (affectsec == spikes->sector) // Applied to an actual sector
{ {
fixed_t affectfloor = P_GetSpecialBottomZ(thing, affectsec, affectsec);
fixed_t affectceil = P_GetSpecialTopZ(thing, affectsec, affectsec);
if (affectsec->flags & SF_FLIPSPECIAL_FLOOR) if (affectsec->flags & SF_FLIPSPECIAL_FLOOR)
{ {
if (!(thing->eflags & MFE_VERTICALFLIP) && thing->momz > 0) if (!(thing->eflags & MFE_VERTICALFLIP) && thing->momz > 0)
continue; continue;
fixed_t affectfloor = P_GetSpecialBottomZ(thing, affectsec, affectsec);
if (thing->z == affectfloor) if (thing->z == affectfloor)
dothepain = true; dothepain = true;
} }
@@ -1124,19 +1123,21 @@ void T_SpikeSector(levelspecthink_t *spikes)
if ((thing->eflags & MFE_VERTICALFLIP) && thing->momz < 0) if ((thing->eflags & MFE_VERTICALFLIP) && thing->momz < 0)
continue; continue;
fixed_t affectceil = P_GetSpecialTopZ(thing, affectsec, affectsec);
if (thing->z + thing->height == affectceil) if (thing->z + thing->height == affectceil)
dothepain = true; dothepain = true;
} }
} }
else else
{ {
fixed_t affectfloor = P_GetSpecialBottomZ(thing, affectsec, spikes->sector);
fixed_t affectceil = P_GetSpecialTopZ(thing, affectsec, spikes->sector);
if (affectsec->flags & SF_FLIPSPECIAL_FLOOR) if (affectsec->flags & SF_FLIPSPECIAL_FLOOR)
{ {
if (!(thing->eflags & MFE_VERTICALFLIP) && thing->momz > 0) if (!(thing->eflags & MFE_VERTICALFLIP) && thing->momz > 0)
continue; continue;
fixed_t affectceil = P_GetSpecialTopZ(thing, affectsec, spikes->sector);
if (thing->z == affectceil) if (thing->z == affectceil)
dothepain = true; dothepain = true;
} }
@@ -1146,6 +1147,8 @@ void T_SpikeSector(levelspecthink_t *spikes)
if ((thing->eflags & MFE_VERTICALFLIP) && thing->momz < 0) if ((thing->eflags & MFE_VERTICALFLIP) && thing->momz < 0)
continue; continue;
fixed_t affectfloor = P_GetSpecialBottomZ(thing, affectsec, spikes->sector);
if (thing->z + thing->height == affectfloor) if (thing->z + thing->height == affectfloor)
dothepain = true; dothepain = true;
} }
@@ -1652,6 +1655,7 @@ wegotit:
static mobj_t *SearchMarioNode(msecnode_t *node) static mobj_t *SearchMarioNode(msecnode_t *node)
{ {
mobj_t *thing = NULL; mobj_t *thing = NULL;
for (; node; node = node->m_thinglist_next) for (; node; node = node->m_thinglist_next)
{ {
// Things which should NEVER be ejected from a MarioBlock, by type. // Things which should NEVER be ejected from a MarioBlock, by type.
@@ -1894,7 +1898,6 @@ void T_NoEnemiesSector(levelspecthink_t *nobaddies)
{ {
if (nobaddies->sector->lines[i]->special == 223) if (nobaddies->sector->lines[i]->special == 223)
{ {
upperbound = nobaddies->sector->ceilingheight; upperbound = nobaddies->sector->ceilingheight;
lowerbound = nobaddies->sector->floorheight; lowerbound = nobaddies->sector->floorheight;
@@ -2080,11 +2083,12 @@ void T_EachTimeThinker(levelspecthink_t *eachtime)
continue; continue;
topheight = P_GetSpecialTopZ(players[j].mo, sec, targetsec); topheight = P_GetSpecialTopZ(players[j].mo, sec, targetsec);
bottomheight = P_GetSpecialBottomZ(players[j].mo, sec, targetsec);
if (players[j].mo->z > topheight) if (players[j].mo->z > topheight)
continue; continue;
bottomheight = P_GetSpecialBottomZ(players[j].mo, sec, targetsec);
if (players[j].mo->z + players[j].mo->height < bottomheight) if (players[j].mo->z + players[j].mo->height < bottomheight)
continue; continue;
+2 -22
View File
@@ -1219,24 +1219,6 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
case MT_EXTRALARGEBUBBLE: case MT_EXTRALARGEBUBBLE:
return; // SRB2kart - don't need bubbles mucking with the player return; // SRB2kart - don't need bubbles mucking with the player
if ((player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL)
return;
if (UNLIKELY(maptol & TOL_NIGHTS))
return;
if (UNLIKELY(mariomode))
return;
else if (toucher->eflags & MFE_VERTICALFLIP)
{
if (special->z+special->height < toucher->z + toucher->height / 3
|| special->z+special->height > toucher->z + (toucher->height*2/3))
return; // Only go in the mouth
}
else if (special->z < toucher->z + toucher->height / 3
|| special->z > toucher->z + (toucher->height*2/3))
return; // Only go in the mouth
toucher->momx = toucher->momy = toucher->momz = 0;
break;
case MT_WATERDROP: case MT_WATERDROP:
if (special->state == &states[special->info->spawnstate]) if (special->state == &states[special->info->spawnstate])
@@ -1642,7 +1624,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
// Drop stuff. // Drop stuff.
// This determines the kind of object spawned // This determines the kind of object spawned
// during the death frame of a thing. // during the death frame of a thing.
if (!mariomode // Don't show birds, etc. in Mario Mode Tails 12-23-2001 if (LIKELY(!mariomode) // Don't show birds, etc. in Mario Mode Tails 12-23-2001
&& target->flags & MF_ENEMY) && target->flags & MF_ENEMY)
{ {
if (cv_soniccd.value) if (cv_soniccd.value)
@@ -1877,11 +1859,9 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
P_SetThingPosition(target); P_SetThingPosition(target);
P_InstaThrust(target,target->angle,FixedMul(2*FRACUNIT, target->scale)); P_InstaThrust(target,target->angle,FixedMul(2*FRACUNIT, target->scale));
target->momz = FixedMul(7*FRACUNIT, target->scale); target->momz = FixedMul(7*FRACUNIT, target->scale);
if (flip)
target->momz = -target->momz;
if (flip) if (flip)
{ {
target->momz = -target->momz;
target = P_SpawnMobj(x,y,z-FixedMul(12*FRACUNIT, target->scale),MT_SPIKE); target = P_SpawnMobj(x,y,z-FixedMul(12*FRACUNIT, target->scale),MT_SPIKE);
target->eflags |= MFE_VERTICALFLIP; target->eflags |= MFE_VERTICALFLIP;
} }
-9
View File
@@ -99,10 +99,6 @@ typedef struct camera_s
// Hold up/down to pan the camera vertically // Hold up/down to pan the camera vertically
SINT8 dpad_y_held; SINT8 dpad_y_held;
// Things used by FS cameras.
fixed_t viewheight;
angle_t startangle;
// Camera demobjerization // Camera demobjerization
// Info for drawing: position. // Info for drawing: position.
fixed_t x, y, z; fixed_t x, y, z;
@@ -121,8 +117,6 @@ typedef struct camera_s
fixed_t radius; fixed_t radius;
fixed_t height; fixed_t height;
fixed_t relativex;
// Momentums, used to update position. // Momentums, used to update position.
fixed_t momx, momy, momz; fixed_t momx, momy, momz;
@@ -212,7 +206,6 @@ mobj_t *P_SpawnGhostMobj(mobj_t *mobj);
void P_GivePlayerRings(player_t *player, INT32 num_rings); void P_GivePlayerRings(player_t *player, INT32 num_rings);
void P_GivePlayerLives(player_t *player, INT32 numlives); void P_GivePlayerLives(player_t *player, INT32 numlives);
UINT8 P_GetNextEmerald(void); UINT8 P_GetNextEmerald(void);
void P_GiveEmerald(boolean spawnObj);
void P_ResetScore(player_t *player); void P_ResetScore(player_t *player);
boolean P_AutoPause(void); boolean P_AutoPause(void);
@@ -220,7 +213,6 @@ void P_DoJumpShield(player_t *player);
void P_BlackOw(player_t *player); void P_BlackOw(player_t *player);
void P_ElementalFireTrail(player_t *player); void P_ElementalFireTrail(player_t *player);
//void P_DoPityCheck(player_t *player);
void P_PlayerThink(player_t *player); void P_PlayerThink(player_t *player);
void P_PlayerAfterThink(player_t *player); void P_PlayerAfterThink(player_t *player);
void P_DoPlayerExit(player_t *player); void P_DoPlayerExit(player_t *player);
@@ -281,7 +273,6 @@ void P_RemoveMobj(mobj_t *th);
void P_RemoveSavegameMobj(mobj_t *th); void P_RemoveSavegameMobj(mobj_t *th);
boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state); boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state);
boolean P_SetMobjState(mobj_t *mobj, statenum_t state); boolean P_SetMobjState(mobj_t *mobj, statenum_t state);
//void P_RunShields(void);
void P_RunOverlays(void); void P_RunOverlays(void);
void P_RunShadows(void); void P_RunShadows(void);
void P_MobjThinker(mobj_t *mobj); void P_MobjThinker(mobj_t *mobj);
+45 -37
View File
@@ -189,12 +189,12 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
} }
if (vertispeed) if (vertispeed)
object->momz = FixedMul(vertispeed,FixedSqrt(FixedMul(vscale, spring->scale))); object->momz = FixedMul(vertispeed, FixedSqrt(FixedMul(vscale, spring->scale)));
if (horizspeed) if (horizspeed)
{ {
if (!object->player) if (!object->player)
P_InstaThrustEvenIn2D(object, spring->angle, FixedMul(horizspeed,FixedSqrt(FixedMul(hscale, spring->scale)))); P_InstaThrustEvenIn2D(object, spring->angle, FixedMul(horizspeed, FixedSqrt(FixedMul(hscale, spring->scale))));
else else
{ {
fixed_t finalSpeed = FixedDiv(horizspeed, hscale); fixed_t finalSpeed = FixedDiv(horizspeed, hscale);
@@ -203,7 +203,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
if (pSpeed > finalSpeed) if (pSpeed > finalSpeed)
finalSpeed = pSpeed; finalSpeed = pSpeed;
P_InstaThrustEvenIn2D(object, spring->angle, FixedMul(finalSpeed,FixedSqrt(FixedMul(hscale, spring->scale)))); P_InstaThrustEvenIn2D(object, spring->angle, FixedMul(finalSpeed, FixedSqrt(FixedMul(hscale, spring->scale))));
} }
} }
@@ -321,7 +321,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
// Ignore spectators // Ignore spectators
if ((tmthing->player && tmthing->player->spectator) if ((tmthing->player && tmthing->player->spectator)
|| (thing->player && thing->player->spectator)) || (thing->player && thing->player->spectator))
return true; return true;
#ifdef SEENAMES #ifdef SEENAMES
@@ -1509,14 +1509,14 @@ static boolean PIT_CheckThing(mobj_t *thing)
// Adjusts tmfloorz and tmceilingz as lines are contacted - FOR CAMERA ONLY // Adjusts tmfloorz and tmceilingz as lines are contacted - FOR CAMERA ONLY
static boolean PIT_CheckCameraLine(line_t *ld) static boolean PIT_CheckCameraLine(line_t *ld)
{ {
if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID)) if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
return true; return true;
if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID))
|| tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
{
return true; return true;
}
if (P_BoxOnLineSide(tmbbox, ld) != -1) if (P_BoxOnLineSide(tmbbox, ld) != -1)
return true; return true;
@@ -1571,11 +1571,13 @@ static boolean PIT_CheckCameraLine(line_t *ld)
// //
static boolean PIT_CheckLine(line_t *ld) static boolean PIT_CheckLine(line_t *ld)
{ {
if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID)) if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
return true; return true;
if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID))
|| tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
return true; return true;
if (P_BoxOnLineSide(tmbbox, ld) != -1) if (P_BoxOnLineSide(tmbbox, ld) != -1)
@@ -1584,10 +1586,12 @@ static boolean PIT_CheckLine(line_t *ld)
if (tmthing->flags & MF_PAPERCOLLISION) // Caution! Turning whilst up against a wall will get you stuck. You probably shouldn't give the player this flag. if (tmthing->flags & MF_PAPERCOLLISION) // Caution! Turning whilst up against a wall will get you stuck. You probably shouldn't give the player this flag.
{ {
fixed_t cosradius, sinradius; fixed_t cosradius, sinradius;
cosradius = FixedMul(tmthing->radius, FINECOSINE(tmthing->angle>>ANGLETOFINESHIFT)); cosradius = FixedMul(tmthing->radius, FINECOSINE(tmthing->angle>>ANGLETOFINESHIFT));
sinradius = FixedMul(tmthing->radius, FINESINE(tmthing->angle>>ANGLETOFINESHIFT)); sinradius = FixedMul(tmthing->radius, FINESINE(tmthing->angle>>ANGLETOFINESHIFT));
if (P_PointOnLineSide(tmx - cosradius, tmy - sinradius, ld) if (P_PointOnLineSide(tmx - cosradius, tmy - sinradius, ld)
== P_PointOnLineSide(tmx + cosradius, tmy + sinradius, ld)) == P_PointOnLineSide(tmx + cosradius, tmy + sinradius, ld))
return true; // the line doesn't cross between collider's start or end return true; // the line doesn't cross between collider's start or end
} }
@@ -2369,6 +2373,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
fixed_t radius = thing->radius; fixed_t radius = thing->radius;
fixed_t thingtop ;//= thing->z + thing->height; fixed_t thingtop ;//= thing->z + thing->height;
fixed_t startingonground = P_IsObjectOnGround(thing); fixed_t startingonground = P_IsObjectOnGround(thing);
INT32 special = -1;
floatok = false; floatok = false;
if (radius < MAXRADIUS/2) if (radius < MAXRADIUS/2)
@@ -2402,21 +2407,31 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
if (!(thing->flags & MF_NOCLIP)) if (!(thing->flags & MF_NOCLIP))
{ {
//All things are affected by their scale. // All things are affected by their scale.
fixed_t maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale); fixed_t maxstep;
INT32 special = 0;
if (tmceilingz - tmfloorz < thing->height)
{
if (tmfloorthing)
tmhitthing = tmfloorthing;
return false; // doesn't fit
}
maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale);
if (thing->player) if (thing->player)
{ {
special = GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1); if (special == -1)
special = GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1);
// If using type Section1:13, double the maxstep. // If using type Section1:13, double the maxstep.
if (P_PlayerTouchingSectorSpecial(thing->player, 1, 13) || special == 13) if (special == 13 || P_PlayerTouchingSectorSpecial(thing->player, 1, 13))
{ {
maxstep <<= 1; maxstep <<= 1;
} }
// If using type Section1:12, no maxstep. For ledges you don't want the player to climb! (see: Egg Zeppelin & SMK port walls) // If using type Section1:12, no maxstep. For ledges you don't want the player to climb! (see: Egg Zeppelin & SMK port walls)
else if (P_PlayerTouchingSectorSpecial(thing->player, 1, 12) || special == 12) else if (special == 12 || P_PlayerTouchingSectorSpecial(thing->player, 1, 12))
{ {
maxstep = 0; maxstep = 0;
} }
@@ -2427,14 +2442,6 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
maxstep = 0; maxstep = 0;
} }
if (tmceilingz - tmfloorz < thing->height)
{
if (tmfloorthing)
tmhitthing = tmfloorthing;
return false; // doesn't fit
}
floatok = true; floatok = true;
thingtop = thing->z + thing->height; thingtop = thing->z + thing->height;
@@ -2465,7 +2472,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
} }
} }
else if (maxstep > 0 && !(thing->player && else if (maxstep > 0 && !(thing->player &&
(P_PlayerTouchingSectorSpecial(thing->player, 1, 14) || special == 14))) // Step down (special == 14 || P_PlayerTouchingSectorSpecial(thing->player, 1, 14)))) // Step down
{ {
// If the floor difference is MAXSTEPMOVE or less, and the sector isn't Section1:14, ALWAYS // If the floor difference is MAXSTEPMOVE or less, and the sector isn't Section1:14, ALWAYS
// step down! Formerly required a Section1:13 sector for the full MAXSTEPMOVE, but no more. // step down! Formerly required a Section1:13 sector for the full MAXSTEPMOVE, but no more.
@@ -3537,6 +3544,12 @@ static boolean PIT_RadiusAttack(mobj_t *thing)
if (thing->flags & MF_MONITOR) if (thing->flags & MF_MONITOR)
return true; return true;
if (thing->floorz > bombspot->z && bombspot->ceilingz < thing->z)
return true;
if (thing->ceilingz < bombspot->z && bombspot->floorz > thing->z)
return true;
dx = abs(thing->x - bombspot->x); dx = abs(thing->x - bombspot->x);
dy = abs(thing->y - bombspot->y); dy = abs(thing->y - bombspot->y);
dz = abs(thing->z + (thing->height>>1) - bombspot->z); dz = abs(thing->z + (thing->height>>1) - bombspot->z);
@@ -3550,14 +3563,9 @@ static boolean PIT_RadiusAttack(mobj_t *thing)
if (dist >= bombdamage) if (dist >= bombdamage)
return true; // out of range return true; // out of range
if (thing->floorz > bombspot->z && bombspot->ceilingz < thing->z) // must be in direct path
return true;
if (thing->ceilingz < bombspot->z && bombspot->floorz > thing->z)
return true;
if (P_CheckSight(thing, bombspot)) if (P_CheckSight(thing, bombspot))
{ // must be in direct path {
P_DamageMobj(thing, bombspot, bombsource, 1); // Tails 01-11-2001 P_DamageMobj(thing, bombspot, bombsource, 1); // Tails 01-11-2001
} }
@@ -4001,10 +4009,10 @@ static inline boolean PIT_GetSectors(line_t *ld)
tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
return true; return true;
if (P_BoxOnLineSide(tmbbox, ld) != -1) if (ld->polyobj) // line belongs to a polyobject, don't add it
return true; return true;
if (ld->polyobj) // line belongs to a polyobject, don't add it if (P_BoxOnLineSide(tmbbox, ld) != -1)
return true; return true;
// This line crosses through the object. // This line crosses through the object.
+84 -41
View File
@@ -242,7 +242,7 @@ void P_CameraLineOpening(line_t *linedef)
sector_t *back; sector_t *back;
fixed_t frontfloor, frontceiling, backfloor, backceiling; fixed_t frontfloor, frontceiling, backfloor, backceiling;
if (linedef->sidenum[1] == 0xffff) if (linedef->sidenum[1] == NO_INDEX)
{ {
// single sided line // single sided line
openrange = 0; openrange = 0;
@@ -398,7 +398,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
{ {
sector_t *front, *back; sector_t *front, *back;
if (linedef->sidenum[1] == 0xffff) if (linedef->sidenum[1] == NO_INDEX)
{ {
// single sided line // single sided line
openrange = 0; openrange = 0;
@@ -423,40 +423,40 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
// Set open and high/low values here // Set open and high/low values here
fixed_t frontheight, backheight; fixed_t frontheight, backheight;
frontheight = P_GetCeilingZ(mobj, front, tmx, tmy, linedef);
backheight = P_GetCeilingZ(mobj, back, tmx, tmy, linedef);
if (frontheight < backheight)
{
opentop = frontheight;
highceiling = backheight;
opentopslope = front->c_slope;
}
else
{
opentop = backheight;
highceiling = frontheight;
opentopslope = back->c_slope;
}
frontheight = P_GetFloorZ(mobj, front, tmx, tmy, linedef);
backheight = P_GetFloorZ(mobj, back, tmx, tmy, linedef);
if (frontheight > backheight)
{
openbottom = frontheight;
lowfloor = backheight;
openbottomslope = front->f_slope;
}
else
{
openbottom = backheight;
lowfloor = frontheight;
openbottomslope = back->f_slope;
}
if (mobj) if (mobj)
{ {
frontheight = P_GetCeilingZ(mobj, front, tmx, tmy, linedef);
backheight = P_GetCeilingZ(mobj, back, tmx, tmy, linedef);
if (frontheight < backheight)
{
opentop = frontheight;
highceiling = backheight;
opentopslope = front->c_slope;
}
else
{
opentop = backheight;
highceiling = frontheight;
opentopslope = back->c_slope;
}
frontheight = P_GetFloorZ(mobj, front, tmx, tmy, linedef);
backheight = P_GetFloorZ(mobj, back, tmx, tmy, linedef);
if (frontheight > backheight)
{
openbottom = frontheight;
lowfloor = backheight;
openbottomslope = front->f_slope;
}
else
{
openbottom = backheight;
lowfloor = frontheight;
openbottomslope = back->f_slope;
}
fixed_t thingtop = mobj->z + mobj->height; fixed_t thingtop = mobj->z + mobj->height;
// Check for collision with front side's midtexture if Effect 4 is set // Check for collision with front side's midtexture if Effect 4 is set
@@ -650,6 +650,43 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
lowfloor = lowestfloor; lowfloor = lowestfloor;
} }
} }
else
{
// this is what P_LineOpening did before the addition of slopes
// so i´ll just use it as the fallback case
// not that we will ever likely hit this
frontheight = front->ceilingheight;
backheight = back->ceilingheight;
if (frontheight < backheight)
{
opentop = frontheight;
highceiling = backheight;
opentopslope = front->c_slope;
}
else
{
opentop = backheight;
highceiling = frontheight;
opentopslope = back->c_slope;
}
frontheight = front->floorheight;
backheight = back->floorheight;
if (frontheight > backheight)
{
openbottom = frontheight;
lowfloor = backheight;
openbottomslope = front->f_slope;
}
else
{
openbottom = backheight;
lowfloor = frontheight;
openbottomslope = back->f_slope;
}
}
openrange = opentop - openbottom; openrange = opentop - openbottom;
} }
@@ -668,7 +705,6 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
// //
void P_UnsetThingPosition(mobj_t *thing) void P_UnsetThingPosition(mobj_t *thing)
{ {
I_Assert(thing != NULL);
I_Assert(!P_MobjWasRemoved(thing)); I_Assert(!P_MobjWasRemoved(thing));
if (!(thing->flags & MF_NOSECTOR)) if (!(thing->flags & MF_NOSECTOR))
@@ -772,7 +808,6 @@ void P_SetThingPosition(mobj_t *thing)
sector_t *oldsec = NULL; sector_t *oldsec = NULL;
fixed_t tfloorz, tceilz; fixed_t tfloorz, tceilz;
I_Assert(thing != NULL);
I_Assert(!P_MobjWasRemoved(thing)); I_Assert(!P_MobjWasRemoved(thing));
if (thing->player && thing->z <= thing->floorz && thing->subsector) if (thing->player && thing->z <= thing->floorz && thing->subsector)
@@ -823,16 +858,20 @@ void P_SetThingPosition(mobj_t *thing)
// sector's floor is the same height. // sector's floor is the same height.
if (thing->player && oldsec != NULL && thing->subsector && oldsec != thing->subsector->sector) if (thing->player && oldsec != NULL && thing->subsector && oldsec != thing->subsector->sector)
{ {
tfloorz = P_GetFloorZ(thing, ss->sector, thing->x, thing->y, NULL);
tceilz = P_GetCeilingZ(thing, ss->sector, thing->x, thing->y, NULL);
if (thing->eflags & MFE_VERTICALFLIP) if (thing->eflags & MFE_VERTICALFLIP)
{ {
tceilz = P_GetCeilingZ(thing, ss->sector, thing->x, thing->y, NULL);
if (thing->z + thing->height >= tceilz) if (thing->z + thing->height >= tceilz)
thing->eflags |= MFE_JUSTSTEPPEDDOWN; thing->eflags |= MFE_JUSTSTEPPEDDOWN;
} }
else if (thing->z <= tfloorz) else
thing->eflags |= MFE_JUSTSTEPPEDDOWN; {
tfloorz = P_GetFloorZ(thing, ss->sector, thing->x, thing->y, NULL);
if (thing->z <= tfloorz)
thing->eflags |= MFE_JUSTSTEPPEDDOWN;
}
} }
} }
@@ -933,6 +972,10 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *))
// First index is really empty, so +1 it. // First index is really empty, so +1 it.
for (list = blockmaplump + offset + 1; *list != -1; list++) for (list = blockmaplump + offset + 1; *list != -1; list++)
{ {
#ifdef RANGECHECK
if (*list < 0 || (UINT32)*list >= numlines)
I_Error("P_BlockLinesIterator: index >= numlines");
#endif
ld = &lines[*list]; ld = &lines[*list];
if (ld->validcount == validcount) if (ld->validcount == validcount)
+171 -206
View File
@@ -122,27 +122,6 @@ static void P_CycleMobjState(mobj_t *mobj)
} }
} }
//
// P_CycleMobjState for players.
//
static void P_CyclePlayerMobjState(mobj_t *mobj)
{
// state animations
P_CycleStateAnimation(mobj);
// cycle through states,
// calling action functions at transitions
if (mobj->tics != -1)
{
mobj->tics--;
// you can cycle through multiple states in a tic
if (!mobj->tics && mobj->state)
if (!P_SetPlayerMobjState(mobj, mobj->state->nextstate))
return; // freed itself
}
}
#define MAX_RECURSION 20 #define MAX_RECURSION 20
// //
@@ -243,11 +222,6 @@ boolean P_SetMobjState(mobj_t *mobj, statenum_t state)
INT32 recursion = 0; INT32 recursion = 0;
#ifdef PARANOIA
if (mobj->player != NULL)
I_Error("P_SetMobjState used for player mobj. Use P_SetPlayerMobjState instead!\n(State called: %d)", state);
#endif
if (mobj->player != NULL) if (mobj->player != NULL)
return P_SetPlayerMobjState(mobj, state); return P_SetPlayerMobjState(mobj, state);
@@ -360,7 +334,6 @@ void P_ExplodeMissile(mobj_t *mo)
{ {
mobj_t *explodemo; mobj_t *explodemo;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
mo->momx = mo->momy = mo->momz = 0; mo->momx = mo->momy = mo->momz = 0;
@@ -441,14 +414,18 @@ boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover)
if (!(rover->flags & FF_EXISTS)) if (!(rover->flags & FF_EXISTS))
return false; return false;
if ((((rover->flags & FF_BLOCKPLAYER) && mobj->player) if ((((rover->flags & FF_BLOCKPLAYER) && mobj->player) ||
|| ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) ((rover->flags & FF_BLOCKOTHERS) && !mobj->player)))
return false;
topheight = P_GetFFloorTopZAt(rover, mobj->x, mobj->y);
if (mobj->z > topheight)
return false; return false;
topheight = P_GetFFloorTopZAt (rover, mobj->x, mobj->y);
bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y); bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y);
if (mobj->z > topheight || (mobj->z + mobj->height < bottomheight)) if (mobj->z + mobj->height < bottomheight)
return false; return false;
return true; return true;
@@ -598,7 +575,7 @@ fixed_t P_MobjFloorZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t
return P_GetSlopeZAt(slope, testx, testy); return P_GetSlopeZAt(slope, testx, testy);
// If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point // If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point
if (perfect) if (perfect && boundsec)
{ {
size_t i; size_t i;
line_t *ld; line_t *ld;
@@ -617,8 +594,10 @@ fixed_t P_MobjFloorZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t
fixed_t highline; fixed_t highline;
ld = boundsec->lines[i]; ld = boundsec->lines[i];
if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
|| bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || bbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
bbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
continue; continue;
if (P_BoxOnLineSide(bbox, ld) != -1) if (P_BoxOnLineSide(bbox, ld) != -1)
@@ -685,7 +664,7 @@ fixed_t P_MobjCeilingZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed
return P_GetSlopeZAt(slope, testx, testy); return P_GetSlopeZAt(slope, testx, testy);
// If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point // If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point
if (perfect) if (perfect && boundsec)
{ {
size_t i; size_t i;
line_t *ld; line_t *ld;
@@ -704,8 +683,10 @@ fixed_t P_MobjCeilingZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed
fixed_t highline; fixed_t highline;
ld = boundsec->lines[i]; ld = boundsec->lines[i];
if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
|| bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || bbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
bbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
continue; continue;
if (P_BoxOnLineSide(bbox, ld) != -1) if (P_BoxOnLineSide(bbox, ld) != -1)
@@ -773,7 +754,7 @@ fixed_t P_CameraFloorZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, fix
return P_GetSlopeZAt(slope, testx, testy); return P_GetSlopeZAt(slope, testx, testy);
// If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point // If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point
if (perfect) if (perfect && boundsec)
{ {
size_t i; size_t i;
line_t *ld; line_t *ld;
@@ -792,8 +773,10 @@ fixed_t P_CameraFloorZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, fix
fixed_t highline; fixed_t highline;
ld = boundsec->lines[i]; ld = boundsec->lines[i];
if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
|| bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || bbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
bbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
continue; continue;
if (P_BoxOnLineSide(bbox, ld) != -1) if (P_BoxOnLineSide(bbox, ld) != -1)
@@ -860,7 +843,7 @@ fixed_t P_CameraCeilingZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, f
return P_GetSlopeZAt(slope, testx, testy); return P_GetSlopeZAt(slope, testx, testy);
// If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point // If boundsec is set, we're looking for specials. In that case, iterate over every line in this sector to find the TRUE highest/lowest point
if (perfect) if (perfect && boundsec)
{ {
size_t i; size_t i;
line_t *ld; line_t *ld;
@@ -879,8 +862,10 @@ fixed_t P_CameraCeilingZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, f
fixed_t highline; fixed_t highline;
ld = boundsec->lines[i]; ld = boundsec->lines[i];
if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] if (bbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
|| bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || bbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) bbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
bbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
bbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
continue; continue;
if (P_BoxOnLineSide(bbox, ld) != -1) if (P_BoxOnLineSide(bbox, ld) != -1)
@@ -911,6 +896,7 @@ fixed_t P_CameraCeilingZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, f
else // Well, that makes it easy. Just get the ceiling height else // Well, that makes it easy. Just get the ceiling height
return sector->ceilingheight; return sector->ceilingheight;
} }
static void P_PlayerFlip(mobj_t *mo) static void P_PlayerFlip(mobj_t *mo)
{ {
if (!mo->player) if (!mo->player)
@@ -919,7 +905,12 @@ static void P_PlayerFlip(mobj_t *mo)
G_GhostAddFlip((INT32) (mo->player - players)); G_GhostAddFlip((INT32) (mo->player - players));
// Flip aiming to match! // Flip aiming to match!
if (mo->player->pflags & PF_FLIPCAM) if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
{
if (mo->tracer)
mo->tracer->eflags ^= MFE_VERTICALFLIP;
}
else if (mo->player->pflags & PF_FLIPCAM)
{ {
UINT8 i; UINT8 i;
@@ -941,11 +932,6 @@ static void P_PlayerFlip(mobj_t *mo)
camera[i].z += FixedMul(20*FRACUNIT, mo->scale); camera[i].z += FixedMul(20*FRACUNIT, mo->scale);
} }
} }
else if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
{
if (mo->tracer)
mo->tracer->eflags ^= MFE_VERTICALFLIP;
}
} }
// //
@@ -961,7 +947,6 @@ fixed_t P_GetMobjGravity(mobj_t *mo)
boolean goopgravity = false; boolean goopgravity = false;
boolean wasflip; boolean wasflip;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
wasflip = (mo->eflags & MFE_VERTICALFLIP) != 0; wasflip = (mo->eflags & MFE_VERTICALFLIP) != 0;
@@ -1134,7 +1119,6 @@ void P_CheckGravity(mobj_t *mo, boolean affect)
// //
static void P_SceneryXYFriction(mobj_t *mo, fixed_t oldx, fixed_t oldy) static void P_SceneryXYFriction(mobj_t *mo, fixed_t oldx, fixed_t oldy)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
const fixed_t fric_scale = FixedMul(FRACUNIT/32, mo->scale); const fixed_t fric_scale = FixedMul(FRACUNIT/32, mo->scale);
@@ -1178,7 +1162,6 @@ static void P_XYFriction(mobj_t *mo, fixed_t oldx, fixed_t oldy)
{ {
player_t *player; player_t *player;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
player = mo->player; player = mo->player;
@@ -1230,7 +1213,6 @@ static void P_PushableCheckBustables(mobj_t *mo)
fixed_t oldx; fixed_t oldx;
fixed_t oldy; fixed_t oldy;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
if (netgame && mo->player && mo->player->spectator) if (netgame && mo->player && mo->player->spectator)
@@ -1349,7 +1331,6 @@ void P_XYMovement(mobj_t *mo)
vector3_t slopemom = {0, 0, 0}; vector3_t slopemom = {0, 0, 0};
fixed_t predictedz = 0; fixed_t predictedz = 0;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
// if it's stopped // if it's stopped
@@ -1432,7 +1413,7 @@ void P_XYMovement(mobj_t *mo)
// blocked move // blocked move
moved = false; moved = false;
if (player && player->bot) if (UNLIKELY(player && player->bot))
{ {
B_MoveBlocked(player); B_MoveBlocked(player);
} }
@@ -1467,24 +1448,24 @@ void P_XYMovement(mobj_t *mo)
else else
fx->eflags &= ~MFE_VERTICALFLIP; fx->eflags &= ~MFE_VERTICALFLIP;
fx->scale = mo->scale; fx->scale = mo->scale;
}
if (mo->type == MT_ORBINAUT) // Orbinaut speed decreasing if (mo->type == MT_ORBINAUT) // Orbinaut speed decreasing
{
if (mo->health > 1)
{ {
S_StartSound(mo, mo->info->attacksound); if (mo->health > 1)
mo->health--; {
mo->threshold = 0; S_StartSound(mo, mo->info->attacksound);
} mo->health--;
else if (mo->health == 1) mo->threshold = 0;
{ }
// This Item Damage else if (mo->health == 1)
S_StartSound(mo, mo->info->deathsound); {
P_KillMobj(mo, NULL, NULL); // This Item Damage
S_StartSound(mo, mo->info->deathsound);
P_KillMobj(mo, NULL, NULL);
P_SetObjectMomZ(mo, 8*FRACUNIT, false); P_SetObjectMomZ(mo, 8*FRACUNIT, false);
P_InstaThrust(mo, R_PointToAngle2(mo->x, mo->y, mo->x, mo->y)+ANGLE_90, 16*FRACUNIT); P_InstaThrust(mo, R_PointToAngle2(mo->x, mo->y, mo->x, mo->y)+ANGLE_90, 16*FRACUNIT);
}
} }
} }
//} //}
@@ -1588,43 +1569,46 @@ void P_XYMovement(mobj_t *mo)
if (P_MobjWasRemoved(mo)) // MF_SPECIAL touched a player! O_o;; if (P_MobjWasRemoved(mo)) // MF_SPECIAL touched a player! O_o;;
return; return;
if (moved && oldslope) // Check to see if we ran off if (moved)
{ {
if (oldslope != mo->standingslope) // First, compare different slopes if (oldslope) // Check to see if we ran off
{ {
angle_t oldangle, newangle; if (oldslope != mo->standingslope) // First, compare different slopes
angle_t moveangle = R_PointToAngle2(0, 0, mo->momx, mo->momy); {
angle_t oldangle, newangle;
angle_t moveangle = R_PointToAngle2(0, 0, mo->momx, mo->momy);
oldangle = FixedMul((signed)oldslope->zangle, FINECOSINE((moveangle - oldslope->xydirection) >> ANGLETOFINESHIFT)); oldangle = FixedMul((signed)oldslope->zangle, FINECOSINE((moveangle - oldslope->xydirection) >> ANGLETOFINESHIFT));
if (mo->standingslope) if (mo->standingslope)
newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT)); newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT));
else else
newangle = 0; newangle = 0;
// Now compare the Zs of the different quantizations // Now compare the Zs of the different quantizations
if (oldangle-newangle > ANG30 && oldangle-newangle < ANGLE_180) // Allow for a bit of sticking - this value can be adjusted later if (oldangle-newangle > ANG30 && oldangle-newangle < ANGLE_180) // Allow for a bit of sticking - this value can be adjusted later
{
mo->standingslope = oldslope;
P_SlopeLaunch(mo);
}
}
else if (predictedz-mo->z > abs(slopemom.z/2) // Sryder 2018-11-26: Don't launch here if it's a slope without physics, we stick to those like glue anyway
&& !(mo->standingslope->flags & SL_NOPHYSICS)) // Now check if we were supposed to stick to this slope
{ {
mo->standingslope = oldslope;
P_SlopeLaunch(mo); P_SlopeLaunch(mo);
} }
} }
else if (predictedz-mo->z > abs(slopemom.z/2) // Sryder 2018-11-26: Don't launch here if it's a slope without physics, we stick to those like glue anyway else if (mo->standingslope && predictedz)
&& !(mo->standingslope->flags & SL_NOPHYSICS)) // Now check if we were supposed to stick to this slope
{ {
P_SlopeLaunch(mo); angle_t moveangle = R_PointToAngle2(0, 0, mo->momx, mo->momy);
} angle_t newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT));
}
else if (moved && mo->standingslope && predictedz)
{
angle_t moveangle = R_PointToAngle2(0, 0, mo->momx, mo->momy);
angle_t newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT));
if (ANGLE_MAX-newangle > ANG30 && newangle > ANGLE_180) if (ANGLE_MAX-newangle > ANG30 && newangle > ANGLE_180)
{ {
mo->momz = P_MobjFlip(mo)*FRACUNIT/2; mo->momz = P_MobjFlip(mo)*FRACUNIT/2;
mo->z = predictedz + P_MobjFlip(mo); mo->z = predictedz + P_MobjFlip(mo);
mo->standingslope = NULL; mo->standingslope = NULL;
}
} }
} }
@@ -1670,6 +1654,14 @@ void P_XYMovement(mobj_t *mo)
if (mo->flags & MF_NOCLIPHEIGHT) if (mo->flags & MF_NOCLIPHEIGHT)
return; // no frictions for objects that can pass through floors return; // no frictions for objects that can pass through floors
//{ SRB2kart stuff
if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
return;
if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
return;
//}
if (mo->flags & MF_MISSILE || mo->flags2 & MF2_SKULLFLY || mo->type == MT_SHELL || mo->type == MT_VULTURE) if (mo->flags & MF_MISSILE || mo->flags2 & MF2_SKULLFLY || mo->type == MT_SHELL || mo->type == MT_VULTURE)
return; // no friction for missiles ever return; // no friction for missiles ever
@@ -1683,14 +1675,6 @@ void P_XYMovement(mobj_t *mo)
&& (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8)) // Special exception for tumbleweeds on slopes && (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8)) // Special exception for tumbleweeds on slopes
return; return;
//{ SRB2kart stuff
if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
return;
if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
return;
//}
if (((!(mo->eflags & MFE_VERTICALFLIP) && mo->z > mo->floorz) || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height < mo->ceilingz)) if (((!(mo->eflags & MFE_VERTICALFLIP) && mo->z > mo->floorz) || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height < mo->ceilingz))
&& !(player && player->pflags & PF_SLIDING)) && !(player && player->pflags & PF_SLIDING))
return; // no friction when airborne return; // no friction when airborne
@@ -1700,7 +1684,6 @@ void P_XYMovement(mobj_t *mo)
static void P_RingXYMovement(mobj_t *mo) static void P_RingXYMovement(mobj_t *mo)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
if (!P_SceneryTryMove(mo, mo->x + mo->momx, mo->y + mo->momy)) if (!P_SceneryTryMove(mo, mo->x + mo->momx, mo->y + mo->momy))
@@ -1711,7 +1694,6 @@ static void P_SceneryXYMovement(mobj_t *mo)
{ {
fixed_t oldx, oldy; // reducing bobbing/momentum on ice when up against walls fixed_t oldx, oldy; // reducing bobbing/momentum on ice when up against walls
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
oldx = mo->x; oldx = mo->x;
@@ -1749,7 +1731,6 @@ static void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motyp
fixed_t delta1, delta2, thingtop; fixed_t delta1, delta2, thingtop;
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
thingtop = mo->z + mo->height; thingtop = mo->z + mo->height;
@@ -1826,7 +1807,6 @@ static void P_AdjustMobjFloorZ_PolyObjs(mobj_t *mo, subsector_t *subsec)
fixed_t delta1, delta2, thingtop; fixed_t delta1, delta2, thingtop;
fixed_t polytop, polybottom; fixed_t polytop, polybottom;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
thingtop = mo->z + mo->height; thingtop = mo->z + mo->height;
@@ -1870,7 +1850,6 @@ static void P_AdjustMobjFloorZ_PolyObjs(mobj_t *mo, subsector_t *subsec)
static void P_RingZMovement(mobj_t *mo) static void P_RingZMovement(mobj_t *mo)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
// Intercept the stupid 'fall through 3dfloors' bug // Intercept the stupid 'fall through 3dfloors' bug
@@ -1905,7 +1884,6 @@ static void P_RingZMovement(mobj_t *mo)
boolean P_CheckDeathPitCollide(mobj_t *mo) boolean P_CheckDeathPitCollide(mobj_t *mo)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
const INT32 secspecial = GETSECSPECIAL(mo->subsector->sector->special, 1); const INT32 secspecial = GETSECSPECIAL(mo->subsector->sector->special, 1);
@@ -1922,7 +1900,6 @@ boolean P_CheckDeathPitCollide(mobj_t *mo)
boolean P_CheckSolidLava(mobj_t *mo, ffloor_t *rover) boolean P_CheckSolidLava(mobj_t *mo, ffloor_t *rover)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
if (rover->flags & FF_SWIMMABLE && GETSECSPECIAL(rover->master->frontsector->special, 1) == 3 if (rover->flags & FF_SWIMMABLE && GETSECSPECIAL(rover->master->frontsector->special, 1) == 3
@@ -1941,7 +1918,6 @@ static boolean P_ZMovement(mobj_t *mo)
{ {
fixed_t dist, delta; fixed_t dist, delta;
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
// Intercept the stupid 'fall through 3dfloors' bug // Intercept the stupid 'fall through 3dfloors' bug
@@ -2398,7 +2374,6 @@ static boolean P_ZMovement(mobj_t *mo)
static void P_PlayerZMovement(mobj_t *mo) static void P_PlayerZMovement(mobj_t *mo)
{ {
I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
if (!mo->player) if (!mo->player)
@@ -2464,6 +2439,7 @@ static void P_PlayerZMovement(mobj_t *mo)
} }
goto nightsdone; goto nightsdone;
} }
// Get up if you fell. // Get up if you fell.
if ((mo->state == &states[mo->info->painstate] || mo->state == &states[S_KART_SPIN]) if ((mo->state == &states[mo->info->painstate] || mo->state == &states[S_KART_SPIN])
&& mo->player->kartstuff[k_spinouttimer] == 0 && mo->player->kartstuff[k_squishedtimer] == 0) // SRB2kart && mo->player->kartstuff[k_spinouttimer] == 0 && mo->player->kartstuff[k_squishedtimer] == 0) // SRB2kart
@@ -2516,7 +2492,7 @@ static void P_PlayerZMovement(mobj_t *mo)
polyobj_t *po = newsubsec->polyList; polyobj_t *po = newsubsec->polyList;
sector_t *polysec; sector_t *polysec;
while(po) while (po)
{ {
if (!P_MobjInsidePolyobj(po, mo) || !(po->flags & POF_SOLID)) if (!P_MobjInsidePolyobj(po, mo) || !(po->flags & POF_SOLID))
{ {
@@ -2744,6 +2720,7 @@ static boolean P_SceneryZMovement(mobj_t *mo)
P_RemoveMobj(mo); P_RemoveMobj(mo);
return false; return false;
} }
if ((!(mo->eflags & MFE_VERTICALFLIP) && mo->z <= mo->floorz) if ((!(mo->eflags & MFE_VERTICALFLIP) && mo->z <= mo->floorz)
|| (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height >= mo->ceilingz)) // Hit the floor, so split! || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height >= mo->ceilingz)) // Hit the floor, so split!
{ {
@@ -2781,6 +2758,7 @@ static boolean P_SceneryZMovement(mobj_t *mo)
P_RemoveMobj(mo); P_RemoveMobj(mo);
return false; return false;
} }
// Soniccd seed turns into a flower! // Soniccd seed turns into a flower!
if ((!(mo->eflags & MFE_VERTICALFLIP) && mo->z <= mo->floorz) if ((!(mo->eflags & MFE_VERTICALFLIP) && mo->z <= mo->floorz)
|| (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height >= mo->ceilingz)) || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height >= mo->ceilingz))
@@ -2891,22 +2869,29 @@ void P_MobjCheckWater(mobj_t *mobj)
|| ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) || ((rover->flags & FF_BLOCKOTHERS) && !mobj->player)))
continue; continue;
topheight = P_GetFFloorTopZAt(rover, mobj->x, mobj->y); fixed_t topcheck, bottomcheck;
bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y);
if (mobj->eflags & MFE_VERTICALFLIP) if (mobj->eflags & MFE_VERTICALFLIP)
{ {
if (topheight < (thingtop - FixedMul(mobj->info->height/2, mobj->scale)) topcheck = (thingtop - FixedMul(mobj->info->height/2, mobj->scale));
|| bottomheight > thingtop) bottomcheck = thingtop;
continue;
} }
else else
{ {
if (topheight < mobj->z topcheck = mobj->z;
|| bottomheight > (mobj->z + FixedMul(mobj->info->height/2, mobj->scale))) bottomcheck = (mobj->z + FixedMul(mobj->info->height/2, mobj->scale));
continue;
} }
topheight = P_GetFFloorTopZAt(rover, mobj->x, mobj->y);
if (topheight < topcheck)
continue;
bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y);
if (bottomheight > bottomcheck)
continue;
// Set the watertop and waterbottom // Set the watertop and waterbottom
mobj->watertop = topheight; mobj->watertop = topheight;
mobj->waterbottom = bottomheight; mobj->waterbottom = bottomheight;
@@ -3112,11 +3097,14 @@ static void P_SceneryCheckWater(mobj_t *mobj)
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKOTHERS) if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKOTHERS)
continue; continue;
topheight = P_GetFFloorTopZAt(rover, mobj->x, mobj->y); topheight = P_GetFFloorTopZAt(rover, mobj->x, mobj->y);
if (topheight <= mobj->z)
continue;
bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y); bottomheight = P_GetFFloorBottomZAt(rover, mobj->x, mobj->y);
if (topheight <= mobj->z if (bottomheight > (mobj->z + FixedMul(mobj->info->height >> 1, mobj->scale)))
|| bottomheight > (mobj->z + FixedMul(mobj->info->height >> 1, mobj->scale)))
continue; continue;
if (mobj->z + FixedMul(mobj->info->height, mobj->scale) > topheight) if (mobj->z + FixedMul(mobj->info->height, mobj->scale) > topheight)
@@ -3210,30 +3198,6 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
return false; return false;
} }
void P_DestroyRobots(void)
{
// Search through all the thinkers for enemies.
mobj_t *mo;
thinker_t *think;
for (think = thinkercap.next; think != &thinkercap; think = think->next)
{
if (think->function != (actionf_p1)P_MobjThinker)
continue; // not a mobj thinker
mo = (mobj_t *)think;
if (mo->health <= 0 || !(mo->flags & MF_ENEMY || mo->flags & MF_BOSS))
continue; // not a valid enemy
if (mo->type == MT_PLAYER) // Don't chase after other players!
continue;
// Found a target enemy
P_KillMobj(mo, players[consoleplayer].mo, players[consoleplayer].mo);
}
}
// the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person // the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person
void P_CalcChasePostImg(player_t *player, camera_t *thiscam) void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
{ {
@@ -3405,7 +3369,6 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
{ {
msecnode_t *node; msecnode_t *node;
I_Assert(mobj != NULL);
I_Assert(mobj->player != NULL); I_Assert(mobj->player != NULL);
I_Assert(!P_MobjWasRemoved(mobj)); I_Assert(!P_MobjWasRemoved(mobj));
@@ -3420,20 +3383,23 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
mobj->eflags &= ~MFE_JUSTSTEPPEDDOWN; mobj->eflags &= ~MFE_JUSTSTEPPEDDOWN;
// Zoom tube // Zoom tube
if (UNLIKELY(mobj->tracer && mobj->tracer->type == MT_TUBEWAYPOINT)) if (mobj->tracer)
{ {
P_UnsetThingPosition(mobj); if (mobj->tracer->type == MT_TUBEWAYPOINT)
mobj->x += mobj->momx; {
mobj->y += mobj->momy; P_UnsetThingPosition(mobj);
mobj->z += mobj->momz; mobj->x += mobj->momx;
P_SetThingPosition(mobj); mobj->y += mobj->momy;
P_CheckPosition(mobj, mobj->x, mobj->y); mobj->z += mobj->momz;
goto animonly; P_SetThingPosition(mobj);
} P_CheckPosition(mobj, mobj->x, mobj->y);
else if (UNLIKELY(mobj->player->pflags & PF_MACESPIN && mobj->tracer)) goto animonly;
{ }
P_CheckPosition(mobj, mobj->x, mobj->y); else if (UNLIKELY(mobj->player->pflags & PF_MACESPIN))
goto animonly; {
P_CheckPosition(mobj, mobj->x, mobj->y);
goto animonly;
}
} }
// Needed for gravity boots // Needed for gravity boots
@@ -3449,24 +3415,30 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
else else
P_TryMove(mobj, mobj->x, mobj->y, true); P_TryMove(mobj, mobj->x, mobj->y, true);
if (LIKELY(!(netgame && mobj->player->spectator))) if (!(netgame && mobj->player->spectator))
{ {
// Crumbling platforms // Crumbling platforms
for (node = mobj->touching_sectorlist; node; node = node->m_sectorlist_next) for (node = mobj->touching_sectorlist; node; node = node->m_sectorlist_next)
{ {
fixed_t topheight, bottomheight;
ffloor_t *rover; ffloor_t *rover;
for (rover = node->m_sector->ffloors; rover; rover = rover->next) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
boolean oncrumble;
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_CRUMBLE)) if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_CRUMBLE))
continue; continue;
topheight = P_GetSpecialTopZ(mobj, sectors + rover->secnum, node->m_sector); if (mobj->eflags & MFE_VERTICALFLIP)
bottomheight = P_GetSpecialBottomZ(mobj, sectors + rover->secnum, node->m_sector); {
oncrumble = P_GetSpecialBottomZ(mobj, sectors + rover->secnum, node->m_sector) == mobj->z + mobj->height; // You nut.
}
else
{
oncrumble = P_GetSpecialTopZ(mobj, sectors + rover->secnum, node->m_sector) == mobj->z;
}
if ((topheight == mobj->z && !(mobj->eflags & MFE_VERTICALFLIP)) if (oncrumble)
|| (bottomheight == mobj->z + mobj->height && mobj->eflags & MFE_VERTICALFLIP)) // You nut.
EV_StartCrumble(rover->master->frontsector, rover, (rover->flags & FF_FLOATBOB), mobj->player, rover->alpha, !(rover->flags & FF_NORETURN)); EV_StartCrumble(rover->master->frontsector, rover, (rover->flags & FF_FLOATBOB), mobj->player, rover->alpha, !(rover->flags & FF_NORETURN));
} }
} }
@@ -3569,11 +3541,9 @@ animonly:
static void P_CalculatePrecipFloor(precipmobj_t *mobj) static void P_CalculatePrecipFloor(precipmobj_t *mobj)
{ {
// recalculate floorz each time // recalculate floorz each time
const sector_t *sec; const sector_t *sec = (mobj && mobj->subsector) ? mobj->subsector->sector : NULL;
if (mobj && mobj->subsector && mobj->subsector->sector) if (!sec)
sec = mobj->subsector->sector;
else
return; return;
mobj->floorz = P_GetSectorFloorZAt(sec, mobj->x, mobj->y); mobj->floorz = P_GetSectorFloorZAt(sec, mobj->x, mobj->y);
@@ -3667,8 +3637,10 @@ boolean P_PrecipThinker(precipmobj_t *mobj)
return true; return true;
// only recalc this twice a second (doubt anyone will notice this lulul) // only recalc this twice a second (doubt anyone will notice this lulul)
if ((leveltime % 17) == 0) if ((leveltime % (TICRATE/2)) == 0)
{
P_CalculatePrecipFloor(mobj); P_CalculatePrecipFloor(mobj);
}
// adjust height // adjust height
if ((mobj->z += mobj->momz) <= mobj->floorz) if ((mobj->z += mobj->momz) <= mobj->floorz)
@@ -4331,7 +4303,7 @@ static void P_Boss4PopSpikeballs(mobj_t *mobj)
{ {
mobj_t *base = mobj->tracer, *seg, *next; mobj_t *base = mobj->tracer, *seg, *next;
P_SetTarget(&mobj->tracer, NULL); P_SetTarget(&mobj->tracer, NULL);
while(base) while (base)
{ {
next = base->tracer; next = base->tracer;
P_SetTarget(&base->tracer, NULL); P_SetTarget(&base->tracer, NULL);
@@ -5665,13 +5637,15 @@ void P_SetScale(mobj_t *mobj, fixed_t newscale)
void P_Attract(mobj_t *source, mobj_t *dest, boolean nightsgrab) // Home in on your target void P_Attract(mobj_t *source, mobj_t *dest, boolean nightsgrab) // Home in on your target
{ {
fixed_t dist, ndist, speedmul; fixed_t dist, ndist, speedmul;
fixed_t tx = dest->x; fixed_t tx, ty, tz;
fixed_t ty = dest->y;
fixed_t tz = dest->z + (dest->height/2); // Aim for center
if (!dest || dest->health <= 0 || !dest->player || !source->tracer) if (!dest || dest->health <= 0 || !dest->player || !source->tracer)
return; return;
tx = dest->x;
ty = dest->y;
tz = dest->z + (dest->height/2); // Aim for center
// change slope // change slope
dist = P_AproxDistance(P_AproxDistance(tx - source->x, ty - source->y), tz - source->z); dist = P_AproxDistance(P_AproxDistance(tx - source->x, ty - source->y), tz - source->z);
@@ -9050,10 +9024,9 @@ static void P_FiringThink(mobj_t *mobj)
// //
void P_MobjThinker(mobj_t *mobj) void P_MobjThinker(mobj_t *mobj)
{ {
I_Assert(mobj != NULL);
I_Assert(!P_MobjWasRemoved(mobj)); I_Assert(!P_MobjWasRemoved(mobj));
if (UNLIKELY(mobj->flags & MF_NOTHINK)) if (mobj->flags & MF_NOTHINK)
return; return;
// Remove dead target/tracer. // Remove dead target/tracer.
@@ -9154,7 +9127,6 @@ void P_MobjThinker(mobj_t *mobj)
if (mobj->fuse && !P_FuseThink(mobj)) if (mobj->fuse && !P_FuseThink(mobj))
return; return;
I_Assert(mobj != NULL);
I_Assert(!P_MobjWasRemoved(mobj)); I_Assert(!P_MobjWasRemoved(mobj));
if (mobj->momx || mobj->momy || (mobj->flags2 & MF2_SKULLFLY)) if (mobj->momx || mobj->momy || (mobj->flags2 & MF2_SKULLFLY))
@@ -9221,10 +9193,7 @@ void P_MobjThinker(mobj_t *mobj)
} }
// Can end up here if a player dies. // Can end up here if a player dies.
if (mobj->player) P_CycleMobjState(mobj);
P_CyclePlayerMobjState(mobj);
else
P_CycleMobjState(mobj);
if (P_MobjWasRemoved(mobj)) if (P_MobjWasRemoved(mobj))
return; return;
@@ -9253,7 +9222,6 @@ boolean P_RailThinker(mobj_t *mobj)
{ {
fixed_t x, y, z; fixed_t x, y, z;
I_Assert(mobj != NULL);
I_Assert(!P_MobjWasRemoved(mobj)); I_Assert(!P_MobjWasRemoved(mobj));
x = mobj->x, y = mobj->y, z = mobj->z; x = mobj->x, y = mobj->y, z = mobj->z;
@@ -9279,7 +9247,6 @@ void P_PushableThinker(mobj_t *mobj)
{ {
sector_t *sec; sector_t *sec;
I_Assert(mobj != NULL);
I_Assert(!P_MobjWasRemoved(mobj)); I_Assert(!P_MobjWasRemoved(mobj));
if (!mobj) if (!mobj)
@@ -9317,12 +9284,13 @@ void P_PushableThinker(mobj_t *mobj)
x = mobj->spawnpoint->x << FRACBITS; x = mobj->spawnpoint->x << FRACBITS;
y = mobj->spawnpoint->y << FRACBITS; y = mobj->spawnpoint->y << FRACBITS;
ss = R_PointInSubsector(x, y);
if (mobj->spawnpoint->z != 0) if (mobj->spawnpoint->z != 0)
z = mobj->spawnpoint->z << FRACBITS; z = mobj->spawnpoint->z << FRACBITS;
else else
{
ss = R_PointInSubsector(x, y);
z = ss->sector->floorheight; z = ss->sector->floorheight;
}
spawnmo = P_SpawnMobj(x, y, z, mobj->type); spawnmo = P_SpawnMobj(x, y, z, mobj->type);
if (spawnmo) if (spawnmo)
@@ -10303,7 +10271,7 @@ void P_SpawnPrecipitation(void)
if (curWeather == PRECIP_BLANK) if (curWeather == PRECIP_BLANK)
rainmo->precipflags |= PCF_INVISIBLE; rainmo->precipflags |= PCF_INVISIBLE;
floorz = rainmo->floorz >> FRACBITS; floorz = rainmo->floorz >> FRACBITS;
ceilingz = rainmo->ceilingz >> FRACBITS; ceilingz = rainmo->ceilingz >> FRACBITS;
if (floorz < ceilingz) if (floorz < ceilingz)
@@ -10370,8 +10338,6 @@ void P_PrecipitationEffects(void)
return; return;
} }
boolean sounds_rain = ((cv_drawdist_precip.value != 0) && rainsfx && (!leveltime || leveltime % 80 == 1));
// Currently thunderstorming with lightning, and we're sounding the thunder... // Currently thunderstorming with lightning, and we're sounding the thunder...
// and where there's thunder, there's gotta be lightning! // and where there's thunder, there's gotta be lightning!
if (effects_lightning && lightningStrike) if (effects_lightning && lightningStrike)
@@ -10393,6 +10359,8 @@ void P_PrecipitationEffects(void)
if (sound_disabled) if (sound_disabled)
return; // Sound off? D'aw, no fun. return; // Sound off? D'aw, no fun.
const boolean sounds_rain = ((cv_drawdist_precip.value != 0) && rainsfx && (!leveltime || leveltime % 80 == 1));
if (!sounds_rain && !sounds_thunder) if (!sounds_rain && !sounds_thunder)
return; // no need to calculate volume at ALL return; // no need to calculate volume at ALL
@@ -11061,7 +11029,11 @@ void P_SpawnMapThing(mapthing_t *mthing)
{ {
if (mthing->type > MAXPLAYERS) // be wary of playerstarts size! playerstarts[MAXPLAYERS] if (mthing->type > MAXPLAYERS) // be wary of playerstarts size! playerstarts[MAXPLAYERS]
{ {
#ifdef COMPAT_VANILLA
CONS_Alert(CONS_ERROR, "Excess player start detected %d This will crash vanilla clients!\n", mthing->type); CONS_Alert(CONS_ERROR, "Excess player start detected %d This will crash vanilla clients!\n", mthing->type);
#else
CONS_Debug(DBG_SETUP, "Excess player start detected %d\n", mthing->type);
#endif
} }
else else
{ {
@@ -11118,8 +11090,6 @@ void P_SpawnMapThing(mapthing_t *mthing)
{ {
if (!cv_powerstones.value || !G_BattleGametype()) if (!cv_powerstones.value || !G_BattleGametype())
return; return;
runemeraldmanager = true;
} }
if (!G_RaceGametype()) // No enemies in match or CTF modes if (!G_RaceGametype()) // No enemies in match or CTF modes
@@ -11211,16 +11181,7 @@ void P_SpawnMapThing(mapthing_t *mthing)
} }
} }
if (ultimatemode) if (i == MT_EMMY && (gametype != GT_COOP || tokenbits == 30 || tokenlist & (1 << tokenbits++)))
{
if (i == MT_PITYTV || i == MT_GREENTV || i == MT_YELLOWTV || i == MT_BLUETV || i == MT_BLACKTV || i == MT_WHITETV)
return; // No shields in Ultimate mode
if (i == MT_SUPERRINGBOX)
return; // No rings in Ultimate mode (except special stages)
}
if (i == MT_EMMY && (gametype != GT_COOP || ultimatemode || tokenbits == 30 || tokenlist & (1 << tokenbits++)))
return; // you already got this token, or there are too many, or the gametype's not right return; // you already got this token, or there are too many, or the gametype's not right
// Objectplace landing point // Objectplace landing point
@@ -11323,7 +11284,11 @@ void P_SpawnMapThing(mapthing_t *mthing)
if (P_MobjWasRemoved(mobj)) if (P_MobjWasRemoved(mobj))
{ {
#ifdef COMPAT_VANILLA
CONS_Alert(CONS_ERROR, "Failed to spawn map thing #%d at %d, %d. This will crash vanilla clients!\n", mthing->type, x>>FRACBITS, y>>FRACBITS); CONS_Alert(CONS_ERROR, "Failed to spawn map thing #%d at %d, %d. This will crash vanilla clients!\n", mthing->type, x>>FRACBITS, y>>FRACBITS);
#else
CONS_Debug(DBG_SETUP, "Failed to spawn map thing #%d at %d, %d.\n", mthing->type, x>>FRACBITS, y>>FRACBITS);
#endif
return; return;
} }
@@ -11892,8 +11857,6 @@ void P_SpawnHoops(mapthing_t *mthing)
x = mthing->x << FRACBITS; x = mthing->x << FRACBITS;
y = mthing->y << FRACBITS; y = mthing->y << FRACBITS;
sec = R_PointInSubsector(x, y)->sector;
// Save our flags! // Save our flags!
if (mthing->type == 1713) if (mthing->type == 1713)
z = (mthing->options >> ZSHIFT) << FRACBITS; z = (mthing->options >> ZSHIFT) << FRACBITS;
@@ -11905,6 +11868,8 @@ void P_SpawnHoops(mapthing_t *mthing)
if (P_MobjWasRemoved(hoopcenter)) if (P_MobjWasRemoved(hoopcenter))
return; return;
sec = R_PointInSubsector(x, y)->sector;
hoopcenter->spawnpoint = mthing; hoopcenter->spawnpoint = mthing;
z += P_GetSectorFloorZAt(sec, x, y); z += P_GetSectorFloorZAt(sec, x, y);
-6
View File
@@ -421,10 +421,6 @@ typedef struct mobj_s
// //
// For precipitation // For precipitation
// //
// Sometimes this is casted to a mobj_t,
// so please keep the start of the
// structure the same.
//
typedef struct precipmobj_s typedef struct precipmobj_s
{ {
// List: thinker links. // List: thinker links.
@@ -499,7 +495,6 @@ void P_SpawnPrecipitation(void);
void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter); void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter);
boolean P_BossTargetPlayer(mobj_t *actor, boolean closest); boolean P_BossTargetPlayer(mobj_t *actor, boolean closest);
boolean P_SupermanLook4Players(mobj_t *actor); boolean P_SupermanLook4Players(mobj_t *actor);
void P_DestroyRobots(void);
boolean P_PrecipThinker(precipmobj_t *mobj); boolean P_PrecipThinker(precipmobj_t *mobj);
void P_NullPrecipThinker(precipmobj_t *mobj); void P_NullPrecipThinker(precipmobj_t *mobj);
void P_FreePrecipMobj(precipmobj_t *mobj); void P_FreePrecipMobj(precipmobj_t *mobj);
@@ -510,7 +505,6 @@ void P_EmeraldManager(void);
#define MAXHUNTEMERALDS 64 #define MAXHUNTEMERALDS 64
extern mapthing_t *huntemeralds[MAXHUNTEMERALDS]; extern mapthing_t *huntemeralds[MAXHUNTEMERALDS];
extern INT32 numhuntemeralds; extern INT32 numhuntemeralds;
extern boolean runemeraldmanager;
extern INT32 numstarposts; extern INT32 numstarposts;
#ifdef __cplusplus #ifdef __cplusplus
+9 -8
View File
@@ -691,7 +691,7 @@ static void ArchiveLines(savebuffer_t *save)
if (spawnli->special == 321 || spawnli->special == 322) // only reason li->callcount would be non-zero is if either of these are involved if (spawnli->special == 321 || spawnli->special == 322) // only reason li->callcount would be non-zero is if either of these are involved
diff |= LD_CLLCOUNT; diff |= LD_CLLCOUNT;
if (li->sidenum[0] != 0xffff) if (li->sidenum[0] != NO_INDEX)
{ {
si = &sides[li->sidenum[0]]; si = &sides[li->sidenum[0]];
spawnsi = &spawnsides[li->sidenum[0]]; spawnsi = &spawnsides[li->sidenum[0]];
@@ -706,7 +706,8 @@ static void ArchiveLines(savebuffer_t *save)
if (si->midtexture != spawnsi->midtexture) if (si->midtexture != spawnsi->midtexture)
diff |= LD_S1MIDTEX; diff |= LD_S1MIDTEX;
} }
if (li->sidenum[1] != 0xffff)
if (li->sidenum[1] != NO_INDEX)
{ {
si = &sides[li->sidenum[1]]; si = &sides[li->sidenum[1]];
spawnsi = &spawnsides[li->sidenum[1]]; spawnsi = &spawnsides[li->sidenum[1]];
@@ -786,6 +787,7 @@ static void UnArchiveFFloors(savebuffer_t *save, const sector_t *ss)
I_Error("Sector does not have any ffloors!"); I_Error("Sector does not have any ffloors!");
fflr_i = READUINT16(save->p); // get first modified ffloor's number ready fflr_i = READUINT16(save->p); // get first modified ffloor's number ready
for (;;) // for some reason the usual for (rover = x; ...) thing doesn't work here? for (;;) // for some reason the usual for (rover = x; ...) thing doesn't work here?
{ {
if (fflr_i == 0xffff) // end of modified ffloors list, let's stop already if (fflr_i == 0xffff) // end of modified ffloors list, let's stop already
@@ -3308,8 +3310,6 @@ FUNCINLINE static ATTRINLINE void P_ArchiveMisc(savebuffer_t *save)
else else
WRITEINT16(save->p, gamemap); WRITEINT16(save->p, gamemap);
lastmapsaved = gamemap;
WRITEUINT16(save->p, (botskin ? (emeralds|(1<<10)) : emeralds)+357); WRITEUINT16(save->p, (botskin ? (emeralds|(1<<10)) : emeralds)+357);
WRITESTRINGN(save->p, timeattackfolder, sizeof(timeattackfolder)); WRITESTRINGN(save->p, timeattackfolder, sizeof(timeattackfolder));
} }
@@ -3333,8 +3333,6 @@ FUNCINLINE static ATTRINLINE void P_UnArchiveSPGame(savebuffer_t *save, INT16 ma
if (!mapheaderinfo[gamemap-1]) if (!mapheaderinfo[gamemap-1])
P_AllocMapHeader(gamemap-1); P_AllocMapHeader(gamemap-1);
lastmapsaved = gamemap;
tokenlist = 0; tokenlist = 0;
token = 0; token = 0;
@@ -3514,7 +3512,7 @@ static void P_ReloadSaveLevelData(void)
li->firsttag = spawnli->firsttag; li->firsttag = spawnli->firsttag;
li->nexttag = spawnli->nexttag; li->nexttag = spawnli->nexttag;
if (li->sidenum[0] != 0xffff) if (li->sidenum[0] != NO_INDEX)
{ {
si = &sides[li->sidenum[0]]; si = &sides[li->sidenum[0]];
spawnsi = &spawnsides[li->sidenum[0]]; spawnsi = &spawnsides[li->sidenum[0]];
@@ -3525,7 +3523,7 @@ static void P_ReloadSaveLevelData(void)
si->midtexture = spawnsi->midtexture; si->midtexture = spawnsi->midtexture;
} }
if (li->sidenum[1] != 0xffff) if (li->sidenum[1] != NO_INDEX)
{ {
si = &sides[li->sidenum[1]]; si = &sides[li->sidenum[1]];
spawnsi = &spawnsides[li->sidenum[1]]; spawnsi = &spawnsides[li->sidenum[1]];
@@ -3592,8 +3590,11 @@ FUNCINLINE static ATTRINLINE boolean P_NetUnArchiveMisc(savebuffer_t *save, bool
if (!P_SetupLevel(true, reloading)) if (!P_SetupLevel(true, reloading))
{ {
CONS_Alert(CONS_ERROR, M_GetText("Can't load the level!\n")); CONS_Alert(CONS_ERROR, M_GetText("Can't load the level!\n"));
P_FreeCorruptMapWarnings();
return false; return false;
} }
P_PrintCorruptMapWarnings();
} }
else else
{ {
+310 -143
View File
@@ -188,6 +188,57 @@ FUNCNORETURN static ATTRNORETURN void CorruptMapError(const char *msg)
I_Error("Invalid or corrupt map.\nLook in log file or text console for technical details."); I_Error("Invalid or corrupt map.\nLook in log file or text console for technical details.");
} }
static char **mapwarnings = NULL;
static size_t nummapwarnings = 0;
// collect map errors we can fix clientside
// we then can print em when the map finishes loading
// so they actually appear and raise awareness shits fucked
// see G_DoLoadLevel as to why :chaosleep:
static void CorruptMapWarning(const char *msg)
{
#ifdef PARANOIA
// just error out
I_Error("%sThis WILL crash Vanilla clients!\n", msg);
#endif
nummapwarnings++;
mapwarnings = Z_Realloc(mapwarnings, nummapwarnings * sizeof(*mapwarnings), PU_STATIC, NULL);
mapwarnings[nummapwarnings-1] = Z_StrDup(msg);
}
void P_PrintCorruptMapWarnings(void)
{
size_t i;
if (!nummapwarnings)
return;
for (i = 0; i < nummapwarnings; i++)
{
CONS_Alert(CONS_ERROR, "%sAttempting to fix... This WILL crash Vanilla clients!\n", mapwarnings[i]);
}
P_FreeCorruptMapWarnings();
}
void P_FreeCorruptMapWarnings(void)
{
size_t i;
if (!nummapwarnings)
return;
for (i = 0; i < nummapwarnings; i++)
{
Z_Free(mapwarnings[i]);
mapwarnings[i] = NULL;
}
Z_Free(mapwarnings);
mapwarnings = NULL;
nummapwarnings = 0;
}
#define NUMLAPS_DEFAULT 3 #define NUMLAPS_DEFAULT 3
static void P_ClearMapHeaderLighting(mapheader_lighting_t *lighting) static void P_ClearMapHeaderLighting(mapheader_lighting_t *lighting)
@@ -218,8 +269,6 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
mapheaderinfo[num]->musname[6] = 0; mapheaderinfo[num]->musname[6] = 0;
mapheaderinfo[num]->mustrack = 0; mapheaderinfo[num]->mustrack = 0;
mapheaderinfo[num]->muspos = 0; mapheaderinfo[num]->muspos = 0;
mapheaderinfo[num]->musinterfadeout = 0;
mapheaderinfo[num]->musintername[0] = '\0';
mapheaderinfo[num]->forcecharacter[0] = '\0'; mapheaderinfo[num]->forcecharacter[0] = '\0';
mapheaderinfo[num]->weather = 0; mapheaderinfo[num]->weather = 0;
mapheaderinfo[num]->skynum = 1; mapheaderinfo[num]->skynum = 1;
@@ -237,16 +286,10 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
mapheaderinfo[num]->numlaps = NUMLAPS_DEFAULT; mapheaderinfo[num]->numlaps = NUMLAPS_DEFAULT;
mapheaderinfo[num]->unlockrequired = -1; mapheaderinfo[num]->unlockrequired = -1;
mapheaderinfo[num]->levelselect = 0; mapheaderinfo[num]->levelselect = 0;
mapheaderinfo[num]->bonustype = 0;
mapheaderinfo[num]->saveoverride = SAVE_DEFAULT;
mapheaderinfo[num]->levelflags = 0; mapheaderinfo[num]->levelflags = 0;
mapheaderinfo[num]->menuflags = (mainwads ? 0 : LF2_EXISTSHACK); // see p_setup.c - prevents replacing maps in addons with easier versions mapheaderinfo[num]->menuflags = (mainwads ? 0 : LF2_EXISTSHACK); // see p_setup.c - prevents replacing maps in addons with easier versions
// TODO grades support for delfile (pfft yeah right)
P_DeleteGrades(num);
// SRB2Kart // SRB2Kart
//mapheaderinfo[num]->automap = false;
mapheaderinfo[num]->mobj_scale = FRACUNIT; mapheaderinfo[num]->mobj_scale = FRACUNIT;
mapheaderinfo[num]->customopts = NULL; mapheaderinfo[num]->customopts = NULL;
@@ -266,107 +309,11 @@ void P_AllocMapHeader(INT16 i)
if (!mapheaderinfo[i]) if (!mapheaderinfo[i])
{ {
mapheaderinfo[i] = Z_Malloc(sizeof(mapheader_t), PU_STATIC, NULL); mapheaderinfo[i] = Z_Malloc(sizeof(mapheader_t), PU_STATIC, NULL);
mapheaderinfo[i]->grades = NULL;
} }
P_ClearSingleMapHeaderInfo(i + 1); P_ClearSingleMapHeaderInfo(i + 1);
} }
/** NiGHTS Grades are a special structure,
* we initialize them here.
*
* \param i Index of header to allocate grades for
* \param mare The mare we're adding grades for
* \param grades the string from DeHackEd, we work with it ourselves
*/
void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext)
{
INT32 g;
char *spos = gtext;
CONS_Debug(DBG_SETUP, "Map %d Mare %d: ", i+1, (UINT16)mare+1);
if (mapheaderinfo[i]->numGradedMares < mare+1)
{
mapheaderinfo[i]->numGradedMares = mare+1;
mapheaderinfo[i]->grades = Z_Realloc(mapheaderinfo[i]->grades, sizeof(nightsgrades_t) * mapheaderinfo[i]->numGradedMares, PU_STATIC, NULL);
}
for (g = 0; g < 6; ++g)
{
// Allow "partial" grading systems
if (spos != NULL)
{
mapheaderinfo[i]->grades[mare].grade[g] = atoi(spos);
CONS_Debug(DBG_SETUP, "%u ", atoi(spos));
// Grab next comma
spos = strchr(spos, ',');
if (spos)
++spos;
}
else
{
// Grade not reachable
mapheaderinfo[i]->grades[mare].grade[g] = UINT32_MAX;
}
}
CONS_Debug(DBG_SETUP, "\n");
}
/** And this removes the grades safely.
*
* \param i The header to remove grades from
*/
void P_DeleteGrades(INT16 i)
{
Z_Free(mapheaderinfo[i]->grades);
mapheaderinfo[i]->grades = NULL;
mapheaderinfo[i]->numGradedMares = 0;
}
/** And this fetches the grades
*
* \param pscore The player's score.
* \param map The game map.
* \param mare The mare to test.
*/
UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare)
{
INT32 i;
// Determining the grade
if (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades && mapheaderinfo[map-1]->numGradedMares >= mare + 1)
{
INT32 pgrade = 0;
for (i = 0; i < 6; ++i)
{
if (pscore >= mapheaderinfo[map-1]->grades[mare].grade[i])
++pgrade;
}
return (UINT8)pgrade;
}
return 0;
}
UINT8 P_HasGrades(INT16 map, UINT8 mare)
{
// Determining the grade
// Mare 0 is treated as overall and is true if ANY grades exist
return (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades
&& (mare == 0 || mapheaderinfo[map-1]->numGradedMares >= mare));
}
UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade)
{
// Get the score for the grade... if it exists
if (grade == GRADE_F || grade > GRADE_S || !P_HasGrades(map, mare)) return 0;
return mapheaderinfo[map-1]->grades[mare].grade[grade-1];
}
// Loads the vertexes for a level. // Loads the vertexes for a level.
FUNCINLINE static ATTRINLINE void P_LoadVertices(UINT8 *data) FUNCINLINE static ATTRINLINE void P_LoadVertices(UINT8 *data)
{ {
@@ -541,8 +488,39 @@ static void P_LoadSegs(UINT8 *data)
for (i = 0; i < numsegs; i++, li++, ml++) for (i = 0; i < numsegs; i++, li++, ml++)
{ {
li->v1 = &vertexes[SHORT(ml->v1)]; INT16 v1, v2;
li->v2 = &vertexes[SHORT(ml->v2)];
v1 = SHORT(ml->v1);
v2 = SHORT(ml->v2);
// e6y
// check and fix wrong references to non-existent vertexes
// see e1m9 @ NIVELES.WAD
// http://www.doomworld.com/idgames/index.php?id=12647
if ((unsigned)v1 >= numvertexes || (unsigned)v2 >= numvertexes)
{
if ((unsigned)v1 >= numvertexes)
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v1));
if ((unsigned)v2 >= numvertexes)
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v2));
if (li->sidedef == &sides[li->linedef->sidenum[0]])
{
li->v1 = lines[ml->linedef].v1;
li->v2 = lines[ml->linedef].v2;
}
else
{
li->v1 = lines[ml->linedef].v2;
li->v2 = lines[ml->linedef].v1;
}
}
else
{
li->v1 = &vertexes[v1];
li->v2 = &vertexes[v2];
}
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
{ {
@@ -559,14 +537,59 @@ static void P_LoadSegs(UINT8 *data)
li->angle = (SHORT(ml->angle))<<FRACBITS; li->angle = (SHORT(ml->angle))<<FRACBITS;
li->offset = (SHORT(ml->offset))<<FRACBITS; li->offset = (SHORT(ml->offset))<<FRACBITS;
rawlinedef = SHORT(ml->linedef); rawlinedef = SHORT(ml->linedef);
//e6y: check for wrong indexes
if ((unsigned)rawlinedef >= numlines)
{
I_Error("P_LoadSegs: seg %s references a non-existent linedef %d", sizeu1(i), (unsigned)rawlinedef);
}
ldef = &lines[rawlinedef]; ldef = &lines[rawlinedef];
li->linedef = ldef; li->linedef = ldef;
li->side = rawside = SHORT(ml->side); rawside = SHORT(ml->side);
//e6y: fix wrong side index
if (rawside != 0 && rawside != 1)
{
CorruptMapWarning(va("P_LoadSegs: seg %s contains wrong side index %d.\n", sizeu1(i), rawside));
rawside = 1;
}
//e6y: check for wrong indexes
if (ldef->sidenum[rawside] >= numsides)
{
I_Error("P_LoadSegs: linedef %d for seg %s references a non-existent sidedef %d", rawlinedef, sizeu1(i), ldef->sidenum[rawside]);
}
li->side = rawside;
li->sidedef = &sides[ldef->sidenum[rawside]]; li->sidedef = &sides[ldef->sidenum[rawside]];
li->frontsector = sides[ldef->sidenum[rawside]].sector;
/* cph 2006/09/30 - our frontsector can be the second side of the
* linedef, so must check for NO_INDEX in case we are incorrectly
* referencing the back of a 1S line */
if (ldef->sidenum[rawside] == NO_INDEX)
{
CorruptMapWarning(va("P_LoadSegs: front of seg %s has no sidedef\n", sizeu1(i)));
li->frontsector = NULL;
}
else
{
li->frontsector = sides[ldef->sidenum[rawside]].sector;
}
if (ldef->flags & ML_TWOSIDED) if (ldef->flags & ML_TWOSIDED)
li->backsector = sides[ldef->sidenum[rawside^1]].sector; {
if (ldef->sidenum[rawside^1] == NO_INDEX)
{
CorruptMapWarning(va("P_LoadSegs: back of seg %s has no sidedef while being marked as double sided\n", sizeu1(i)));
li->backsector = NULL;
}
else
{
li->backsector = sides[ldef->sidenum[rawside^1]].sector;
}
}
P_UpdateSegLightOffset(li); P_UpdateSegLightOffset(li);
} }
@@ -842,7 +865,33 @@ static void P_LoadNodes(UINT8 *data)
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
{ {
no->children[j] = SHORT(mn->children[j]); UINT16 child;
child = SHORT(mn->children[j]);
if (child & NF_SUBSECTOR)
{
// Convert to extended type
child &= ~NF_SUBSECTOR;
// haleyjd 11/06/10: check for invalid subsector reference
if (child >= numsubsectors)
{
CorruptMapWarning(va("P_LoadNodes: BSP tree %s references invalid subsector %d\n", sizeu1(i), child));
child = 0;
}
child |= NF_SUBSECTOR;
}
else if (child >= numnodes)
{
CorruptMapWarning(va("P_LoadNodes: BSP node %s references invalid node.\n", sizeu1(i)));
//I_Error("P_LoadNodes: BSP node %d references invalid node %d.\n", sizeu1(i), Index(((node_t *)no->children[j])));
child = 0;
}
no->children[j] = child;
for (k = 0; k < 4; k++) for (k = 0; k < 4; k++)
no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS; no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
} }
@@ -1105,9 +1154,9 @@ static void P_InitializeLinedef(line_t *ld)
// cph 2002/07/20 - these errors are fatal if not fixed, so apply them // cph 2002/07/20 - these errors are fatal if not fixed, so apply them
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
{ {
if (ld->sidenum[j] != 0xffff && ld->sidenum[j] >= (UINT16)numsides) if (ld->sidenum[j] != NO_INDEX && ld->sidenum[j] >= (UINT16)numsides)
{ {
ld->sidenum[j] = 0xffff; ld->sidenum[j] = NO_INDEX;
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has out-of-range sidedef number\n", sizeu1((size_t)(ld - lines))); CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has out-of-range sidedef number\n", sizeu1((size_t)(ld - lines)));
} }
} }
@@ -1115,23 +1164,23 @@ static void P_InitializeLinedef(line_t *ld)
ld->firsttag = ld->nexttag = -1; ld->firsttag = ld->nexttag = -1;
// killough 11/98: fix common wad errors (missing sidedefs): // killough 11/98: fix common wad errors (missing sidedefs):
if (ld->sidenum[0] == 0xffff) if (ld->sidenum[0] == NO_INDEX)
{ {
ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side
// cph - print a warning about the bug // cph - print a warning about the bug
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s missing first sidedef\n", sizeu1((size_t)(ld - lines))); CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s missing first sidedef\n", sizeu1((size_t)(ld - lines)));
} }
if ((ld->sidenum[1] == 0xffff) && (ld->flags & ML_TWOSIDED)) if ((ld->sidenum[1] == NO_INDEX) && (ld->flags & ML_TWOSIDED))
{ {
ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side
// cph - print a warning about the bug // cph - print a warning about the bug
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has two-sided flag set, but no second sidedef\n", sizeu1((size_t)(ld - lines))); CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has two-sided flag set, but no second sidedef\n", sizeu1((size_t)(ld - lines)));
} }
if (ld->sidenum[0] != 0xffff && ld->special) if (ld->sidenum[0] != NO_INDEX && ld->special)
sides[ld->sidenum[0]].special = ld->special; sides[ld->sidenum[0]].special = ld->special;
if (ld->sidenum[1] != 0xffff && ld->special) if (ld->sidenum[1] != NO_INDEX && ld->special)
sides[ld->sidenum[1]].special = ld->special; sides[ld->sidenum[1]].special = ld->special;
} }
@@ -1164,10 +1213,10 @@ static void P_LoadLineDefs2(void)
for (; i--; ld++) for (; i--; ld++)
{ {
ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : NULL; ld->backsector = ld->sidenum[1] != NO_INDEX ? sides[ld->sidenum[1]].sector : NULL;
// Repeat count for midtexture // Repeat count for midtexture
if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff)) if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != NO_INDEX))
{ {
sides[ld->sidenum[0]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) >> 12); sides[ld->sidenum[0]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) >> 12);
sides[ld->sidenum[0]].textureoffset = (((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) & 2047) << FRACBITS; sides[ld->sidenum[0]].textureoffset = (((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
@@ -1183,13 +1232,13 @@ static void P_LoadLineDefs2(void)
{ {
size_t len = strlen(sides[ld->sidenum[0]].text)+1; size_t len = strlen(sides[ld->sidenum[0]].text)+1;
if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text) if (ld->sidenum[1] != NO_INDEX && sides[ld->sidenum[1]].text)
len += strlen(sides[ld->sidenum[1]].text); len += strlen(sides[ld->sidenum[1]].text);
ld->text = Z_Malloc(len, PU_LEVEL, NULL); ld->text = Z_Malloc(len, PU_LEVEL, NULL);
memcpy(ld->text, sides[ld->sidenum[0]].text, strlen(sides[ld->sidenum[0]].text)+1); memcpy(ld->text, sides[ld->sidenum[0]].text, strlen(sides[ld->sidenum[0]].text)+1);
if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text) if (ld->sidenum[1] != NO_INDEX && sides[ld->sidenum[1]].text)
memcpy(ld->text+strlen(ld->text)+1, sides[ld->sidenum[1]].text, strlen(sides[ld->sidenum[1]].text)+1); memcpy(ld->text+strlen(ld->text)+1, sides[ld->sidenum[1]].text, strlen(sides[ld->sidenum[1]].text)+1);
} }
break; break;
@@ -1319,14 +1368,14 @@ static void P_LoadSideChangeMusic(boolean firstside, mapsidedef_t *msd, side_t *
if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0') if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0')
{ {
memcpy(process,msd->bottomtexture,8); memcpy(process, msd->bottomtexture, 8);
process[8] = '\0'; process[8] = '\0';
sd->bottomtexture = get_number(process); sd->bottomtexture = get_number(process);
} }
if (!(msd->midtexture[0] == '-' && msd->midtexture[1] == '\0') || msd->midtexture[1] != '\0') if (!(msd->midtexture[0] == '-' && msd->midtexture[1] == '\0') || msd->midtexture[1] != '\0')
{ {
memcpy(process,msd->midtexture,8); memcpy(process, msd->midtexture, 8);
process[8] = '\0'; process[8] = '\0';
sd->midtexture = get_number(process); sd->midtexture = get_number(process);
} }
@@ -1336,7 +1385,7 @@ static void P_LoadSideChangeMusic(boolean firstside, mapsidedef_t *msd, side_t *
if (firstside || msd->toptexture[0] != '-' || msd->toptexture[1] != '\0') if (firstside || msd->toptexture[0] != '-' || msd->toptexture[1] != '\0')
{ {
memcpy(process,msd->toptexture,8); memcpy(process, msd->toptexture, 8);
process[8] = '\0'; process[8] = '\0';
// If they type in O_ or D_ and their music name, just shrug, // If they type in O_ or D_ and their music name, just shrug,
@@ -1376,7 +1425,7 @@ static void P_LoadSidedefs(void *data)
// Colormaps! // Colormaps!
switch (sd->special) switch (sd->special)
{ {
case 63: // variable colormap via 242 linedef case 63: // variable colormap via 242 linedef
case 606: //SoM: 4/4/2000: Just colormap transfer case 606: //SoM: 4/4/2000: Just colormap transfer
// SoM: R_CreateColormap will only create a colormap in software mode... // SoM: R_CreateColormap will only create a colormap in software mode...
// Perhaps we should just call it instead of doing the calculations here. // Perhaps we should just call it instead of doing the calculations here.
@@ -1392,26 +1441,26 @@ static void P_LoadSidedefs(void *data)
if (msd->toptexture[0] != '-' || msd->toptexture[1] != '\0') if (msd->toptexture[0] != '-' || msd->toptexture[1] != '\0')
{ {
char process[8+1]; char process[8+1];
memcpy(process,msd->toptexture,8); memcpy(process, msd->toptexture, 8);
process[8] = '\0'; process[8] = '\0';
sd->toptexture = get_number(process); sd->toptexture = get_number(process);
} }
break; break;
} }
case 9: // Mace parameters case 9: // Mace parameters
case 14: // Bustable block parameters case 14: // Bustable block parameters
case 15: // Fan particle spawner parameters case 15: // Fan particle spawner parameters
case 425: // Calls P_SetMobjState on calling mobj case 425: // Calls P_SetMobjState on calling mobj
case 434: // Custom Power case 434: // Custom Power
case 442: // Calls P_SetMobjState on mobjs of a given type in the tagged sectors case 442: // Calls P_SetMobjState on mobjs of a given type in the tagged sectors
{ {
char process[8*3+1]; char process[8*3+1];
memset(process,0,8*3+1); memset(process, 0, 8*3+1);
sd->toptexture = sd->midtexture = sd->bottomtexture = 0; sd->toptexture = sd->midtexture = sd->bottomtexture = 0;
if (msd->toptexture[0] == '-' && msd->toptexture[1] == '\0') if (msd->toptexture[0] == '-' && msd->toptexture[1] == '\0')
break; break;
else else
memcpy(process,msd->toptexture,8); memcpy(process, msd->toptexture, 8);
if (msd->midtexture[0] != '-' || msd->midtexture[1] != '\0') if (msd->midtexture[0] != '-' || msd->midtexture[1] != '\0')
memcpy(process+strlen(process), msd->midtexture, 8); memcpy(process+strlen(process), msd->midtexture, 8);
if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0') if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0')
@@ -1423,12 +1472,12 @@ static void P_LoadSidedefs(void *data)
case 443: // Calls a named Lua function case 443: // Calls a named Lua function
{ {
char process[8*3+1]; char process[8*3+1];
memset(process,0,8*3+1); memset(process, 0, 8*3+1);
sd->toptexture = sd->midtexture = sd->bottomtexture = 0; sd->toptexture = sd->midtexture = sd->bottomtexture = 0;
if (msd->toptexture[0] == '-' && msd->toptexture[1] == '\0') if (msd->toptexture[0] == '-' && msd->toptexture[1] == '\0')
break; break;
else else
memcpy(process,msd->toptexture,8); memcpy(process,msd->toptexture, 8);
if (msd->midtexture[0] != '-' || msd->midtexture[1] != '\0') if (msd->midtexture[0] != '-' || msd->midtexture[1] != '\0')
memcpy(process+strlen(process), msd->midtexture, 8); memcpy(process+strlen(process), msd->midtexture, 8);
if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0') if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0')
@@ -1729,6 +1778,80 @@ static void P_CreateBlockMap(void)
} }
} }
//
// P_VerifyBlockMap
//
// haleyjd 03/04/10: do verification on validity of blockmap.
//
static boolean P_VerifyBlockMap(INT32 count)
{
// FIXME: should any of this shit be unsinged?
INT32 x, y;
INT32 *maxoffs = blockmaplump + count;
//skipblstart = true;
for (y = 0; y < bmapheight; y++)
{
for (x = 0; x < bmapwidth; x++)
{
INT32 offset;
INT32 *list, *tmplist;
INT32 *blockoffset;
offset = y * bmapwidth + x;
blockoffset = blockmaplump + offset + 4;
// check that block offset is in bounds
if (blockoffset >= maxoffs)
{
CONS_Alert(CONS_ERROR, "P_VerifyBlockMap: block offset overflow\n");
return false;
}
offset = *blockoffset;
// check that list offset is in bounds
if (offset < 4 || offset >= count)
{
CONS_Alert(CONS_ERROR, "P_VerifyBlockMap: list offset overflow\n");
return false;
}
list = blockmaplump + offset;
//if (*list != 0)
//skipblstart = false;
// scan forward for a -1 terminator before maxoffs
for (tmplist = list; ; tmplist++)
{
// we have overflowed the lump?
if (tmplist >= maxoffs)
{
CONS_Alert(CONS_ERROR, "P_VerifyBlockMap: open blocklist\n");
return false;
}
if (*tmplist == -1) // found -1
break;
}
// scan the list for out-of-range linedef indicies in list
for (tmplist = list; *tmplist != -1; tmplist++)
{
if (*tmplist < 0 || *tmplist >= (INT32)numlines)
{
CONS_Alert(CONS_ERROR, "P_VerifyBlockMap: index >= numlines\n");
return false;
}
}
}
}
return true;
}
// Split from P_LoadBlockMap for convenience // Split from P_LoadBlockMap for convenience
// -- Monster Iestyn 08/01/18 // -- Monster Iestyn 08/01/18
static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count) static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count)
@@ -1770,9 +1893,20 @@ static boolean P_LoadRawBlockMap(UINT8 *data, size_t count)
bmaporgx = blockmaplump[0]<<FRACBITS; bmaporgx = blockmaplump[0]<<FRACBITS;
bmaporgy = blockmaplump[1]<<FRACBITS; bmaporgy = blockmaplump[1]<<FRACBITS;
bmapwidth = blockmaplump[2]; bmapwidth = blockmaplump[2];
bmapheight = blockmaplump[3]; bmapheight = blockmaplump[3];
// haleyjd 03/04/10: check for blockmap problems
// http://www.doomworld.com/idgames/index.php?id=12935
if (!P_VerifyBlockMap(count))
{
CorruptMapWarning(va("P_LoadBlockMap: corrupted or invalid BLOCKMAP lump! Check the log for more information.\n"));
// vanilla WILL crash here anyways so just rebuild it ourselves
Z_Free(blockmaplump);
blockmaplump = NULL;
return false;
}
// clear out mobj chains // clear out mobj chains
count = sizeof (*blocklinks)* bmapwidth*bmapheight; count = sizeof (*blocklinks)* bmapwidth*bmapheight;
blocklinks = Z_Calloc(count, PU_LEVEL, NULL); blocklinks = Z_Calloc(count, PU_LEVEL, NULL);
@@ -1807,22 +1941,35 @@ static void P_GroupLines(void)
for (i = 0; i < numsubsectors; i++, ss++) for (i = 0; i < numsubsectors; i++, ss++)
{ {
if (ss->firstline >= numsegs) if (ss->firstline >= numsegs)
{
CorruptMapError(va("P_GroupLines: ss->firstline invalid " CorruptMapError(va("P_GroupLines: ss->firstline invalid "
"(subsector %s, firstline refers to %d of %s)", sizeu1(i), ss->firstline, "(subsector %s, firstline refers to %d of %s)", sizeu1(i), ss->firstline,
sizeu2(numsegs))); sizeu2(numsegs)));
}
seg = &segs[ss->firstline]; seg = &segs[ss->firstline];
sidei = (size_t)(seg->sidedef - sides); sidei = (size_t)(seg->sidedef - sides);
if (!seg->sidedef) if (!seg->sidedef)
{
CorruptMapError(va("P_GroupLines: seg->sidedef is NULL " CorruptMapError(va("P_GroupLines: seg->sidedef is NULL "
"(subsector %s, firstline is %d)", sizeu1(i), ss->firstline)); "(subsector %s, firstline is %d)", sizeu1(i), ss->firstline));
}
if (seg->sidedef - sides < 0 || seg->sidedef - sides > (UINT16)numsides) if (seg->sidedef - sides < 0 || seg->sidedef - sides > (UINT16)numsides)
{
CorruptMapError(va("P_GroupLines: seg->sidedef refers to sidedef %s of %s " CorruptMapError(va("P_GroupLines: seg->sidedef refers to sidedef %s of %s "
"(subsector %s, firstline is %d)", sizeu1(sidei), sizeu2(numsides), "(subsector %s, firstline is %d)", sizeu1(sidei), sizeu2(numsides),
sizeu3(i), ss->firstline)); sizeu3(i), ss->firstline));
}
if (!seg->sidedef->sector) if (!seg->sidedef->sector)
{
CorruptMapError(va("P_GroupLines: seg->sidedef->sector is NULL " CorruptMapError(va("P_GroupLines: seg->sidedef->sector is NULL "
"(subsector %s, firstline is %d, sidedef is %s)", sizeu1(i), ss->firstline, "(subsector %s, firstline is %d, sidedef is %s)", sizeu1(i), ss->firstline,
sizeu1(sidei))); sizeu1(sidei)));
}
ss->sector = seg->sidedef->sector; ss->sector = seg->sidedef->sector;
} }
@@ -1884,20 +2031,36 @@ static void P_GroupLines(void)
} }
} }
// PK3 version // PK3 version
// -- Monster Iestyn 09/01/18 // -- Monster Iestyn 09/01/18
static void P_LoadReject(UINT8 *data, size_t count) static void P_LoadReject(UINT8 *data, size_t rejectsize)
{ {
if (!count) // zero length, someone probably used ZDBSP const size_t neededsize = (numsectors * numsectors + 7) >> 3;
size_t allocsize = rejectsize;
if (!rejectsize) // zero length, someone probably used ZDBSP
{ {
rejectmatrix = NULL; rejectmatrix = NULL;
CONS_Debug(DBG_SETUP, "P_LoadReject: REJECT lump has size 0, will not be loaded\n"); CONS_Debug(DBG_SETUP, "P_LoadReject: REJECT lump has size 0, will not be loaded\n");
} }
else else
{ {
rejectmatrix = Z_Malloc(count, PU_LEVEL, NULL); // allocate memory for the reject matrix if (rejectsize < neededsize)
memcpy(rejectmatrix, data, count); // copy the data into it {
CorruptMapWarning(va("P_LoadReject: REJECT is %s byte%s too small. REJECT might be invalid!\n", sizeu1(neededsize - rejectsize), (neededsize - rejectsize) == 1 ? "" : "s"));
#ifdef COMPAT_VANILLA
// we can pad this and somewhat prevent desyncs
// probs not cool if the reject is from a completely different map
// but whatever
allocsize = neededsize;
#else
rejectmatrix = NULL;
return;
#endif
}
rejectmatrix = Z_Calloc(allocsize, PU_LEVEL, NULL); // allocate memory for the reject matrix
memcpy(rejectmatrix, data, rejectsize); // copy the data into it
} }
} }
@@ -1935,9 +2098,13 @@ static void P_LoadMapLUT(const virtres_t* virt)
// Lookup tables // Lookup tables
if (virtreject) if (virtreject)
{
P_LoadReject(virtreject->data, virtreject->size); P_LoadReject(virtreject->data, virtreject->size);
}
else else
{
rejectmatrix = NULL; rejectmatrix = NULL;
}
if (!(virtblockmap && P_LoadRawBlockMap(virtblockmap->data, virtblockmap->size))) if (!(virtblockmap && P_LoadRawBlockMap(virtblockmap->data, virtblockmap->size)))
P_CreateBlockMap(); P_CreateBlockMap();
@@ -2047,7 +2214,6 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
// special stage tokens, emeralds, and ring total // special stage tokens, emeralds, and ring total
tokenbits = 0; tokenbits = 0;
runemeraldmanager = false;
nummaprings = nummapboxes = numgotboxes = 0; nummaprings = nummapboxes = numgotboxes = 0;
// emerald hunt // emerald hunt
@@ -2691,7 +2857,8 @@ void P_FreeLevelState(void)
} }
// Clear pointers that would be left dangling by the purge // Clear pointers that would be left dangling by the purge
R_FlushTranslationColormapCache(); // Pointers are now PU_STATIC so they won't be freed :)
//R_FlushTranslationColormapCache();
#ifdef HWRENDER #ifdef HWRENDER
// Free GPU textures before freeing patches. // Free GPU textures before freeing patches.
@@ -3031,7 +3198,7 @@ static size_t sreplaces = 0, mreplaces = 0, digmreplaces = 0;
static boolean P_CheckSoundReplacements(UINT16 wadnum, char *name, size_t i) static boolean P_CheckSoundReplacements(UINT16 wadnum, char *name, size_t i)
{ {
size_t j; size_t j;
lumpnum_t lumpnum = (i|(wadnum<<16)); lumpnum_t lumpnum = (i | (wadnum<<16));
if (name[0] == 'D') if (name[0] == 'D')
{ {
@@ -3039,8 +3206,8 @@ static boolean P_CheckSoundReplacements(UINT16 wadnum, char *name, size_t i)
{ {
for (j = 1; j < NUMSFX; j++) for (j = 1; j < NUMSFX; j++)
{ {
if (S_sfx[j].name && !strnicmp(S_sfx[j].name, name + 2, 6) if ((S_sfx[j].lumpnum != lumpnum) && (S_sfx[j].lumpnum != LUMPERROR) &&
&& (S_sfx[j].lumpnum != lumpnum) && (S_sfx[j].lumpnum != LUMPERROR)) S_sfx[j].name && !strnicmp(S_sfx[j].name, name + 2, 6))
{ {
// the sound will be reloaded when needed, // the sound will be reloaded when needed,
// since sfx->data will be NULL // since sfx->data will be NULL
+2 -6
View File
@@ -114,12 +114,8 @@ size_t P_PrecacheLevelFlats(void);
void P_AllocMapHeader(INT16 i); void P_AllocMapHeader(INT16 i);
// Needed for NiGHTS void P_PrintCorruptMapWarnings(void);
void P_DeleteGrades(INT16 i); void P_FreeCorruptMapWarnings(void);
void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext);
UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare);
UINT8 P_HasGrades(INT16 map, UINT8 mare);
UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
+40 -22
View File
@@ -31,8 +31,6 @@ typedef struct {
fixed_t bbox[4]; fixed_t bbox[4];
} los_t; } los_t;
static INT32 sightcounts[2];
typedef INT32 (*divlinefunc)(fixed_t x, fixed_t y, const divline_t *node); typedef INT32 (*divlinefunc)(fixed_t x, fixed_t y, const divline_t *node);
typedef INT32 (*divlinecrossfunc)(fixed_t x1, fixed_t y1, fixed_t x2, fixed_t y2, const divline_t *node); typedef INT32 (*divlinecrossfunc)(fixed_t x1, fixed_t y1, fixed_t x2, fixed_t y2, const divline_t *node);
@@ -73,7 +71,7 @@ static inline INT32 P_DivlineCrossedFast(fixed_t x1, fixed_t y1, fixed_t x2, fix
return (P_DivlineSideFast(x1, y1, node) == P_DivlineSideFast(x2, y2, node)); return (P_DivlineSideFast(x1, y1, node) == P_DivlineSideFast(x2, y2, node));
} }
static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los) static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los, boolean fast)
{ {
size_t i; size_t i;
sector_t *polysec; sector_t *polysec;
@@ -81,6 +79,8 @@ static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los)
if (!(po->flags & POF_RENDERALL)) if (!(po->flags & POF_RENDERALL))
return true; // the polyobject isn't visible, so we can ignore it return true; // the polyobject isn't visible, so we can ignore it
const divlinecrossfunc divlinecrossFunc = fast ? P_DivlineCrossedFast : P_DivlineCrossed;
polysec = po->lines[0]->backsector; polysec = po->lines[0]->backsector;
for (i = 0; i < po->numLines; ++i) for (i = 0; i < po->numLines; ++i)
@@ -108,21 +108,21 @@ static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los)
v2 = line->v2; v2 = line->v2;
// line isn't crossed? // line isn't crossed?
if (P_DivlineCrossed(v1->x, v1->y, v2->x, v2->y, &los->strace)) if (divlinecrossFunc(v1->x, v1->y, v2->x, v2->y, &los->strace))
continue; continue;
divl.dx = v2->x - (divl.x = v1->x); divl.dx = v2->x - (divl.x = v1->x);
divl.dy = v2->y - (divl.y = v1->y); divl.dy = v2->y - (divl.y = v1->y);
// line isn't crossed? // line isn't crossed?
if (P_DivlineCrossed(los->strace.x, los->strace.y, los->t2x, los->t2y, &divl)) if (divlinecrossFunc(los->strace.x, los->strace.y, los->t2x, los->t2y, &divl))
continue; continue;
frac = P_InterceptVector(&los->strace, &divl); frac = P_InterceptVector(&los->strace, &divl);
// get slopes of top and bottom of this polyobject line // get slopes of top and bottom of this polyobject line
topslope = FixedDiv(polysec->ceilingheight - los->sightzstart , frac); topslope = FixedDiv(polysec->ceilingheight - los->sightzstart, frac);
bottomslope = FixedDiv(polysec->floorheight - los->sightzstart , frac); bottomslope = FixedDiv(polysec->floorheight - los->sightzstart, frac);
if (topslope >= los->topslope && bottomslope <= los->bottomslope) if (topslope >= los->topslope && bottomslope <= los->bottomslope)
return false; // view completely blocked return false; // view completely blocked
@@ -147,6 +147,8 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
I_Error("P_CrossSubsector: ss %s with numss = %s\n", sizeu1(num), sizeu2(numsubsectors)); I_Error("P_CrossSubsector: ss %s with numss = %s\n", sizeu1(num), sizeu2(numsubsectors));
#endif #endif
const divlinecrossfunc divlinecrossFunc = fast ? P_DivlineCrossedFast : P_DivlineCrossed;
// haleyjd 02/23/06: this assignment should be after the above check // haleyjd 02/23/06: this assignment should be after the above check
seg = segs + subsectors[num].firstline; seg = segs + subsectors[num].firstline;
@@ -158,15 +160,13 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
if (po->validcount != validcount) if (po->validcount != validcount)
{ {
po->validcount = validcount; po->validcount = validcount;
if (!P_CrossSubsecPolyObj(po, los)) if (!P_CrossSubsecPolyObj(po, los, fast))
return false; return false;
} }
po = (polyobj_t *)(po->link.next); po = (polyobj_t *)(po->link.next);
} }
} }
const divlinecrossfunc divlinecrossFunc = fast ? P_DivlineCrossedFast : P_DivlineCrossed;
for (count = subsectors[num].numlines; --count >= 0; seg++) // check lines for (count = subsectors[num].numlines; --count >= 0; seg++) // check lines
{ {
line_t *line = seg->linedef; line_t *line = seg->linedef;
@@ -214,14 +214,17 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
front = seg->frontsector; front = seg->frontsector;
back = seg->backsector; back = seg->backsector;
// calculate position at intercept // calculate position at intercept
fracx = los->strace.x + FixedMul(los->strace.dx, frac); fracx = los->strace.x + FixedMul(los->strace.dx, frac);
fracy = los->strace.y + FixedMul(los->strace.dy, frac); fracy = los->strace.y + FixedMul(los->strace.dy, frac);
// calculate sector heights // calculate sector heights
frontf = P_GetSectorFloorZAt (front, fracx, fracy); frontf = P_GetSectorFloorZAt (front, fracx, fracy);
frontc = P_GetSectorCeilingZAt(front, fracx, fracy); frontc = P_GetSectorCeilingZAt(front, fracx, fracy);
backf = P_GetSectorFloorZAt (back , fracx, fracy); backf = P_GetSectorFloorZAt (back , fracx, fracy);
backc = P_GetSectorCeilingZAt(back , fracx, fracy); backc = P_GetSectorCeilingZAt(back , fracx, fracy);
// crosses a two sided line // crosses a two sided line
// no wall to block sight with? // no wall to block sight with?
if (frontf == backf && frontc == backc if (frontf == backf && frontc == backc
@@ -262,6 +265,7 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
ffloor_t *rover; ffloor_t *rover;
fixed_t topslope, bottomslope; fixed_t topslope, bottomslope;
fixed_t topz, bottomz; fixed_t topz, bottomz;
// check front sector's FOFs first // check front sector's FOFs first
for (rover = front->ffloors; rover; rover = rover->next) for (rover = front->ffloors; rover; rover = rover->next)
{ {
@@ -275,9 +279,11 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
bottomz = P_GetFFloorBottomZAt(rover, fracx, fracy); bottomz = P_GetFFloorBottomZAt(rover, fracx, fracy);
topslope = FixedDiv( topz - los->sightzstart, frac); topslope = FixedDiv( topz - los->sightzstart, frac);
bottomslope = FixedDiv(bottomz - los->sightzstart, frac); bottomslope = FixedDiv(bottomz - los->sightzstart, frac);
if (topslope >= los->topslope && bottomslope <= los->bottomslope) if (topslope >= los->topslope && bottomslope <= los->bottomslope)
return false; // view completely blocked return false; // view completely blocked
} }
// check back sector's FOFs as well // check back sector's FOFs as well
for (rover = back->ffloors; rover; rover = rover->next) for (rover = back->ffloors; rover; rover = rover->next)
{ {
@@ -291,6 +297,7 @@ static boolean P_CrossSubsector(size_t num, register los_t *los, boolean fast)
bottomz = P_GetFFloorBottomZAt(rover, fracx, fracy); bottomz = P_GetFFloorBottomZAt(rover, fracx, fracy);
topslope = FixedDiv( topz - los->sightzstart, frac); topslope = FixedDiv( topz - los->sightzstart, frac);
bottomslope = FixedDiv(bottomz - los->sightzstart, frac); bottomslope = FixedDiv(bottomz - los->sightzstart, frac);
if (topslope >= los->topslope && bottomslope <= los->bottomslope) if (topslope >= los->topslope && bottomslope <= los->bottomslope)
return false; // view completely blocked return false; // view completely blocked
} }
@@ -315,10 +322,10 @@ static boolean P_CrossBSPNode(INT32 bspnum, register los_t *los, boolean fast)
while (!(bspnum & NF_SUBSECTOR)) while (!(bspnum & NF_SUBSECTOR))
{ {
register node_t *bsp = nodes + bspnum; register const node_t *bsp = nodes + bspnum;
INT32 side = divlineFunc(los->strace.x, los->strace.y, (divline_t *)bsp) & 1; INT32 side = divlineFunc(los->strace.x, los->strace.y, (const divline_t *)bsp) & 1;
INT32 side2 = divlineFunc(los->t2x, los->t2y, (divline_t *) bsp); INT32 side2 = divlineFunc(los->t2x, los->t2y, (const divline_t *)bsp);
if (side == side2) if (side == side2)
{ {
@@ -357,8 +364,10 @@ boolean P_CheckSight2(mobj_t *t1, mobj_t *t2, boolean fast)
I_Assert(!P_MobjWasRemoved(t2)); I_Assert(!P_MobjWasRemoved(t2));
if (!t1->subsector || !t2->subsector if (!t1->subsector || !t2->subsector
|| !t1->subsector->sector || !t2->subsector->sector) || !t1->subsector->sector || !t2->subsector->sector)
{
return false; return false;
}
s1 = t1->subsector->sector; s1 = t1->subsector->sector;
s2 = t2->subsector->sector; s2 = t2->subsector->sector;
@@ -368,7 +377,9 @@ boolean P_CheckSight2(mobj_t *t1, mobj_t *t2, boolean fast)
{ {
// Check in REJECT table. // Check in REJECT table.
if (rejectmatrix[pnum>>3] & (1 << (pnum&7))) // can't possibly be connected if (rejectmatrix[pnum>>3] & (1 << (pnum&7))) // can't possibly be connected
{
return false; return false;
}
} }
// killough 11/98: shortcut for melee situations // killough 11/98: shortcut for melee situations
@@ -376,11 +387,9 @@ boolean P_CheckSight2(mobj_t *t1, mobj_t *t2, boolean fast)
// haleyjd 02/23/06: can't do this if there are polyobjects in the subsec // haleyjd 02/23/06: can't do this if there are polyobjects in the subsec
if (!t1->subsector->polyList && if (!t1->subsector->polyList &&
t1->subsector == t2->subsector) t1->subsector == t2->subsector)
{
return true; return true;
}
// An unobstructed LOS is possible.
// Now look from eyes of t1 to any part of t2.
sightcounts[1]++;
validcount++; validcount++;
@@ -423,21 +432,30 @@ boolean P_CheckSight2(mobj_t *t1, mobj_t *t2, boolean fast)
continue; continue;
} }
topz1 = P_GetFFloorTopZAt (rover, t1->x, t1->y); // Check for blocking floors here.
topz2 = P_GetFFloorTopZAt (rover, t2->x, t2->y); topz2 = P_GetFFloorTopZAt (rover, t2->x, t2->y);
bottomz1 = P_GetFFloorBottomZAt(rover, t1->x, t1->y); bottomz1 = P_GetFFloorBottomZAt(rover, t1->x, t1->y);
if (los.sightzstart < bottomz1 && t2->z >= topz2)
{
// no way to see through that
return false;
}
topz1 = P_GetFFloorTopZAt (rover, t1->x, t1->y);
bottomz2 = P_GetFFloorBottomZAt(rover, t2->x, t2->y); bottomz2 = P_GetFFloorBottomZAt(rover, t2->x, t2->y);
// Check for blocking floors here. if (los.sightzstart >= topz1 && t2->z + t2->height < bottomz2)
if ((los.sightzstart < bottomz1 && t2->z >= topz2)
|| (los.sightzstart >= topz1 && t2->z + t2->height < bottomz2))
{ {
// no way to see through that // no way to see through that
return false; return false;
} }
if (rover->flags & FF_SOLID) if (rover->flags & FF_SOLID)
{
continue; // shortcut since neither mobj can be inside the 3dfloor continue; // shortcut since neither mobj can be inside the 3dfloor
}
if (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES)) if (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))
{ {
+6 -3
View File
@@ -76,8 +76,8 @@ static void P_UpdateSlopeLightOffset(pslope_t *slope)
*/ */
light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT)) light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
+ FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT)); + FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
light = (light + FRACUNIT) / 2; light = (light + FRACUNIT) / 2;
} }
else else
{ {
@@ -166,7 +166,8 @@ static void P_ReconfigureVertexSlope(pslope_t *slope)
slope->real_xydirection = R_PointToAngle2(0, 0, slope->d.x, slope->d.y)+ANGLE_180; slope->real_xydirection = R_PointToAngle2(0, 0, slope->d.x, slope->d.y)+ANGLE_180;
slope->real_zangle = InvAngle(R_PointToAngle2(0, 0, FRACUNIT, slope->zdelta)); slope->real_zangle = InvAngle(R_PointToAngle2(0, 0, FRACUNIT, slope->zdelta));
if (slope->normal.x == 0 && slope->normal.y == 0) // Set some defaults for a non-sloped "slope" // Set some defaults for a non-sloped "slope"
if (slope->normal.x == 0 && slope->normal.y == 0)
{ {
slope->zangle = slope->xydirection = 0; slope->zangle = slope->xydirection = 0;
slope->zdelta = slope->d.x = slope->d.y = 0; slope->zdelta = slope->d.x = slope->d.y = 0;
@@ -663,8 +664,10 @@ static pslope_t *P_NewVertexSlope(INT16 tag1, INT16 tag2, INT16 tag3, UINT8 flag
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
{ {
mt = ret->vertices[i]; mt = ret->vertices[i];
if (!mt) // If a vertex wasn't found, it's game over. There's nothing you can do to recover (except maybe try and kill the slope instead - TODO?) if (!mt) // If a vertex wasn't found, it's game over. There's nothing you can do to recover (except maybe try and kill the slope instead - TODO?)
I_Error("P_NewVertexSlope: Slope vertex %s (for linedef tag %d) not found!", sizeu1(i), tag1); I_Error("P_NewVertexSlope: Slope vertex %s (for linedef tag %d) not found!", sizeu1(i), tag1);
if (mt->extrainfo) if (mt->extrainfo)
mt->z = mt->options; mt->z = mt->options;
else else
+222 -126
View File
@@ -881,7 +881,7 @@ static boolean PolyDoor(line_t *line)
pdd.polyObjNum = line->tag; // polyobject id pdd.polyObjNum = line->tag; // polyobject id
switch(line->special) switch (line->special)
{ {
case 480: // Polyobj_DoorSlide case 480: // Polyobj_DoorSlide
pdd.doorType = POLY_DOOR_SLIDE; pdd.doorType = POLY_DOOR_SLIDE;
@@ -889,7 +889,7 @@ static boolean PolyDoor(line_t *line)
pdd.angle = line->angle; // angle of motion pdd.angle = line->angle; // angle of motion
pdd.distance = sides[line->sidenum[0]].rowoffset; pdd.distance = sides[line->sidenum[0]].rowoffset;
if (line->sidenum[1] != 0xffff) if (line->sidenum[1] != NO_INDEX)
pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics
else else
pdd.delay = 0; pdd.delay = 0;
@@ -899,7 +899,7 @@ static boolean PolyDoor(line_t *line)
pdd.speed = sides[line->sidenum[0]].textureoffset >> FRACBITS; // angular speed pdd.speed = sides[line->sidenum[0]].textureoffset >> FRACBITS; // angular speed
pdd.distance = sides[line->sidenum[0]].rowoffset >> FRACBITS; // angular distance pdd.distance = sides[line->sidenum[0]].rowoffset >> FRACBITS; // angular distance
if (line->sidenum[1] != 0xffff) if (line->sidenum[1] != NO_INDEX)
pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics
else else
pdd.delay = 0; pdd.delay = 0;
@@ -1234,7 +1234,6 @@ static void P_AddExecutorDelay(line_t *line, mobj_t *mobj, sector_t *sector)
boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller) boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller)
{ {
sector_t *ctlsector; sector_t *ctlsector;
fixed_t dist = P_AproxDistance(triggerline->dx, triggerline->dy)>>FRACBITS;
size_t i, linecnt, sectori; size_t i, linecnt, sectori;
INT16 specialtype = triggerline->special; INT16 specialtype = triggerline->special;
//fromlapexec = false; //fromlapexec = false;
@@ -1272,6 +1271,8 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
rings = actor->health-1; rings = actor->health-1;
} }
const fixed_t dist = P_AproxDistance(triggerline->dx, triggerline->dy)>>FRACBITS;
if (triggerline->flags & ML_NOCLIMB) if (triggerline->flags & ML_NOCLIMB)
{ {
if (rings > dist) if (rings > dist)
@@ -1293,7 +1294,6 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
msecnode_t *node; msecnode_t *node;
mobj_t *mo; mobj_t *mo;
INT32 numpush = 0; INT32 numpush = 0;
INT32 numneeded = dist;
if (!caller) if (!caller)
return false; // we need a calling sector to find pushables in, silly! return false; // we need a calling sector to find pushables in, silly!
@@ -1308,6 +1308,8 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
node = node->m_thinglist_next; node = node->m_thinglist_next;
} }
const fixed_t numneeded = P_AproxDistance(triggerline->dx, triggerline->dy)>>FRACBITS;
if (triggerline->flags & ML_NOCLIMB) // Need at least or more if (triggerline->flags & ML_NOCLIMB) // Need at least or more
{ {
if (numpush < numneeded) if (numpush < numneeded)
@@ -1336,6 +1338,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
else if (secspecial == 7) // SRB2Kart: reusing for Race Lap executor else if (secspecial == 7) // SRB2Kart: reusing for Race Lap executor
{ {
UINT8 lap; UINT8 lap;
INT32 targlap;
if (actor && actor->player && triggerline->flags & ML_EFFECT4) if (actor && actor->player && triggerline->flags & ML_EFFECT4)
{ {
@@ -1346,19 +1349,21 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
lap = P_FindLowestLap(); lap = P_FindLowestLap();
} }
targlap = (INT32)(sides[triggerline->sidenum[0]].textureoffset >> FRACBITS);
if (triggerline->flags & ML_NOCLIMB) // Need higher than or equal to if (triggerline->flags & ML_NOCLIMB) // Need higher than or equal to
{ {
if (lap < (sides[triggerline->sidenum[0]].textureoffset >> FRACBITS)) if (lap < targlap)
return false; return false;
} }
else if (triggerline->flags & ML_BLOCKMONSTERS) // Need lower than or equal to else if (triggerline->flags & ML_BLOCKMONSTERS) // Need lower than or equal to
{ {
if (lap > (sides[triggerline->sidenum[0]].textureoffset >> FRACBITS)) if (lap > targlap)
return false; return false;
} }
else // Need equal to else // Need equal to
{ {
if (lap != (sides[triggerline->sidenum[0]].textureoffset >> FRACBITS)) if (lap != targlap)
return false; return false;
} }
@@ -1450,6 +1455,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
if (triggerline->flags & ML_EFFECT5) // disregard order for efficiency if (triggerline->flags & ML_EFFECT5) // disregard order for efficiency
{ {
for (i = 0; i < linecnt; i++) for (i = 0; i < linecnt; i++)
{
if (ctlsector->lines[i]->special >= 400 if (ctlsector->lines[i]->special >= 400
&& ctlsector->lines[i]->special < 500) && ctlsector->lines[i]->special < 500)
{ {
@@ -1458,6 +1464,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
else else
P_ProcessLineSpecial(ctlsector->lines[i], actor, caller); P_ProcessLineSpecial(ctlsector->lines[i], actor, caller);
} }
}
} }
else // walk around the sector in a defined order else // walk around the sector in a defined order
{ {
@@ -1465,11 +1472,13 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
size_t j, masterlineindex = (size_t)-1; size_t j, masterlineindex = (size_t)-1;
for (i = 0; i < linecnt; i++) for (i = 0; i < linecnt; i++)
{
if (ctlsector->lines[i] == triggerline) if (ctlsector->lines[i] == triggerline)
{ {
masterlineindex = i; masterlineindex = i;
break; break;
} }
}
#ifdef PARANOIA #ifdef PARANOIA
if (masterlineindex == (size_t)-1) if (masterlineindex == (size_t)-1)
@@ -1488,11 +1497,13 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
{ {
if (i == j) if (i == j)
continue; continue;
if (ctlsector->lines[i]->v1 == ctlsector->lines[j]->v2) if (ctlsector->lines[i]->v1 == ctlsector->lines[j]->v2)
{ {
i = j; i = j;
break; break;
} }
if (ctlsector->lines[i]->v1 == ctlsector->lines[j]->v1) if (ctlsector->lines[i]->v1 == ctlsector->lines[j]->v1)
{ {
i = j; i = j;
@@ -1500,6 +1511,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
break; break;
} }
} }
if (j == linecnt) if (j == linecnt)
{ {
const size_t vertexei = (size_t)(ctlsector->lines[i]->v1 - vertexes); const size_t vertexei = (size_t)(ctlsector->lines[i]->v1 - vertexes);
@@ -1514,11 +1526,13 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
{ {
if (i == j) if (i == j)
continue; continue;
if (ctlsector->lines[i]->v2 == ctlsector->lines[j]->v1) if (ctlsector->lines[i]->v2 == ctlsector->lines[j]->v1)
{ {
i = j; i = j;
break; break;
} }
if (ctlsector->lines[i]->v2 == ctlsector->lines[j]->v2) if (ctlsector->lines[i]->v2 == ctlsector->lines[j]->v2)
{ {
i = j; i = j;
@@ -1595,19 +1609,21 @@ void P_LinedefExecute(INT16 tag, mobj_t *actor, sector_t *caller)
if (lines[masterline].tag != tag) if (lines[masterline].tag != tag)
continue; continue;
const INT16 specialtype = lines[masterline].special;
// "No More Enemies" and "Level Load" take care of themselves. // "No More Enemies" and "Level Load" take care of themselves.
if (lines[masterline].special == 313 if (specialtype == 313
|| lines[masterline].special == 399 || specialtype == 399
|| lines[masterline].special == 328 || specialtype == 328
|| lines[masterline].special == 323 || specialtype == 323
// Each-time executors handle themselves, too // Each-time executors handle themselves, too
|| lines[masterline].special == 301 // Each time || specialtype == 301 // Each time
|| lines[masterline].special == 306 // Character ability - Each time || specialtype == 306 // Character ability - Each time
|| lines[masterline].special == 310 // CTF Red team - Each time || specialtype == 310 // CTF Red team - Each time
|| lines[masterline].special == 312 // CTF Blue team - Each time || specialtype == 312 // CTF Blue team - Each time
|| lines[masterline].special == 322 // Trigger on X calls - Each Time || specialtype == 322 // Trigger on X calls - Each Time
|| lines[masterline].special < 300 || specialtype < 300
|| lines[masterline].special > 399) || specialtype > 399)
continue; continue;
if (!P_RunTriggerLinedef(&lines[masterline], actor, caller)) if (!P_RunTriggerLinedef(&lines[masterline], actor, caller))
@@ -1973,8 +1989,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
INT32 position = (INT32)max(sides[line->sidenum[0]].midtexture, 0); INT32 position = (INT32)max(sides[line->sidenum[0]].midtexture, 0);
UINT32 prefadems = (UINT32)max(sides[line->sidenum[0]].textureoffset >> FRACBITS, 0); UINT32 prefadems = (UINT32)max(sides[line->sidenum[0]].textureoffset >> FRACBITS, 0);
UINT32 postfadems = (UINT32)max(sides[line->sidenum[0]].rowoffset >> FRACBITS, 0); UINT32 postfadems = (UINT32)max(sides[line->sidenum[0]].rowoffset >> FRACBITS, 0);
UINT8 fadetarget = (UINT8)max((line->sidenum[1] != 0xffff) ? sides[line->sidenum[1]].textureoffset >> FRACBITS : 0, 0); UINT8 fadetarget = (UINT8)max((line->sidenum[1] != NO_INDEX) ? sides[line->sidenum[1]].textureoffset >> FRACBITS : 0, 0);
INT16 fadesource = (INT16)max((line->sidenum[1] != 0xffff) ? sides[line->sidenum[1]].rowoffset >> FRACBITS : -1, -1); INT16 fadesource = (INT16)max((line->sidenum[1] != NO_INDEX) ? sides[line->sidenum[1]].rowoffset >> FRACBITS : -1, -1);
// Seek offset from current song position // Seek offset from current song position
if (line->flags & ML_EFFECT1) if (line->flags & ML_EFFECT1)
@@ -2419,7 +2435,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
P_SetPlayerMobjState(mo, S_KART_STND1); // SRB2kart - was S_PLAY_STND P_SetPlayerMobjState(mo, S_KART_STND1); // SRB2kart - was S_PLAY_STND
// Reset bot too. // Reset bot too.
if (bot) { if (bot)
{
if (line->flags & ML_NOCLIMB) if (line->flags & ML_NOCLIMB)
P_SetOrigin(bot, mo->x, mo->y, mo->z); P_SetOrigin(bot, mo->x, mo->y, mo->z);
bot->momx = bot->momy = bot->momz = 1; bot->momx = bot->momy = bot->momz = 1;
@@ -2487,7 +2504,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
var1 = sides[line->sidenum[0]].toptexture; //(line->dx>>FRACBITS)-1; var1 = sides[line->sidenum[0]].toptexture; //(line->dx>>FRACBITS)-1;
if (line->sidenum[1] != 0xffff && line->flags & ML_BLOCKMONSTERS) // read power from back sidedef if (line->sidenum[1] != NO_INDEX && line->flags & ML_BLOCKMONSTERS) // read power from back sidedef
var2 = sides[line->sidenum[1]].toptexture; var2 = sides[line->sidenum[1]].toptexture;
else if (line->flags & ML_NOCLIMB) // 'Infinite' else if (line->flags & ML_NOCLIMB) // 'Infinite'
var2 = UINT16_MAX; var2 = UINT16_MAX;
@@ -2502,6 +2519,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
P_SetTarget(&dummy->target, bot); P_SetTarget(&dummy->target, bot);
A_CustomPower(dummy); A_CustomPower(dummy);
} }
P_RemoveMobj(dummy); P_RemoveMobj(dummy);
} }
break; break;
@@ -2565,11 +2583,15 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
if (mo && mo->player) if (mo && mo->player)
{ {
UINT16 fractime = (UINT16)(sides[line->sidenum[0]].textureoffset>>FRACBITS); UINT16 fractime = (UINT16)(sides[line->sidenum[0]].textureoffset>>FRACBITS);
if (fractime < 1) if (fractime < 1)
fractime = 1; //instantly wears off upon leaving fractime = 1; //instantly wears off upon leaving
if (line->flags & ML_NOCLIMB) if (line->flags & ML_NOCLIMB)
fractime |= 1<<15; //more crazy &ing, as if music stuff wasn't enough fractime |= 1<<15; //more crazy &ing, as if music stuff wasn't enough
mo->player->powers[pw_nocontrol] = fractime; mo->player->powers[pw_nocontrol] = fractime;
if (bot) if (bot)
bot->player->powers[pw_nocontrol] = fractime; bot->player->powers[pw_nocontrol] = fractime;
} }
@@ -2579,8 +2601,10 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
if (mo) if (mo)
{ {
mo->destscale = FixedDiv(P_AproxDistance(line->dx, line->dy), 100<<FRACBITS); mo->destscale = FixedDiv(P_AproxDistance(line->dx, line->dy), 100<<FRACBITS);
if (mo->destscale < FRACUNIT/100) if (mo->destscale < FRACUNIT/100)
mo->destscale = FRACUNIT/100; mo->destscale = FRACUNIT/100;
if (mo->player && bot) if (mo->player && bot)
bot->destscale = mo->destscale; bot->destscale = mo->destscale;
} }
@@ -2609,7 +2633,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
if (always || this->bottomtexture) if (always || this->bottomtexture)
this->bottomtexture = set->bottomtexture; this->bottomtexture = set->bottomtexture;
if (lines[linenum].sidenum[1] == 0xffff) if (lines[linenum].sidenum[1] == NO_INDEX)
continue; // One-sided stops here. continue; // One-sided stops here.
// Back side // Back side
@@ -2658,16 +2682,18 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
sector_t *sec; sector_t *sec;
mobj_t *thing; mobj_t *thing;
if (line->sidenum[1] != 0xffff) if (line->sidenum[1] != NO_INDEX)
state = (statenum_t)sides[line->sidenum[1]].toptexture; state = (statenum_t)sides[line->sidenum[1]].toptexture;
while ((secnum = P_FindSectorFromLineTag(line, secnum)) >= 0) while ((secnum = P_FindSectorFromLineTag(line, secnum)) >= 0)
{ {
boolean tryagain; boolean tryagain;
sec = sectors + secnum; sec = sectors + secnum;
do { do {
tryagain = false; tryagain = false;
for (thing = sec->thinglist; thing; thing = thing->snext) for (thing = sec->thinglist; thing; thing = thing->snext)
{
if (thing->type == type) if (thing->type == type)
{ {
if (state != NUMSTATES) if (state != NUMSTATES)
@@ -2684,6 +2710,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
break; break;
} }
} }
}
} while (tryagain); } while (tryagain);
} }
break; break;
@@ -3259,6 +3286,7 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
case 3: // Linedef executor requires all players present // Trigger Linedef Exec (Floor Touch, All Players) case 3: // Linedef executor requires all players present // Trigger Linedef Exec (Floor Touch, All Players)
/// \todo check continues for proper splitscreen support? /// \todo check continues for proper splitscreen support?
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i] && !players[i].bot && players[i].mo && (gametype != GT_COOP || players[i].lives > 0)) if (playeringame[i] && !players[i].bot && players[i].mo && (gametype != GT_COOP || players[i].lives > 0))
{ {
if (roversector) if (roversector)
@@ -3312,6 +3340,7 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
goto DoneSection2; goto DoneSection2;
} }
} }
}
/* FALLTHRU */ /* FALLTHRU */
case 4: // Linedef executor that doesn't require touching floor // Trigger Linedef Exec (Anywhere in Sector) case 4: // Linedef executor that doesn't require touching floor // Trigger Linedef Exec (Anywhere in Sector)
case 5: // Linedef executor // Trigger Linedef Exec (Floor Touch) case 5: // Linedef executor // Trigger Linedef Exec (Floor Touch)
@@ -3385,14 +3414,16 @@ DoneSection2:
{ {
const fixed_t hscale = mapobjectscale + (mapobjectscale - player->mo->scale); const fixed_t hscale = mapobjectscale + (mapobjectscale - player->mo->scale);
const fixed_t minspeed = 24*hscale; const fixed_t minspeed = 24*hscale;
angle_t pushangle = FixedHypot(player->mo->momx, player->mo->momy) ? R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy) : player->mo->angle;
// if we have no speed for SOME REASON, use the player's angle, otherwise we'd be forcefully thrusted to what I can only assume is angle 0
if (player->mo->eflags & MFE_SPRUNG) if (player->mo->eflags & MFE_SPRUNG)
break; break;
if (player->speed < minspeed) // Push forward to prevent getting stuck if (player->speed < minspeed) // Push forward to prevent getting stuck
{
// if we have no speed for SOME REASON, use the player's angle, otherwise we'd be forcefully thrusted to what I can only assume is angle 0
const angle_t pushangle = FixedHypot(player->mo->momx, player->mo->momy) ? R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy) : player->mo->angle;
P_InstaThrust(player->mo, pushangle, minspeed); P_InstaThrust(player->mo, pushangle, minspeed);
}
player->kartstuff[k_pogospring] = 1; player->kartstuff[k_pogospring] = 1;
K_DoPogoSpring(player->mo, 0, 1); K_DoPogoSpring(player->mo, 0, 1);
@@ -3408,16 +3439,22 @@ DoneSection2:
const fixed_t hscale = mapobjectscale + (mapobjectscale - player->mo->scale); const fixed_t hscale = mapobjectscale + (mapobjectscale - player->mo->scale);
const fixed_t minspeed = 24*hscale; const fixed_t minspeed = 24*hscale;
const fixed_t maxspeed = 28*hscale; const fixed_t maxspeed = 28*hscale;
angle_t pushangle = FixedHypot(player->mo->momx, player->mo->momy) ? R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy) : player->mo->angle;
// if we have no speed for SOME REASON, use the player's angle, otherwise we'd be forcefully thrusted to what I can only assume is angle 0
if (player->mo->eflags & MFE_SPRUNG) if (player->mo->eflags & MFE_SPRUNG)
break; break;
if (player->speed > maxspeed) // Prevent overshooting jumps if (player->speed > maxspeed) // Prevent overshooting jumps
{
// if we have no speed for SOME REASON, use the player's angle, otherwise we'd be forcefully thrusted to what I can only assume is angle 0
const angle_t pushangle = FixedHypot(player->mo->momx, player->mo->momy) ? R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy) : player->mo->angle;
P_InstaThrust(player->mo, pushangle, maxspeed); P_InstaThrust(player->mo, pushangle, maxspeed);
}
else if (player->speed < minspeed) // Push forward to prevent getting stuck else if (player->speed < minspeed) // Push forward to prevent getting stuck
{
// if we have no speed for SOME REASON, use the player's angle, otherwise we'd be forcefully thrusted to what I can only assume is angle 0
const angle_t pushangle = FixedHypot(player->mo->momx, player->mo->momy) ? R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy) : player->mo->angle;
P_InstaThrust(player->mo, pushangle, minspeed); P_InstaThrust(player->mo, pushangle, minspeed);
}
player->kartstuff[k_pogospring] = 2; player->kartstuff[k_pogospring] = 2;
K_DoPogoSpring(player->mo, 0, 1); K_DoPogoSpring(player->mo, 0, 1);
@@ -3436,11 +3473,14 @@ DoneSection2:
if (i != -1) if (i != -1)
{ {
INT32 sfxnum;
angle_t lineangle; angle_t lineangle;
fixed_t linespeed; fixed_t linespeed;
lineangle = lines[i].angle; const line_t *line = &lines[i];
linespeed = P_AproxDistance(lines[i].v2->x-lines[i].v1->x, lines[i].v2->y-lines[i].v1->y);
lineangle = line->angle;
linespeed = P_AproxDistance(line->v2->x-line->v1->x, line->v2->y-line->v1->y);
player->mo->angle = lineangle; player->mo->angle = lineangle;
@@ -3454,7 +3494,7 @@ DoneSection2:
P_ForceLocalAngle(player, player->mo->angle); P_ForceLocalAngle(player, player->mo->angle);
} }
if (!(lines[i].flags & ML_EFFECT4)) if (!(line->flags & ML_EFFECT4))
{ {
P_UnsetThingPosition(player->mo); P_UnsetThingPosition(player->mo);
if (roversector) // make FOF speed pads work if (roversector) // make FOF speed pads work
@@ -3476,7 +3516,14 @@ DoneSection2:
player->kartstuff[k_drift] = 0; player->kartstuff[k_drift] = 0;
player->kartstuff[k_driftcharge] = 0; player->kartstuff[k_driftcharge] = 0;
player->kartstuff[k_pogospring] = 0; player->kartstuff[k_pogospring] = 0;
S_StartSound(player->mo, sfx_spdpad);
sfxnum = sides[line->sidenum[0]].toptexture;
// none or invalid sound?
if (sfxnum <= sfx_None || sfxnum >= NUMSFX)
sfxnum = sfx_spdpad; // use the zippy sound then!
S_StartSound(player->mo, sfxnum);
{ {
sfxenum_t pick = P_RandomKey(2); // Gotta roll the RNG every time this is called for sync reasons sfxenum_t pick = P_RandomKey(2); // Gotta roll the RNG every time this is called for sync reasons
@@ -3525,21 +3572,25 @@ DoneSection2:
P_DoPlayerExit(player); P_DoPlayerExit(player);
P_SetupSignExit(player); P_SetupSignExit(player);
// important: use sector->tag on next line instead of player->mo->subsector->tag
// this part is different from in P_PlayerThink, this is what was causing
// FOF custom exits not to work.
lineindex = P_FindSpecialLineFromTag(2, sector->tag, -1);
if (gametype == GT_COOP && lineindex != -1) // Custom exit! if (gametype == GT_COOP)
{ {
// Special goodies with the block monsters flag depending on emeralds collected // important: use sector->tag on next line instead of player->mo->subsector->tag
if ((lines[lineindex].flags & ML_BLOCKMONSTERS) && ALL7EMERALDS(emeralds)) // this part is different from in P_PlayerThink, this is what was causing
nextmapoverride = (INT16)(lines[lineindex].frontsector->ceilingheight>>FRACBITS); // FOF custom exits not to work.
else lineindex = P_FindSpecialLineFromTag(2, sector->tag, -1);
nextmapoverride = (INT16)(lines[lineindex].frontsector->floorheight>>FRACBITS);
if (lines[lineindex].flags & ML_NOCLIMB) if (lineindex != -1) // Custom exit!)
skipstats = true; {
// Special goodies with the block monsters flag depending on emeralds collected
if ((lines[lineindex].flags & ML_BLOCKMONSTERS) && ALL7EMERALDS(emeralds))
nextmapoverride = (INT16)(lines[lineindex].frontsector->ceilingheight>>FRACBITS);
else
nextmapoverride = (INT16)(lines[lineindex].frontsector->floorheight>>FRACBITS);
if (lines[lineindex].flags & ML_NOCLIMB)
skipstats = true;
}
} }
} }
break; break;
@@ -3645,7 +3696,6 @@ DoneSection2:
thinker_t *th; thinker_t *th;
mobj_t *waypoint = NULL; mobj_t *waypoint = NULL;
mobj_t *mo2; mobj_t *mo2;
angle_t an;
if (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT) if (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT)
break; break;
@@ -3693,10 +3743,13 @@ DoneSection2:
CONS_Debug(DBG_GAMELOGIC, "Waypoint %d found in sequence %d - speed = %d\n", waypoint->health, sequence, speed); CONS_Debug(DBG_GAMELOGIC, "Waypoint %d found in sequence %d - speed = %d\n", waypoint->health, sequence, speed);
} }
an = R_PointToAngle2(player->mo->x, player->mo->y, waypoint->x, waypoint->y) - player->mo->angle; if (!(lines[lineindex].flags & ML_EFFECT4))
{
const angle_t an = R_PointToAngle2(player->mo->x, player->mo->y, waypoint->x, waypoint->y) - player->mo->angle;
if (an > ANGLE_90 && an < ANGLE_270 && !(lines[lineindex].flags & ML_EFFECT4)) if (an > ANGLE_90 && an < ANGLE_270)
break; // behind back break; // behind back
}
P_SetTarget(&player->mo->tracer, waypoint); P_SetTarget(&player->mo->tracer, waypoint);
player->speed = speed; player->speed = speed;
@@ -3718,7 +3771,6 @@ DoneSection2:
thinker_t *th; thinker_t *th;
mobj_t *waypoint = NULL; mobj_t *waypoint = NULL;
mobj_t *mo2; mobj_t *mo2;
angle_t an;
if (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT) if (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT)
break; break;
@@ -3766,10 +3818,13 @@ DoneSection2:
CONS_Debug(DBG_GAMELOGIC, "Waypoint %d found in sequence %d - speed = %d\n", waypoint->health, sequence, speed); CONS_Debug(DBG_GAMELOGIC, "Waypoint %d found in sequence %d - speed = %d\n", waypoint->health, sequence, speed);
} }
an = R_PointToAngle2(player->mo->x, player->mo->y, waypoint->x, waypoint->y) - player->mo->angle; if (!(lines[lineindex].flags & ML_EFFECT4))
{
const angle_t an = R_PointToAngle2(player->mo->x, player->mo->y, waypoint->x, waypoint->y) - player->mo->angle;
if (an > ANGLE_90 && an < ANGLE_270 && !(lines[lineindex].flags & ML_EFFECT4)) if (an > ANGLE_90 && an < ANGLE_270)
break; // behind back break; // behind back
}
P_SetTarget(&player->mo->tracer, waypoint); P_SetTarget(&player->mo->tracer, waypoint);
player->speed = speed; player->speed = speed;
@@ -3783,10 +3838,13 @@ DoneSection2:
case 10: // Finish Line case 10: // Finish Line
// SRB2kart - 150117 // SRB2kart - 150117
if (G_RaceGametype() && (player->starpostnum >= (numstarposts - (numstarposts/2)) || player->exiting)) if (!G_RaceGametype())
break;
if (player->starpostnum >= (numstarposts - (numstarposts/2)) || player->exiting)
player->kartstuff[k_starpostwp] = player->kartstuff[k_waypoint] = 0; player->kartstuff[k_starpostwp] = player->kartstuff[k_waypoint] = 0;
// //
if (G_RaceGametype() && !player->exiting) if (!player->exiting)
{ {
if (player->starpostnum >= (numstarposts - (numstarposts/2))) // srb2kart: must have touched *enough* starposts (was originally "(player->starpostnum == numstarposts)") if (player->starpostnum >= (numstarposts - (numstarposts/2))) // srb2kart: must have touched *enough* starposts (was originally "(player->starpostnum == numstarposts)")
{ {
@@ -4441,12 +4499,13 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
} }
f_affectpoint = P_GetSpecialBottomZ(player->mo, sector, sector); f_affectpoint = P_GetSpecialBottomZ(player->mo, sector, sector);
c_affectpoint = P_GetSpecialTopZ(player->mo, sector, sector);
// Only go further if on the ground // Only go further if on the ground
if ((sector->flags & SF_FLIPSPECIAL_FLOOR) && !(sector->flags & SF_FLIPSPECIAL_CEILING) && player->mo->z != f_affectpoint) if ((sector->flags & SF_FLIPSPECIAL_FLOOR) && !(sector->flags & SF_FLIPSPECIAL_CEILING) && player->mo->z != f_affectpoint)
return; return;
c_affectpoint = P_GetSpecialTopZ(player->mo, sector, sector);
if ((sector->flags & SF_FLIPSPECIAL_CEILING) && !(sector->flags & SF_FLIPSPECIAL_FLOOR) && player->mo->z + player->mo->height != c_affectpoint) if ((sector->flags & SF_FLIPSPECIAL_CEILING) && !(sector->flags & SF_FLIPSPECIAL_FLOOR) && player->mo->z + player->mo->height != c_affectpoint)
return; return;
@@ -4502,27 +4561,13 @@ void P_PlayerInSpecialSector(player_t *player)
#undef TELEPORTED #undef TELEPORTED
/** Animate planes, scroll walls, etc. and keeps track of level timelimit and exits if time is up. static void P_UpdateAnimFlats(void)
*
* \sa P_CheckTimeLimit, P_CheckPointLimit
*/
void P_UpdateSpecials(void)
{ {
anim_t *anim; anim_t *anim;
INT32 i; INT32 i;
size_t j; size_t j;
levelflat_t *foundflats; // for flat animation levelflat_t *foundflats; // for flat animation
// LEVEL TIMER
P_CheckTimeLimit();
// POINT LIMIT
P_CheckPointLimit();
// Dynamic slopeness
if (!midgamejoin) // run here when not joined midgame to prevent any potential issues that may arise
P_RunDynamicSlopes();
// ANIMATE TEXTURES // ANIMATE TEXTURES
for (anim = anims; anim < lastanim; anim++) for (anim = anims; anim < lastanim; anim++)
{ {
@@ -4552,15 +4597,40 @@ void P_UpdateSpecials(void)
} }
} }
/** Animate planes, scroll walls, etc. and keeps track of level timelimit and exits if time is up.
*
* \sa P_CheckTimeLimit, P_CheckPointLimit
*/
void P_UpdateSpecials(void)
{
// LEVEL TIMER
P_CheckTimeLimit();
// POINT LIMIT
P_CheckPointLimit();
#ifdef COMPAT_VANILLA
// Dynamic slopeness
// we run this here only when not joined midrace
// for vanilla compat reasons :chaosleep:
if (!midgamejoin)
P_RunDynamicSlopes();
#endif
P_UpdateAnimFlats();
}
static inline ffloor_t *P_GetFFloorBySec(sector_t *sec, sector_t *sec2) static inline ffloor_t *P_GetFFloorBySec(sector_t *sec, sector_t *sec2)
{ {
ffloor_t *rover; ffloor_t *rover;
if (!sec->ffloors) if (!sec->ffloors)
return NULL; return NULL;
for (rover = sec->ffloors; rover; rover = rover->next) for (rover = sec->ffloors; rover; rover = rover->next)
if (rover->secnum == (size_t)(sec2 - sectors)) if (rover->secnum == (size_t)(sec2 - sectors))
return rover; return rover;
return NULL; return NULL;
} }
@@ -4611,6 +4681,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
if (sec == sec2) if (sec == sec2)
return NULL; //Don't need a fake floor on a control sector. return NULL; //Don't need a fake floor on a control sector.
if ((ffloor = (P_GetFFloorBySec(sec, sec2)))) if ((ffloor = (P_GetFFloorBySec(sec, sec2))))
return ffloor; // If this ffloor already exists, return it return ffloor; // If this ffloor already exists, return it
@@ -4717,7 +4788,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
P_AddSpikeThinker(sec, (INT32)sec2num); P_AddSpikeThinker(sec, (INT32)sec2num);
} }
// Should this FOF have friction? // Should this FOF have friction?
else if(th->function == (actionf_p1)T_Friction) else if (th->function == (actionf_p1)T_Friction)
{ {
f = (friction_t *)th; f = (friction_t *)th;
@@ -4725,7 +4796,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
Add_Friction(f->friction, f->movefactor, (INT32)(sec-sectors), f->affectee); Add_Friction(f->friction, f->movefactor, (INT32)(sec-sectors), f->affectee);
} }
// Should this FOF have wind/current/pusher? // Should this FOF have wind/current/pusher?
else if(th->function == (actionf_p1)T_Pusher) else if (th->function == (actionf_p1)T_Pusher)
{ {
p = (pusher_t *)th; p = (pusher_t *)th;
@@ -5163,11 +5234,18 @@ void T_LaserFlash(laserthink_t *flash)
if (thing->health <= 0) if (thing->health <= 0)
continue; continue;
// thing is neither shootable nor an egg guard shield
if (!(thing->flags & MF_SHOOTABLE) && (thing->type != MT_EGGSHIELD))
continue;
top = P_GetSpecialTopZ(thing, sourcesec, sector); top = P_GetSpecialTopZ(thing, sourcesec, sector);
if (thing->z >= top)
continue;
bottom = P_GetSpecialBottomZ(thing, sourcesec, sector); bottom = P_GetSpecialBottomZ(thing, sourcesec, sector);
if (thing->z >= top if (thing->z + thing->height <= bottom)
|| thing->z + thing->height <= bottom)
continue; continue;
if (thing->flags & MF_SHOOTABLE) if (thing->flags & MF_SHOOTABLE)
@@ -5261,7 +5339,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
continue; continue;
// Process Section 1 // Process Section 1
switch(GETSECSPECIAL(sector->special, 1)) switch (GETSECSPECIAL(sector->special, 1))
{ {
case 5: // Spikes case 5: // Spikes
P_AddSpikeThinker(sector, (INT32)(sector-sectors)); P_AddSpikeThinker(sector, (INT32)(sector-sectors));
@@ -5273,7 +5351,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
} }
// Process Section 2 // Process Section 2
switch(GETSECSPECIAL(sector->special, 2)) switch (GETSECSPECIAL(sector->special, 2))
{ {
case 10: // Time for special stage case 10: // Time for special stage
sstimer = (sector->floorheight>>FRACBITS) * TICRATE + 6; // Time to finish sstimer = (sector->floorheight>>FRACBITS) * TICRATE + 6; // Time to finish
@@ -5286,7 +5364,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
} }
// Process Section 4 // Process Section 4
switch(GETSECSPECIAL(sector->special, 4)) switch (GETSECSPECIAL(sector->special, 4))
{ {
case 10: // Circuit finish line case 10: // Circuit finish line
if (G_RaceGametype()) if (G_RaceGametype())
@@ -5322,11 +5400,13 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
// Allocate each list, and then zero the count so we can use it to track // Allocate each list, and then zero the count so we can use it to track
// the end of the list as we add the thinkers // the end of the list as we add the thinkers
for (i = 0; i < numsectors; i++) for (i = 0; i < numsectors; i++)
if(secthinkers[i].count > 0) {
if (secthinkers[i].count > 0)
{ {
secthinkers[i].thinkers = Z_Malloc(secthinkers[i].count * sizeof(thinker_t *), PU_STATIC, NULL); secthinkers[i].thinkers = Z_Malloc(secthinkers[i].count * sizeof(thinker_t *), PU_STATIC, NULL);
secthinkers[i].count = 0; secthinkers[i].count = 0;
} }
}
// Finally, populate the lists. // Finally, populate the lists.
for (th = thinkercap.next; th != &thinkercap; th = th->next) for (th = thinkercap.next; th != &thinkercap; th = th->next)
@@ -5978,7 +6058,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
break; break;
case 259: // Make-Your-Own FOF! case 259: // Make-Your-Own FOF!
if (lines[i].sidenum[1] != 0xffff) if (lines[i].sidenum[1] != NO_INDEX)
{ {
UINT8 *data; UINT8 *data;
UINT16 b; UINT16 b;
@@ -6425,15 +6505,19 @@ void T_Scroll(scroll_t *s)
if (thing->flags2 & MF2_PUSHED) // Already pushed this tic by an exclusive pusher. if (thing->flags2 & MF2_PUSHED) // Already pushed this tic by an exclusive pusher.
continue; continue;
height = P_GetSpecialBottomZ(thing, sec, psec);
if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped
if (!(thing->flags & MF_NOGRAVITY || thing->z+thing->height != height)) // Thing must a) be non-floating and have z+height == height
{ {
// Move objects only if on floor height = P_GetSpecialBottomZ(thing, sec, psec);
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive); if (!(thing->flags & MF_NOGRAVITY || thing->z+thing->height != height)) // Thing must a) be non-floating and have z+height == height
{
// Move objects only if on floor
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive);
}
} }
} // end of for loop through touching_thinglist } // end of for loop through touching_thinglist
} // end of loop through sectors } // end of loop through sectors
} }
@@ -6447,14 +6531,16 @@ void T_Scroll(scroll_t *s)
if (thing->flags2 & MF2_PUSHED) if (thing->flags2 & MF2_PUSHED)
continue; continue;
height = P_GetSpecialBottomZ(thing, sec, sec); if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped
if (!(thing->flags & MF_NOCLIP) &&
(!(thing->flags & MF_NOGRAVITY || thing->z > height)))
{ {
// Move objects only if on floor or underwater, height = P_GetSpecialBottomZ(thing, sec, sec);
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive); if (!(thing->flags & MF_NOGRAVITY || thing->z > height))
{
// Move objects only if on floor or underwater,
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive);
}
} }
} }
} }
@@ -6500,14 +6586,16 @@ void T_Scroll(scroll_t *s)
if (thing->flags2 & MF2_PUSHED) if (thing->flags2 & MF2_PUSHED)
continue; continue;
height = P_GetSpecialTopZ(thing, sec, psec);
if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped
if (!(thing->flags & MF_NOGRAVITY || thing->z != height))// Thing must a) be non-floating and have z == height
{ {
// Move objects only if on floor or underwater, height = P_GetSpecialTopZ(thing, sec, psec);
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive); if (!(thing->flags & MF_NOGRAVITY || thing->z != height))// Thing must a) be non-floating and have z == height
{
// Move objects only if on floor or underwater,
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive);
}
} }
} // end of for loop through touching_thinglist } // end of for loop through touching_thinglist
} // end of loop through sectors } // end of loop through sectors
@@ -6522,14 +6610,16 @@ void T_Scroll(scroll_t *s)
if (thing->flags2 & MF2_PUSHED) if (thing->flags2 & MF2_PUSHED)
continue; continue;
height = P_GetSpecialTopZ(thing, sec, sec); if (!(thing->flags & MF_NOCLIP)) // Thing must be clipped
if (!(thing->flags & MF_NOCLIP) &&
(!(thing->flags & MF_NOGRAVITY || thing->z+thing->height < height)))
{ {
// Move objects only if on floor or underwater, height = P_GetSpecialTopZ(thing, sec, sec);
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive); if (!(thing->flags & MF_NOGRAVITY || thing->z+thing->height < height))
{
// Move objects only if on floor or underwater,
// non-floating, and clipped.
P_DoScrollMove(thing, dx, dy, s->exclusive);
}
} }
} }
} }
@@ -6697,7 +6787,7 @@ static void P_SpawnScrollers(void)
case 506: case 506:
s = lines[i].sidenum[1]; s = lines[i].sidenum[1];
if (s != 0xffff) if (s != NO_INDEX)
Add_Scroller(sc_side, -sides[s].textureoffset, sides[s].rowoffset, -1, lines[i].sidenum[0], accel, 0); Add_Scroller(sc_side, -sides[s].textureoffset, sides[s].rowoffset, -1, lines[i].sidenum[0], accel, 0);
else else
CONS_Debug(DBG_GAMELOGIC, "Line special 506 (line #%s) missing 2nd side!\n", sizeu1(i)); CONS_Debug(DBG_GAMELOGIC, "Line special 506 (line #%s) missing 2nd side!\n", sizeu1(i));
@@ -6908,6 +6998,7 @@ static void P_SpawnFriction(void)
INT32 movefactor; // applied to each player move to simulate inertia INT32 movefactor; // applied to each player move to simulate inertia
for (i = 0; i < numlines; i++, l++) for (i = 0; i < numlines; i++, l++)
{
if (l->special == 540) if (l->special == 540)
{ {
//length = P_AproxDistance(l->dx, l->dy)>>FRACBITS; //length = P_AproxDistance(l->dx, l->dy)>>FRACBITS;
@@ -6941,6 +7032,7 @@ static void P_SpawnFriction(void)
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Friction(friction, movefactor, s, -1); Add_Friction(friction, movefactor, s, -1);
} }
}
} }
/* /*
@@ -6989,9 +7081,10 @@ static void Add_Pusher(pushertype_e type, fixed_t x_mag, fixed_t y_mag, mobj_t *
// "The right triangle of the square of the length of the hypotenuse is equal to the sum of the squares of the lengths of the other two sides." // "The right triangle of the square of the length of the hypotenuse is equal to the sum of the squares of the lengths of the other two sides."
// "Bah! Stupid brains! Don't you know anything besides the Pythagorean Theorem?" - Earthworm Jim // "Bah! Stupid brains! Don't you know anything besides the Pythagorean Theorem?" - Earthworm Jim
if (type == p_downcurrent || type == p_upcurrent || type == p_upwind || type == p_downwind) if (type == p_downcurrent || type == p_upcurrent || type == p_upwind || type == p_downwind)
p->magnitude = P_AproxDistance(p->x_mag,p->y_mag)<<(FRACBITS-PUSH_FACTOR); p->magnitude = P_AproxDistance(p->x_mag, p->y_mag)<<(FRACBITS-PUSH_FACTOR);
else else
p->magnitude = P_AproxDistance(p->x_mag,p->y_mag); p->magnitude = P_AproxDistance(p->x_mag, p->y_mag);
if (source) // point source exist? if (source) // point source exist?
{ {
// where force goes to zero // where force goes to zero
@@ -7042,15 +7135,14 @@ static inline boolean PIT_PushThing(mobj_t *thing)
// don't fade wrt Z if health & 2 (mapthing has multi flag) // don't fade wrt Z if health & 2 (mapthing has multi flag)
if (tmpusher->source->health & 2) if (tmpusher->source->health & 2)
dist = P_AproxDistance(thing->x - sx,thing->y - sy); dist = P_AproxDistance(thing->x - sx, thing->y - sy);
else else
{ {
// Make sure the Z is in range // Make sure the Z is in range
if (thing->z < sz - tmpusher->radius || thing->z > sz + tmpusher->radius) if (thing->z < sz - tmpusher->radius || thing->z > sz + tmpusher->radius)
return false; return false;
dist = P_AproxDistance(P_AproxDistance(thing->x - sx, thing->y - sy), dist = P_AproxDistance(P_AproxDistance(thing->x - sx, thing->y - sy), thing->z - sz);
thing->z - sz);
} }
speed = (tmpusher->magnitude - ((dist>>FRACBITS)>>1))<<(FRACBITS - PUSH_FACTOR - 1); speed = (tmpusher->magnitude - ((dist>>FRACBITS)>>1))<<(FRACBITS - PUSH_FACTOR - 1);
@@ -7213,7 +7305,6 @@ void T_Pusher(pusher_t *p)
if (p->type == p_push) if (p->type == p_push)
{ {
// Seek out all pushable things within the force radius of this // Seek out all pushable things within the force radius of this
// point pusher. Crosses sectors, so use blockmap. // point pusher. Crosses sectors, so use blockmap.
@@ -7256,13 +7347,16 @@ void T_Pusher(pusher_t *p)
if (thing->flags2 & MF2_PUSHED) if (thing->flags2 & MF2_PUSHED)
continue; continue;
if (thing->player && thing->player->pflags & PF_ROPEHANG) if (thing->player)
continue; {
if (thing->player->pflags & PF_ROPEHANG)
continue;
if (thing->player && (thing->state == &states[thing->info->painstate]) if ((thing->state == &states[thing->info->painstate])
&& (thing->player->powers[pw_flashing] > (K_GetKartFlashing(thing->player)/4)*3 && (thing->player->powers[pw_flashing] > (K_GetKartFlashing(thing->player)/4)*3
&& thing->player->powers[pw_flashing] <= K_GetKartFlashing(thing->player))) && thing->player->powers[pw_flashing] <= K_GetKartFlashing(thing->player)))
continue; continue;
}
inFOF = touching = moved = false; inFOF = touching = moved = false;
@@ -7392,7 +7486,7 @@ void T_Pusher(pusher_t *p)
if (p->slider && thing->player) if (p->slider && thing->player)
{ {
boolean jumped = (thing->player->pflags & PF_JUMPED); boolean jumped = (thing->player->pflags & PF_JUMPED);
P_ResetPlayer (thing->player); P_ResetPlayer(thing->player);
if (jumped) if (jumped)
thing->player->pflags |= PF_JUMPED; thing->player->pflags |= PF_JUMPED;
@@ -7460,16 +7554,17 @@ static void P_SpawnPushers(void)
mobj_t *thing; mobj_t *thing;
for (i = 0; i < numlines; i++, l++) for (i = 0; i < numlines; i++, l++)
{
switch (l->special) switch (l->special)
{ {
case 541: // wind case 541: // wind
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_wind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_wind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
case 544: // current case 544: // current
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_current, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_current, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
case 547: // push/pull case 547: // push/pull
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
{ {
@@ -7481,20 +7576,21 @@ static void P_SpawnPushers(void)
case 545: // current up case 545: // current up
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_upcurrent, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_upcurrent, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
case 546: // current down case 546: // current down
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_downcurrent, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_downcurrent, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
case 542: // wind up case 542: // wind up
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_upwind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_upwind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
case 543: // wind down case 543: // wind down
for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(l, s)) >= 0 ;)
Add_Pusher(p_downwind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4); Add_Pusher(p_downwind, l->dx, l->dy, NULL, s, -1, l->flags & ML_NOCLIMB, l->flags & ML_EFFECT4);
break; break;
} }
}
} }
void P_StartQuake(tic_t time, fixed_t intensity, fixed_t radius) void P_StartQuake(tic_t time, fixed_t intensity, fixed_t radius)
+13 -2
View File
@@ -611,6 +611,15 @@ void P_Ticker(boolean run)
#ifdef DEMO_COMPAT_100 #ifdef DEMO_COMPAT_100
} }
#endif #endif
// Lookback is normally handled inside G_BuildTiccmd, which isn't called in replays so we're doing that manually
// idk if this is best place to handle this tho...
for (i = 0; i <= splitscreen; ++i)
{
const boolean usejoystick = cv_usejoystick[i].value;
INT32 axis = JoyAxis(AXISLOOKBACK, i+1);
camspin[i] = (InputDown(gc_lookback, i+1) || (usejoystick && axis > 0));
}
} }
ps_lua_mobjhooks.value.i = 0; ps_lua_mobjhooks.value.i = 0;
@@ -637,7 +646,9 @@ void P_Ticker(boolean run)
if (run) if (run)
{ {
// Dynamic slopeness // Dynamic slopeness
#ifdef COMPAT_VANILLA
if (midgamejoin) // only run here if we joined midgame to fix some desynchs if (midgamejoin) // only run here if we joined midgame to fix some desynchs
#endif
P_RunDynamicSlopes(); P_RunDynamicSlopes();
PS_START_TIMING(ps_thinkertime); PS_START_TIMING(ps_thinkertime);
@@ -706,6 +717,7 @@ void P_Ticker(boolean run)
if (indirectitemcooldown > 0) if (indirectitemcooldown > 0)
indirectitemcooldown--; indirectitemcooldown--;
if (hyubgone > 0) if (hyubgone > 0)
hyubgone--; hyubgone--;
@@ -713,8 +725,7 @@ void P_Ticker(boolean run)
{ {
K_UpdateSpectateGrief(); K_UpdateSpectateGrief();
} }
else if (G_BattleGametype())
if (G_BattleGametype())
{ {
if (wantedcalcdelay && --wantedcalcdelay <= 0) if (wantedcalcdelay && --wantedcalcdelay <= 0)
K_CalculateBattleWanted(); K_CalculateBattleWanted();
+63 -72
View File
@@ -157,6 +157,7 @@ void P_CalcHeight(player_t *player)
if (player->viewz > mo->ceilingz - FixedMul(FRACUNIT, mo->scale)) if (player->viewz > mo->ceilingz - FixedMul(FRACUNIT, mo->scale))
player->viewz = mo->ceilingz - FixedMul(FRACUNIT, mo->scale); player->viewz = mo->ceilingz - FixedMul(FRACUNIT, mo->scale);
} }
return; return;
} }
@@ -220,32 +221,6 @@ UINT8 P_GetNextEmerald(void)
return (UINT8)(gamemap - sstage_start); return (UINT8)(gamemap - sstage_start);
} }
//
// P_GiveEmerald
//
// Award an emerald upon completion
// of a special stage.
//
void P_GiveEmerald(boolean spawnObj)
{
INT32 i;
UINT8 em;
S_StartSound(NULL, sfx_cgot); // Got the emerald!
em = P_GetNextEmerald();
emeralds |= (1 << em);
if (spawnObj)
{
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
P_SetMobjState(P_SpawnMobj(players[i].mo->x, players[i].mo->y, players[i].mo->z + players[i].mo->info->height, MT_GOTEMERALD),
mobjinfo[MT_GOTEMERALD].spawnstate + em);
}
}
}
// //
// P_ResetScore // P_ResetScore
// //
@@ -800,7 +775,7 @@ boolean P_IsObjectInGoop(mobj_t *mo)
// //
boolean P_IsObjectOnGround(mobj_t *mo) boolean P_IsObjectOnGround(mobj_t *mo)
{ {
if (UNLIKELY(P_IsObjectInGoop(mo))) if (P_IsObjectInGoop(mo))
{ {
// but I don't want you to ever 'stand' while submerged in goo. // but I don't want you to ever 'stand' while submerged in goo.
// You're in constant vertical momentum, even if you get stuck on something. // You're in constant vertical momentum, even if you get stuck on something.
@@ -1147,22 +1122,26 @@ void P_SpawnShieldOrb(player_t *player)
P_SetTarget(&ov->target, shieldobj); P_SetTarget(&ov->target, shieldobj);
P_SetMobjState(ov, shieldobj->info->seestate); P_SetMobjState(ov, shieldobj->info->seestate);
} }
if (shieldobj->info->meleestate) if (shieldobj->info->meleestate)
{ {
ov = P_SpawnMobj(shieldobj->x, shieldobj->y, shieldobj->z, MT_OVERLAY); ov = P_SpawnMobj(shieldobj->x, shieldobj->y, shieldobj->z, MT_OVERLAY);
P_SetTarget(&ov->target, shieldobj); P_SetTarget(&ov->target, shieldobj);
P_SetMobjState(ov, shieldobj->info->meleestate); P_SetMobjState(ov, shieldobj->info->meleestate);
} }
if (shieldobj->info->missilestate) if (shieldobj->info->missilestate)
{ {
ov = P_SpawnMobj(shieldobj->x, shieldobj->y, shieldobj->z, MT_OVERLAY); ov = P_SpawnMobj(shieldobj->x, shieldobj->y, shieldobj->z, MT_OVERLAY);
P_SetTarget(&ov->target, shieldobj); P_SetTarget(&ov->target, shieldobj);
P_SetMobjState(ov, shieldobj->info->missilestate); P_SetMobjState(ov, shieldobj->info->missilestate);
} }
if (player->powers[pw_shield] & SH_FORCE) if (player->powers[pw_shield] & SH_FORCE)
{ {
//Copy and pasted from P_ShieldLook in p_mobj.c //Copy and pasted from P_ShieldLook in p_mobj.c
shieldobj->movecount = (player->powers[pw_shield] & 0xFF); shieldobj->movecount = (player->powers[pw_shield] & 0xFF);
if (shieldobj->movecount < 1) if (shieldobj->movecount < 1)
{ {
if (shieldobj->info->painstate) if (shieldobj->info->painstate)
@@ -1226,7 +1205,6 @@ mobj_t *P_SpawnGhostMobj(mobj_t *mobj)
ghost->pitch = mobj->pitch; ghost->pitch = mobj->pitch;
ghost->roll = mobj->roll; ghost->roll = mobj->roll;
ghost->sloperoll = mobj->sloperoll;
ghost->rollangle = mobj->rollangle; ghost->rollangle = mobj->rollangle;
ghost->sloperoll = mobj->sloperoll; ghost->sloperoll = mobj->sloperoll;
ghost->slopepitch = mobj->slopepitch; ghost->slopepitch = mobj->slopepitch;
@@ -1419,7 +1397,8 @@ static void P_CheckBustableBlocks(player_t *player)
for (rover = node->m_sector->ffloors; rover; rover = rover->next) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) continue; if (!(rover->flags & FF_EXISTS))
continue;
if ((rover->flags & FF_BUSTUP)/* && !rover->master->frontsector->crumblestate*/) if ((rover->flags & FF_BUSTUP)/* && !rover->master->frontsector->crumblestate*/)
{ {
@@ -1539,11 +1518,12 @@ static void P_CheckBouncySectors(player_t *player)
continue; // this sector type is required for FOFs to be bouncy continue; // this sector type is required for FOFs to be bouncy
topheight = P_GetFOFTopZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL); topheight = P_GetFOFTopZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL);
bottomheight = P_GetFOFBottomZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL);
if (player->mo->z > topheight) if (player->mo->z > topheight)
continue; continue;
bottomheight = P_GetFOFBottomZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL);
if (player->mo->z + player->mo->height < bottomheight) if (player->mo->z + player->mo->height < bottomheight)
continue; continue;
@@ -1593,10 +1573,12 @@ static void P_CheckBouncySectors(player_t *player)
newmom = -8*FRACUNIT; newmom = -8*FRACUNIT;
} }
if (newmom > P_GetPlayerHeight(player)/2) const fixed_t halfpheight = P_GetPlayerHeight(player)/2;
newmom = P_GetPlayerHeight(player)/2;
else if (newmom < -P_GetPlayerHeight(player)/2) if (newmom > halfpheight)
newmom = -P_GetPlayerHeight(player)/2; newmom = halfpheight;
else if (newmom < -halfpheight)
newmom = -halfpheight;
momentum.z = newmom*2; momentum.z = newmom*2;
@@ -1859,6 +1841,9 @@ void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range)
if (!((mo2->flags & MF_SHOOTABLE && mo2->flags & MF_ENEMY) || mo2->type == MT_EGGGUARD || mo2->player)) if (!((mo2->flags & MF_SHOOTABLE && mo2->flags & MF_ENEMY) || mo2->type == MT_EGGGUARD || mo2->player))
continue; continue;
if (mo2->health <= 0)
continue;
dist = P_AproxDistance(P_AproxDistance(player->mo->x-mo2->x, player->mo->y-mo2->y), player->mo->z-mo2->z); dist = P_AproxDistance(P_AproxDistance(player->mo->x-mo2->x, player->mo->y-mo2->y), player->mo->z-mo2->z);
if (range < dist) if (range < dist)
@@ -1867,15 +1852,12 @@ void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range)
if (!P_CheckSight(player->mo, mo2)) if (!P_CheckSight(player->mo, mo2))
continue; // if your psychic powers can't "see" it don't bother continue; // if your psychic powers can't "see" it don't bother
if (mo2->health > 0) an = R_PointToAngle2(player->mo->x, player->mo->y, mo2->x, mo2->y);
{
an = R_PointToAngle2(player->mo->x, player->mo->y, mo2->x, mo2->y);
P_Thrust(mo2, an, thrust); P_Thrust(mo2, an, thrust);
if (mo2->type == MT_GOLDBUZZ || mo2->type == MT_REDBUZZ) if (mo2->type == MT_GOLDBUZZ || mo2->type == MT_REDBUZZ)
mo2->tics += 8; mo2->tics += 8;
}
} }
//P_SpawnThokMobj(player); //P_SpawnThokMobj(player);
@@ -1992,20 +1974,23 @@ static void P_3dMovement(player_t *player)
K_MomentumToFacing(player); K_MomentumToFacing(player);
} }
const fixed_t kartspd = K_GetKartSpeed(player, true);
// Sideways movement // Sideways movement
if (cmd->sidemove != 0 && !((player->exiting || mapreset) || player->kartstuff[k_spinouttimer])) if (cmd->sidemove != 0 && !((player->exiting || mapreset) || player->kartstuff[k_spinouttimer]))
{ {
if (cmd->sidemove > 0) if (cmd->sidemove > 0)
movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, K_GetKartSpeed(player, true)); movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, kartspd);
else else
movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, K_GetKartSpeed(player, true)); movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, kartspd);
totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside); totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside);
totalthrust.y += P_ReturnThrustY(player->mo, movepushsideangle, movepushside); totalthrust.y += P_ReturnThrustY(player->mo, movepushsideangle, movepushside);
} }
if ((totalthrust.x || totalthrust.y) if ((totalthrust.x || totalthrust.y)
&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2) { && player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2)
{
// Factor thrust to slope, but only for the part pushing up it! // Factor thrust to slope, but only for the part pushing up it!
// The rest is unaffected. // The rest is unaffected.
angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-player->mo->standingslope->xydirection; angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-player->mo->standingslope->xydirection;
@@ -2041,11 +2026,11 @@ static void P_3dMovement(player_t *player)
// -Shadow Hog // -Shadow Hog
newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0); newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
if (newMagnitude > K_GetKartSpeed(player, true)) //topspeed) if (newMagnitude > kartspd) //topspeed)
{ {
fixed_t tempmomx, tempmomy; fixed_t tempmomx, tempmomy;
if (oldMagnitude > K_GetKartSpeed(player, true) && onground) // SRB2Kart: onground check for air speed cap if (oldMagnitude > kartspd && onground) // SRB2Kart: onground check for air speed cap
{ {
if (newMagnitude > oldMagnitude) if (newMagnitude > oldMagnitude)
{ {
@@ -2058,8 +2043,8 @@ static void P_3dMovement(player_t *player)
} }
else else
{ {
tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), K_GetKartSpeed(player, true)); //topspeed) tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), kartspd); //topspeed)
tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), K_GetKartSpeed(player, true)); //topspeed) tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), kartspd); //topspeed)
player->mo->momx = tempmomx + player->cmomx; player->mo->momx = tempmomx + player->cmomx;
player->mo->momy = tempmomy + player->cmomy; player->mo->momy = tempmomy + player->cmomy;
} }
@@ -2133,7 +2118,6 @@ void P_ElementalFireTrail(player_t *player)
INT32 i; INT32 i;
I_Assert(player != NULL); I_Assert(player != NULL);
I_Assert(player->mo != NULL);
I_Assert(!P_MobjWasRemoved(player->mo)); I_Assert(!P_MobjWasRemoved(player->mo));
if (player->mo->eflags & MFE_VERTICALFLIP) if (player->mo->eflags & MFE_VERTICALFLIP)
@@ -2295,7 +2279,8 @@ static void P_MovePlayer(player_t *player)
} }
//CONS_Printf("applied turn: %d\n", angle_diff); //CONS_Printf("applied turn: %d\n", angle_diff);
if (add_delta) { if (add_delta)
{
player->mo->angle += angle_diff << TICCMD_REDUCE; player->mo->angle += angle_diff << TICCMD_REDUCE;
player->mo->angle &= ~0xFFFF; // Try to keep the turning somewhat similar to how it was before? player->mo->angle &= ~0xFFFF; // Try to keep the turning somewhat similar to how it was before?
//CONS_Printf("leftover turn (%s): %5d or %4d%%\n", //CONS_Printf("leftover turn (%s): %5d or %4d%%\n",
@@ -2376,7 +2361,7 @@ static void P_MovePlayer(player_t *player)
if (onground && leveltime % 50 == 0 && player->kartstuff[k_drift] != 0) if (onground && leveltime % 50 == 0 && player->kartstuff[k_drift] != 0)
S_StartSound(player->mo, sfx_drift); S_StartSound(player->mo, sfx_drift);
// Leveltime being 50 might take a while at times. We'll start it up once, isntantly. // Leveltime being 50 might take a while at times. We'll start it up once, isntantly.
else if (onground && !S_SoundPlaying(player->mo, sfx_drift) && player->kartstuff[k_drift] != 0) else if (onground && player->kartstuff[k_drift] != 0 && !S_SoundPlaying(player->mo, sfx_drift))
S_StartSound(player->mo, sfx_drift); S_StartSound(player->mo, sfx_drift);
// Ok, we'll stop now. // Ok, we'll stop now.
else if (player->kartstuff[k_drift] == 0 || !onground) else if (player->kartstuff[k_drift] == 0 || !onground)
@@ -2417,15 +2402,18 @@ static void P_MovePlayer(player_t *player)
{ {
mobj_t *water = P_SpawnMobj(player->mo->x, player->mo->y, mobj_t *water = P_SpawnMobj(player->mo->x, player->mo->y,
((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[MT_SPLISH].height, player->mo->scale) : player->mo->watertop), MT_SPLISH); ((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[MT_SPLISH].height, player->mo->scale) : player->mo->watertop), MT_SPLISH);
if (player->mo->eflags & MFE_GOOWATER) if (player->mo->eflags & MFE_GOOWATER)
S_StartSound(water, sfx_ghit); S_StartSound(water, sfx_ghit);
else else
S_StartSound(water, sfx_wslap); S_StartSound(water, sfx_wslap);
if (player->mo->eflags & MFE_VERTICALFLIP) if (player->mo->eflags & MFE_VERTICALFLIP)
{ {
water->flags2 |= MF2_OBJECTFLIP; water->flags2 |= MF2_OBJECTFLIP;
water->eflags |= MFE_VERTICALFLIP; water->eflags |= MFE_VERTICALFLIP;
} }
water->destscale = player->mo->scale; water->destscale = player->mo->scale;
P_SetScale(water, player->mo->scale); P_SetScale(water, player->mo->scale);
} }
@@ -2474,9 +2462,10 @@ static void P_MovePlayer(player_t *player)
const fixed_t runnyspeed = 20*FRACUNIT; const fixed_t runnyspeed = 20*FRACUNIT;
speed = R_PointToDist2(player->rmomx, player->rmomy, 0, 0); speed = R_PointToDist2(player->rmomx, player->rmomy, 0, 0);
const fixed_t kartspd = K_GetKartSpeed(player, false);
if (speed > K_GetKartSpeed(player, false)-(5<<FRACBITS)) if (speed > kartspd-(5<<FRACBITS))
speed = K_GetKartSpeed(player, false)-(5<<FRACBITS); speed = kartspd-(5<<FRACBITS);
if (speed >= runnyspeed) if (speed >= runnyspeed)
player->fovadd = speed-runnyspeed; player->fovadd = speed-runnyspeed;
@@ -2753,16 +2742,16 @@ boolean P_LookForEnemies(player_t *player)
|| ((mo->z+mo->height < player->mo->z+player->mo->height-FixedMul(MAXSTEPMOVE, mapobjectscale)) && (player->mo->eflags & MFE_VERTICALFLIP))) // Reverse gravity check - Flame. || ((mo->z+mo->height < player->mo->z+player->mo->height-FixedMul(MAXSTEPMOVE, mapobjectscale)) && (player->mo->eflags & MFE_VERTICALFLIP))) // Reverse gravity check - Flame.
continue; // Don't home upwards! continue; // Don't home upwards!
if (P_AproxDistance(P_AproxDistance(player->mo->x-mo->x, player->mo->y-mo->y), const fixed_t modist = P_AproxDistance(P_AproxDistance(player->mo->x-mo->x, player->mo->y-mo->y), player->mo->z-mo->z);
player->mo->z-mo->z) > FixedMul(RING_DIST, player->mo->scale))
if (modist > FixedMul(RING_DIST, player->mo->scale))
continue; // out of range continue; // out of range
if (UNLIKELY((twodlevel || player->mo->flags2 & MF2_TWOD) if (UNLIKELY((twodlevel || player->mo->flags2 & MF2_TWOD)
&& abs(player->mo->y-mo->y) > player->mo->radius)) && abs(player->mo->y-mo->y) > player->mo->radius))
continue; // not in your 2d plane continue; // not in your 2d plane
if (closestmo && P_AproxDistance(P_AproxDistance(player->mo->x-mo->x, player->mo->y-mo->y), if (closestmo && modist > P_AproxDistance(P_AproxDistance(player->mo->x-closestmo->x,
player->mo->z-mo->z) > P_AproxDistance(P_AproxDistance(player->mo->x-closestmo->x,
player->mo->y-closestmo->y), player->mo->z-closestmo->z)) player->mo->y-closestmo->y), player->mo->z-closestmo->z))
continue; continue;
@@ -3126,19 +3115,16 @@ void P_ToggleDemoCamera(UINT8 viewnum)
return; return;
} }
if (!cam->freecam) // toggle on if (!cam->freecam) // toggle on
{ {
cam->freecam = true; cam->freecam = true;
cam->button_a_held = 2; cam->button_a_held = 2;
cam->reset_aiming = true; cam->reset_aiming = true;
// get rid of some hud elements // get rid of some hud elements
if (displayplayers[0] != consoleplayer) displayplayers[0] = consoleplayer;
{
displayplayers[0] = consoleplayer;
}
} }
else // toggle off else // toggle off
{ {
cam->freecam = false; cam->freecam = false;
G_FixCamera(viewnum+1); G_FixCamera(viewnum+1);
@@ -3169,8 +3155,8 @@ static ticcmd_t *P_CameraCmd(camera_t *cam, UINT8 num)
cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE); cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
cmd->aiming = G_ClipAimingPitch(&laim); cmd->aiming = G_ClipAimingPitch(&laim);
const boolean analogjoystickmove = cv_usejoystick[num].value && !Joystick[num].bGamepadStyle; const boolean analogjoystickmove = cv_usejoystick[num].value && !DigitalGamepadStyle(num);
const boolean gamepadjoystickmove = cv_usejoystick[num].value && Joystick[num].bGamepadStyle; const boolean gamepadjoystickmove = cv_usejoystick[num].value && DigitalGamepadStyle(num);
usejoystick = (analogjoystickmove || gamepadjoystickmove); usejoystick = (analogjoystickmove || gamepadjoystickmove);
@@ -3504,8 +3490,6 @@ void P_ResetCamera(player_t *player, camera_t *thiscam)
} }
} }
thiscam->relativex = 0;
thiscam->subsector = R_PointInSubsectorFast(thiscam->x, thiscam->y); thiscam->subsector = R_PointInSubsectorFast(thiscam->x, thiscam->y);
thiscam->radius = 20*FRACUNIT; thiscam->radius = 20*FRACUNIT;
@@ -3998,9 +3982,12 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
{ {
fixed_t panmax = (dist/5); fixed_t panmax = (dist/5);
const INT32 sparkval = K_GetKartDriftSparkValue(player); const INT32 sparkval = K_GetKartDriftSparkValue(player);
pan = FixedDiv(FixedMul(min((fixed_t)player->kartstuff[k_driftcharge], sparkval), panmax), sparkval); pan = FixedDiv(FixedMul(min((fixed_t)player->kartstuff[k_driftcharge], sparkval), panmax), sparkval);
if (pan > panmax) if (pan > panmax)
pan = panmax; pan = panmax;
if (player->kartstuff[k_drift] < 0) if (player->kartstuff[k_drift] < 0)
pan *= -1; pan *= -1;
} }
@@ -4052,7 +4039,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
if (timeover) if (timeover)
thiscam->angle = angle; thiscam->angle = angle;
else if (!camstill && !resetcalled && !paused && timeover != 1) else if (!camstill && !resetcalled && !paused)
thiscam->angle = R_PointToAngle2(thiscam->x, thiscam->y, viewpointx, viewpointy); thiscam->angle = R_PointToAngle2(thiscam->x, thiscam->y, viewpointx, viewpointy);
if (timeover == 1) if (timeover == 1)
@@ -4175,10 +4162,12 @@ void P_ResetLocalCamAiming(player_t *player)
boolean P_SpectatorJoinGame(player_t *player) boolean P_SpectatorJoinGame(player_t *player)
{ {
const boolean islocalplayer = P_IsLocalPlayer(player);
// Team changing isn't allowed. // Team changing isn't allowed.
if (!cv_allowteamchange.value) if (!cv_allowteamchange.value)
{ {
if (P_IsLocalPlayer(player)) if (islocalplayer)
CONS_Printf(M_GetText("Server does not allow team change.\n")); CONS_Printf(M_GetText("Server does not allow team change.\n"));
} }
// Team changing in Team Match and CTF // Team changing in Team Match and CTF
@@ -4226,7 +4215,7 @@ boolean P_SpectatorJoinGame(player_t *player)
P_ResetLocalCamAiming(player); P_ResetLocalCamAiming(player);
//Reset away view //Reset away view
if (P_IsLocalPlayer(player) && displayplayers[0] != consoleplayer) if (islocalplayer && displayplayers[0] != consoleplayer)
displayplayers[0] = consoleplayer; displayplayers[0] = consoleplayer;
if (changeto == 1) if (changeto == 1)
@@ -4253,7 +4242,7 @@ boolean P_SpectatorJoinGame(player_t *player)
P_ResetLocalCamAiming(player); P_ResetLocalCamAiming(player);
//Reset away view //Reset away view
if (P_IsLocalPlayer(player) && displayplayers[0] != consoleplayer) if (islocalplayer && displayplayers[0] != consoleplayer)
displayplayers[0] = consoleplayer; displayplayers[0] = consoleplayer;
HU_AddChatText(va(M_GetText("\x82*%s entered the game."), player_names[player-players]), false); HU_AddChatText(va(M_GetText("\x82*%s entered the game."), player_names[player-players]), false);
@@ -4584,7 +4573,7 @@ void P_PlayerThink(player_t *player)
} }
#ifdef SEENAMES #ifdef SEENAMES
if (netgame && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)) && !splitscreen) if (netgame && !splitscreen && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)))
{ {
seenplayer = NULL; seenplayer = NULL;
@@ -4597,6 +4586,7 @@ void P_PlayerThink(player_t *player)
{ {
short int i; short int i;
mo->flags |= MF_NOCLIPHEIGHT; mo->flags |= MF_NOCLIPHEIGHT;
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
{ {
// Debug drawing // Debug drawing
@@ -4775,6 +4765,7 @@ void P_PlayerThink(player_t *player)
player->mo->flags2 |= MF2_SHADOW; player->mo->flags2 |= MF2_SHADOW;
else else
player->mo->flags2 &= ~MF2_SHADOW; player->mo->flags2 &= ~MF2_SHADOW;
P_DeathThink(player); P_DeathThink(player);
LUA_HookPlayer(player, HOOK(PlayerThink)); LUA_HookPlayer(player, HOOK(PlayerThink));
return; return;
+25 -11
View File
@@ -221,8 +221,9 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorheight = s->floorheight; tempsec->floorheight = s->floorheight;
tempsec->ceilingheight = s->ceilingheight; tempsec->ceilingheight = s->ceilingheight;
if ((underwater && (tempsec-> floorheight = sec->floorheight, if ((underwater && (tempsec->floorheight = sec->floorheight,
tempsec->ceilingheight = s->floorheight - 1, !back)) || viewz <= s->floorheight) tempsec->ceilingheight = s->floorheight - 1, !back)) ||
viewz <= s->floorheight)
{ // head-below-floor hack { // head-below-floor hack
tempsec->floorpic = s->floorpic; tempsec->floorpic = s->floorpic;
tempsec->floor_xoffs = s->floor_xoffs; tempsec->floor_xoffs = s->floor_xoffs;
@@ -258,8 +259,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
*ceilinglightlevel = s->ceilinglightsec == -1 ? s->lightlevel *ceilinglightlevel = s->ceilinglightsec == -1 ? s->lightlevel
: sectors[s->ceilinglightsec].lightlevel; : sectors[s->ceilinglightsec].lightlevel;
} }
else if (heightsec != -1 && viewz >= sectors[heightsec].ceilingheight else if (heightsec != -1 && viewz >= sectors[heightsec].ceilingheight &&
&& sec->ceilingheight > s->ceilingheight) sec->ceilingheight > s->ceilingheight)
{ // Above-ceiling hack { // Above-ceiling hack
tempsec->ceilingheight = s->ceilingheight; tempsec->ceilingheight = s->ceilingheight;
tempsec->floorheight = s->ceilingheight + 1; tempsec->floorheight = s->ceilingheight + 1;
@@ -296,7 +297,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
*ceilinglightlevel = s->ceilinglightsec == -1 ? s->lightlevel : *ceilinglightlevel = s->ceilinglightsec == -1 ? s->lightlevel :
sectors[s->ceilinglightsec].lightlevel; sectors[s->ceilinglightsec].lightlevel;
} }
sec = tempsec;
sec = tempsec; // Use other sector
} }
return sec; return sec;
@@ -318,13 +320,20 @@ static void R_AddLine(seg_t *line)
INT32 x1, x2; INT32 x1, x2;
angle_t angle1, angle2, span, tspan; angle_t angle1, angle2, span, tspan;
static sector_t tempsec; static sector_t tempsec;
boolean bothfloorssky = false; boolean bothfloorssky = false;
fixed_t v1x, v1y, v2x, v2y; // the seg's vertexes as fixed_t
g_portal = NULL; g_portal = NULL;
v1x = line->v1->x;
v1y = line->v1->y;
v2x = line->v2->x;
v2y = line->v2->y;
// big room fix // big room fix
angle1 = R_PointToAngle64(line->v1->x, line->v1->y); angle1 = R_PointToAngle64(v1x, v1y);
angle2 = R_PointToAngle64(line->v2->x, line->v2->y); angle2 = R_PointToAngle64(v2x, v2y);
curline = line; curline = line;
@@ -517,6 +526,7 @@ static boolean R_CheckBBox(const fixed_t *bspcoord)
angle_t angle1, angle2; angle_t angle1, angle2;
INT32 sx1, sx2; INT32 sx1, sx2;
const INT32* check; const INT32* check;
fixed_t x1, y1, x2, y2;
// Find the corners of the box // Find the corners of the box
// that define the edges from current viewpoint. // that define the edges from current viewpoint.
@@ -530,9 +540,14 @@ static boolean R_CheckBBox(const fixed_t *bspcoord)
check = checkcoord[boxpos]; check = checkcoord[boxpos];
x1 = bspcoord[check[0]];
y1 = bspcoord[check[1]];
x2 = bspcoord[check[2]];
y2 = bspcoord[check[3]];
// big room fix // big room fix
angle1 = R_PointToAngle64(bspcoord[check[0]], bspcoord[check[1]]) - viewangle; angle1 = R_PointToAngle64(x1, y1) - viewangle;
angle2 = R_PointToAngle64(bspcoord[check[2]], bspcoord[check[3]]) - viewangle; angle2 = R_PointToAngle64(x2, y2) - viewangle;
// cph - replaced old code, which was unclear and badly commented // cph - replaced old code, which was unclear and badly commented
// Much more efficient code now // Much more efficient code now
@@ -991,7 +1006,6 @@ static void R_Subsector(size_t num)
visffloor[numffloors].height = polysec->floorheight; visffloor[numffloors].height = polysec->floorheight;
visffloor[numffloors].polyobj = po; visffloor[numffloors].polyobj = po;
visffloor[numffloors].slope = NULL; visffloor[numffloors].slope = NULL;
// visffloor[numffloors].ffloor = rover;
po->visplane = visffloor[numffloors].plane; po->visplane = visffloor[numffloors].plane;
numffloors++; numffloors++;
} }
+4 -46
View File
@@ -37,44 +37,6 @@
// Not sure if this is necessary, but it was in w_wad.c, so I'm putting it here too -Shadow Hog // Not sure if this is necessary, but it was in w_wad.c, so I'm putting it here too -Shadow Hog
#include <errno.h> #include <errno.h>
//
// Texture definition.
// Each texture is composed of one or more patches,
// with patches being lumps stored in the WAD.
// The lumps are referenced by number, and patched
// into the rectangular texture space using origin
// and possibly other attributes.
//
typedef struct
{
INT16 originx, originy;
INT16 patch, stepdir, colormap;
} ATTRPACK mappatch_t;
//
// Texture definition.
// An SRB2 wall texture is a list of patches
// which are to be combined in a predefined order.
//
typedef struct
{
char name[8];
INT32 masked;
INT16 width;
INT16 height;
INT32 columndirectory; // FIXTHIS: OBSOLETE
INT16 patchcount;
mappatch_t patches[1];
} ATTRPACK maptexture_t;
// Store lists of lumps for F_START/F_END etc.
typedef struct
{
UINT16 wadfile;
UINT16 firstlump;
size_t numlumps;
} lumplist_t;
// //
// Graphics. // Graphics.
// SRB2 graphics for walls and sprites // SRB2 graphics for walls and sprites
@@ -836,11 +798,7 @@ static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
} }
else else
{ {
if (patchName != NULL) Z_Free(patchName);
{
Z_Free(patchName);
}
patchName = (char *)Z_Malloc((texturesTokenLength+1)*sizeof(char),PU_STATIC,NULL); patchName = (char *)Z_Malloc((texturesTokenLength+1)*sizeof(char),PU_STATIC,NULL);
memcpy(patchName,texturesToken,texturesTokenLength*sizeof(char)); memcpy(patchName,texturesToken,texturesTokenLength*sizeof(char));
patchName[texturesTokenLength] = '\0'; patchName[texturesTokenLength] = '\0';
@@ -1366,7 +1324,7 @@ void R_ReInitColormaps(UINT16 num, lumpnum_t newencoremap)
colormap_p = colormap_p2 = colormaps; colormap_p = colormap_p2 = colormaps;
colormap_p += COLORMAP_REMAPOFFSET; colormap_p += COLORMAP_REMAPOFFSET;
for (p = 0; p < 32; p++) for (p = 0; p < LIGHTLEVELS; p++)
{ {
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
@@ -1588,7 +1546,7 @@ INT32 R_CreateColormap(char *p1, char *p2, char *p3)
// Calculate the palette index for each palette index, for each light level // Calculate the palette index for each palette index, for each light level
// (as well as the two unused colormap lines we inherited from Doom) // (as well as the two unused colormap lines we inherited from Doom)
for (p = 0; p < 32; p++) for (p = 0; p < LIGHTLEVELS; p++)
{ {
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
@@ -1622,7 +1580,7 @@ INT32 R_CreateColormap(char *p1, char *p2, char *p3)
{ {
lighttable_t *colormap_p2 = extra_colormaps[mapnum].colormap; lighttable_t *colormap_p2 = extra_colormaps[mapnum].colormap;
for (p = 0; p < 32; p++) for (p = 0; p < LIGHTLEVELS; p++)
{ {
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
-3
View File
@@ -45,9 +45,6 @@ enum
TEXTURETYPE_COMPOSITE, TEXTURETYPE_COMPOSITE,
}; };
// A maptexturedef_t describes a rectangular texture,
// which is composed of one or more mappatch_t structures
// that arrange graphic patches.
typedef struct typedef struct
{ {
// Keep name for switch changing, etc. // Keep name for switch changing, etc.
+11 -10
View File
@@ -430,7 +430,7 @@ typedef struct line_s
INT16 tag; INT16 tag;
// Visual appearance: sidedefs. // Visual appearance: sidedefs.
UINT16 sidenum[2]; // sidenum[1] will be 0xffff if one-sided UINT16 sidenum[2]; // sidenum[1] will be NO_INDEX if one-sided
fixed_t alpha; // translucency fixed_t alpha; // translucency
UINT8 blendmode; // blendmode UINT8 blendmode; // blendmode
@@ -531,11 +531,10 @@ typedef struct seg_s
vertex_t *v1; vertex_t *v1;
vertex_t *v2; vertex_t *v2;
INT32 side; #ifdef HWRENDER
floatvertex_t fv1; // v1 in floats - precalculated
fixed_t offset; floatvertex_t fv2; // v2 in floats - precalculated
#endif
angle_t angle;
side_t *sidedef; side_t *sidedef;
line_t *linedef; line_t *linedef;
@@ -545,11 +544,13 @@ typedef struct seg_s
sector_t *frontsector; sector_t *frontsector;
sector_t *backsector; sector_t *backsector;
INT32 side;
fixed_t length; // precalculated seg length fixed_t length; // precalculated seg length
#ifdef HWRENDER fixed_t offset;
floatvertex_t fv1; // v1 in floats - precalculated
floatvertex_t fv2; // v2 in floats - precalculated angle_t angle;
#endif
polyobj_t *polyseg; polyobj_t *polyseg;
// Fake contrast calculated on level load // Fake contrast calculated on level load
+17 -11
View File
@@ -400,7 +400,7 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
case TC_ALLWHITE: skintableindex = ALLWHITE_TT_CACHE_INDEX; break; case TC_ALLWHITE: skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
case TC_RAINBOW: skintableindex = RAINBOW_TT_CACHE_INDEX; break; case TC_RAINBOW: skintableindex = RAINBOW_TT_CACHE_INDEX; break;
case TC_BLINK: skintableindex = BLINK_TT_CACHE_INDEX; break; case TC_BLINK: skintableindex = BLINK_TT_CACHE_INDEX; break;
default: skintableindex = skinnum; break; default: skintableindex = skinnum; break;
} }
} }
@@ -419,7 +419,7 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
// Generate the colormap if necessary // Generate the colormap if necessary
if (!ret) if (!ret)
{ {
ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, (flags & GTC_CACHE) ? PU_LEVEL : PU_STATIC, NULL)); ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, PU_STATIC, NULL));
K_GenerateKartColormap(ret, skinnum, color, local); //R_GenerateTranslationColormap(ret, skinnum, color); // SRB2kart K_GenerateKartColormap(ret, skinnum, color, local); //R_GenerateTranslationColormap(ret, skinnum, color); // SRB2kart
// Cache the colormap if desired // Cache the colormap if desired
@@ -487,6 +487,10 @@ patch_t* R_GetSkinFaceMini(player_t* ply)
\return void \return void
*/ */
/* There seems to be no reason to free cached colormaps tho? Not like they can change :ChonkBunckle: */
/*
void R_FlushTranslationColormapCache(void) void R_FlushTranslationColormapCache(void)
{ {
INT32 i; INT32 i;
@@ -499,6 +503,7 @@ void R_FlushTranslationColormapCache(void)
if (localtranslationtablecache[i]) if (localtranslationtablecache[i])
memset(localtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**)); memset(localtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
} }
*/
// ========================================================================== // ==========================================================================
// COMMON DRAWER FOR 8 AND 16 BIT COLOR MODES // COMMON DRAWER FOR 8 AND 16 BIT COLOR MODES
@@ -510,8 +515,6 @@ void R_FlushTranslationColormapCache(void)
// in reality, the few routines that can work for either mode, are // in reality, the few routines that can work for either mode, are
// put here // put here
enum columncontext_e columncontext = COLUMNCONTEXT_DIRECT;
enum ColumnFlushType enum ColumnFlushType
{ {
FLUSH_NONE = 0x0000, FLUSH_NONE = 0x0000,
@@ -529,9 +532,12 @@ typedef struct drawcolumndata_temp_s
// e6y: resolution limitation is removed // e6y: resolution limitation is removed
UINT8 *buf; UINT8 *buf;
INT32 startx; INT32 startx;
ColumnFlushType type;
INT32 commontop, commonbot; ColumnFlushType type;
INT32 commontop, commonbot;
UINT8 *transmap; UINT8 *transmap;
// SoM 7-28-04: Fix the fuzz problem. // SoM 7-28-04: Fix the fuzz problem.
UINT8 *translation; UINT8 *translation;
@@ -559,8 +565,8 @@ FUNCNORETURN static ATTRNORETURN void R_QuadFlushError(void)
} }
static void (*R_FlushWholeColumns)(void) = R_FlushWholeError; static void (*R_FlushWholeColumns)(void) = R_FlushWholeError;
static void (*R_FlushHTColumns)(void) = R_FlushHTError; static void (*R_FlushHTColumns)(void) = R_FlushHTError;
static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; static void (*R_FlushQuadColumn)(void) = R_QuadFlushError;
static void R_FlushColumns(void) static void R_FlushColumns(void)
{ {
@@ -592,8 +598,8 @@ void R_ResetColumnBuffer(void)
temp_dc.type = FLUSH_NONE; temp_dc.type = FLUSH_NONE;
R_FlushWholeColumns = R_FlushWholeError; R_FlushWholeColumns = R_FlushWholeError;
R_FlushHTColumns = R_FlushHTError; R_FlushHTColumns = R_FlushHTError;
R_FlushQuadColumn = R_QuadFlushError; R_FlushQuadColumn = R_QuadFlushError;
} }
/** \brief The R_InitViewBuffer function /** \brief The R_InitViewBuffer function
+2 -1
View File
@@ -105,7 +105,6 @@ enum columncontext_e
COLUMNCONTEXT_FLUSH, COLUMNCONTEXT_FLUSH,
}; };
extern enum columncontext_e columncontext;
void R_SetColumnContext(enum columncontext_e _columncontext); void R_SetColumnContext(enum columncontext_e _columncontext);
void R_ResetColumnBuffer(void); void R_ResetColumnBuffer(void);
@@ -124,6 +123,8 @@ enum
COLDRAWFUNC_TRANSTRANS, COLDRAWFUNC_TRANSTRANS,
COLDRAWFUNC_TWOSMULTIPATCH, COLDRAWFUNC_TWOSMULTIPATCH,
COLDRAWFUNC_TWOSMULTIPATCHTRANS, COLDRAWFUNC_TWOSMULTIPATCHTRANS,
COLDRAWFUNC_TWOSMULTIPATCH_DIRECT,
COLDRAWFUNC_TWOSMULTIPATCHTRANS_DIRECT,
COLDRAWFUNC_FOG, COLDRAWFUNC_FOG,
COLDRAWFUNC_MAX COLDRAWFUNC_MAX
+33 -33
View File
@@ -204,7 +204,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
intptr_t frac; intptr_t frac;
// Looks familiar. // Looks familiar.
const intptr_t fracstep = dc->iscale; const intptr_t fracstep = dc->iscale;
const intptr_t heightmask = dc->sourcelength-1; // CPhipps - specify type intptr_t heightmask = dc->sourcelength-1; // CPhipps - specify type
constexpr INT32 npow2min = -1; constexpr INT32 npow2min = -1;
const INT32 npow2max = dc->sourcelength; const INT32 npow2max = dc->sourcelength;
@@ -237,10 +237,10 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
// Determine scaling, which is the only mapping to be done. // Determine scaling, which is the only mapping to be done.
frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep)); frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep));
switch (heightmask) switch (dc->sourcelength)
{ {
case 255: case 256:
case 127: case 128:
{ {
while (count--) while (count--)
{ {
@@ -251,7 +251,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
} }
} }
break; break;
case npow2min: case 0:
{ {
if (frac < 0) if (frac < 0)
// adjust in case we underread // adjust in case we underread
@@ -269,42 +269,22 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
break; break;
default: default:
{ {
if (!(dc->sourcelength & heightmask)) // power of 2 -- killough if (dc->sourcelength & heightmask) // not a power of 2 -- killough
{ {
while ((count -= 2) >= 0) // texture height is a power of 2 -- killough heightmask = dc->texheight << FRACBITS;
{
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
dest += stride;
frac += fracstep;
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
dest += stride;
frac += fracstep;
}
if (count & 1)
{
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
}
}
else
{
const intptr_t fixed_heightmask = dc->texheight << FRACBITS;
if (frac < 0) if (frac < 0)
{ {
while ((frac += fixed_heightmask) < 0) while ((frac += heightmask) < 0)
{ {
; ;
} }
} }
else else
{ {
while (frac >= fixed_heightmask) while (frac >= heightmask)
{ {
frac -= fixed_heightmask; frac -= heightmask;
} }
} }
@@ -324,7 +304,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
// Avoid overflow. // Avoid overflow.
if (fracstep > 0x7FFFFFFF - frac) if (fracstep > 0x7FFFFFFF - frac)
{ {
frac += fracstep - fixed_heightmask; frac += fracstep - heightmask;
} }
else else
#endif #endif
@@ -332,13 +312,33 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
frac += fracstep; frac += fracstep;
} }
while (frac >= fixed_heightmask) while (frac >= heightmask)
{ {
frac -= fixed_heightmask; frac -= heightmask;
} }
} }
while (--count); while (--count);
} }
else
{
while ((count -= 2) >= 0) // texture height is a power of 2 -- killough
{
*dest = R_DrawColumnPixel<Type>(dc, dest, ((frac>>FRACBITS) & heightmask), source, colormap);
dest += stride;
frac += fracstep;
*dest = R_DrawColumnPixel<Type>(dc, dest, ((frac>>FRACBITS) & heightmask), source, colormap);
dest += stride;
frac += fracstep;
}
if (count & 1)
{
*dest = R_DrawColumnPixel<Type>(dc, dest, ((frac>>FRACBITS) & heightmask), source, colormap);
}
}
} }
break; break;
} }
+4 -4
View File
@@ -387,10 +387,10 @@ void R_InterpolatePrecipMobjState(precipmobj_t *mobj, fixed_t frac, interpmobjst
return; return;
} }
out->x = R_LerpFixed(mobj->old_x, mobj->x, frac); out->x = R_LerpFixed(mobj->old_x, mobj->x, frac);
out->y = R_LerpFixed(mobj->old_y, mobj->y, frac); out->y = R_LerpFixed(mobj->old_y, mobj->y, frac);
out->z = R_LerpFixed(mobj->old_z, mobj->z, frac); out->z = R_LerpFixed(mobj->old_z, mobj->z, frac);
out->scale = mapobjectscale; out->scale = mapobjectscale;
} }
static levelinterpolator_t *CreateInterpolator(levelinterpolator_type_e type, thinker_t *thinker) static levelinterpolator_t *CreateInterpolator(levelinterpolator_type_e type, thinker_t *thinker)
+6 -6
View File
@@ -342,14 +342,14 @@ angle_t R_PointToAngle64(INT64 x, INT64 y)
return (y -= viewy, (x -= viewx) || y) ? return (y -= viewy, (x -= viewx) || y) ?
x >= 0 ? x >= 0 ?
y >= 0 ? y >= 0 ?
(x > y) ? tantoangle[SlopeDivEx(y,x)] : // octant 0 (x > y) ? tantoangle[SlopeDivEx(y,x)] : // octant 0
ANGLE_90-tantoangle[SlopeDivEx(x,y)] : // octant 1 ANGLE_90-tantoangle[SlopeDivEx(x,y)] : // octant 1
x > (y = -y) ? 0-tantoangle[SlopeDivEx(y,x)] : // octant 8 x > (y = -y) ? 0-tantoangle[SlopeDivEx(y,x)] : // octant 8
ANGLE_270+tantoangle[SlopeDivEx(x,y)] : // octant 7 ANGLE_270+tantoangle[SlopeDivEx(x,y)] : // octant 7
y >= 0 ? (x = -x) > y ? ANGLE_180-tantoangle[SlopeDivEx(y,x)] : // octant 3 y >= 0 ? (x = -x) > y ? ANGLE_180-tantoangle[SlopeDivEx(y,x)] : // octant 3
ANGLE_90 + tantoangle[SlopeDivEx(x,y)] : // octant 2 ANGLE_90 + tantoangle[SlopeDivEx(x,y)] : // octant 2
(x = -x) > (y = -y) ? ANGLE_180+tantoangle[SlopeDivEx(y,x)] : // octant 4 (x = -x) > (y = -y) ? ANGLE_180+tantoangle[SlopeDivEx(y,x)] : // octant 4
ANGLE_270-tantoangle[SlopeDivEx(x,y)] : // octant 5 ANGLE_270-tantoangle[SlopeDivEx(x,y)] : // octant 5
0; 0;
} }
+3 -2
View File
@@ -161,7 +161,7 @@ static void R_ParseSpriteInfo(boolean spr2)
if (i == NUMSPRITES) if (i == NUMSPRITES)
I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName); I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName);
if (!memcmp(newSpriteName,sprnames[i], 4)) if (!memcmp(newSpriteName, sprnames[i], 4))
{ {
sprnum = static_cast<spritenum_t>(i); sprnum = static_cast<spritenum_t>(i);
break; break;
@@ -289,7 +289,7 @@ void R_ParseSPRTINFOLump(UINT16 wadNum, UINT16 lumpNum)
sprinfoLumpLength = W_LumpLengthPwad(wadNum, lumpNum); sprinfoLumpLength = W_LumpLengthPwad(wadNum, lumpNum);
sprinfoText = (char *)Z_Malloc((sprinfoLumpLength+1)*sizeof(char),PU_STATIC,NULL); sprinfoText = (char *)Z_Malloc((sprinfoLumpLength+1)*sizeof(char),PU_STATIC,NULL);
// Now move the contents of the lump into this new location. // Now move the contents of the lump into this new location.
memmove(sprinfoText,sprinfoLump,sprinfoLumpLength); memmove(sprinfoText, sprinfoLump, sprinfoLumpLength);
// Make damn well sure the last character in our new memory location is \0. // Make damn well sure the last character in our new memory location is \0.
sprinfoText[sprinfoLumpLength] = '\0'; sprinfoText[sprinfoLumpLength] = '\0';
// Finally, free up the memory from the first data load, because we really // Finally, free up the memory from the first data load, because we really
@@ -443,6 +443,7 @@ void *Patch_AllocateHardwarePatch(patch_t *patch)
GLPatch_t *glPatch = static_cast<GLPatch_t*>(Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, &patch->hardware)); GLPatch_t *glPatch = static_cast<GLPatch_t*>(Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, &patch->hardware));
glPatch->mipmap = static_cast<GLMipmap_t*>(Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, &glPatch->mipmap)); glPatch->mipmap = static_cast<GLMipmap_t*>(Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, &glPatch->mipmap));
} }
return (void *)(patch->hardware); return (void *)(patch->hardware);
} }
+1 -4
View File
@@ -1282,10 +1282,7 @@ void R_DrawSinglePlane(drawspandata_t* ds, visplane_t *pl, boolean allow_paralle
else else
{ {
// Don't mess with angle on slopes! We'll handle this ourselves later // Don't mess with angle on slopes! We'll handle this ourselves later
if (viewangle != pl->viewangle + pl->plangle) viewangle = pl->viewangle + pl->plangle;
{
viewangle = pl->viewangle + pl->plangle;
}
ds->planeheight = abs(pl->height - pl->viewz); ds->planeheight = abs(pl->height - pl->viewz);
ds->planezlight = zlight[light]; ds->planezlight = zlight[light];
+66 -3
View File
@@ -16,6 +16,7 @@
#include "r_sky.h" #include "r_sky.h"
#include <algorithm> #include <algorithm>
#include <vector>
#include "r_portal.h" #include "r_portal.h"
#include "r_splats.h" #include "r_splats.h"
@@ -1166,6 +1167,37 @@ static inline void R_ExpandPlaneY(visplane_t *pl, INT32 x, INT16 top, INT16 bott
// CALLED: CORE LOOPING ROUTINE. // CALLED: CORE LOOPING ROUTINE.
// //
static std::vector<UINT8> holecol(256);
// used for R_DrawWallColumn
// convert "holey" columns into contigous columns
// filled with cyan in place of holes
static UINT8 *R_GetHoleColumn(drawcolumndata_t* dc)
{
column_t *col = (column_t *)(dc->source - 3);
const INT32 texheight = dc->texheight;
holecol.resize(texheight);
// fill in everything with cyan so we can skip it
memset(holecol.data(), TRANSPARENTPIXEL, texheight);
// shamelessly copy pasted from R_GenerateTexture
INT32 topdelta, prevdelta = -1;
while (col->topdelta != 0xff)
{
topdelta = col->topdelta;
if (topdelta <= prevdelta)
topdelta += prevdelta;
prevdelta = topdelta;
memcpy(holecol.data() + topdelta, (UINT8*)col + 4, col->length);
col = (column_t *)((UINT8*)col + col->length + 4);
}
return holecol.data();
}
static void R_DrawWallColumn(drawcolumndata_t* dc, INT32 yl, INT32 yh, fixed_t mid, fixed_t texturecolumn, INT32 texture, boolean remap) static void R_DrawWallColumn(drawcolumndata_t* dc, INT32 yl, INT32 yh, fixed_t mid, fixed_t texturecolumn, INT32 texture, boolean remap)
{ {
const INT32 itexturecolumn = texturecolumn >> FRACBITS; const INT32 itexturecolumn = texturecolumn >> FRACBITS;
@@ -1175,13 +1207,35 @@ static void R_DrawWallColumn(drawcolumndata_t* dc, INT32 yl, INT32 yh, fixed_t m
dc->source = R_GetColumn(texture, itexturecolumn); dc->source = R_GetColumn(texture, itexturecolumn);
dc->texheight = textureheight[texture] >> FRACBITS; dc->texheight = textureheight[texture] >> FRACBITS;
dc->sourcelength = dc->texheight; dc->sourcelength = dc->texheight;
R_SetColumnFunc(colfunctype); R_SetColumnFunc(colfunctype);
coldrawfunc_t* colfunccopy = colfunc; coldrawfunc_t* colfunccopy = colfunc;
if (textures[texture]->holes)
{
dc->source = R_GetHoleColumn(dc);
if (cv_softcyancut.value)
{
// need to use multipatch drawers to cut cyan pixels
if (R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == true)
{
colfunccopy = colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS_DIRECT];
}
else
{
colfunccopy = colfuncs[COLDRAWFUNC_TWOSMULTIPATCH_DIRECT];
}
}
}
drawcolumndata_t dc_copy = *dc; drawcolumndata_t dc_copy = *dc;
if (remap) if (remap)
{ {
dc_copy.colormap += COLORMAP_REMAPOFFSET; dc_copy.colormap += COLORMAP_REMAPOFFSET;
} }
colfunccopy(const_cast<drawcolumndata_t*>(&dc_copy)); colfunccopy(const_cast<drawcolumndata_t*>(&dc_copy));
} }
@@ -1222,6 +1276,15 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
if (yl < top) if (yl < top)
yl = top; yl = top;
// insanely shitty hack to fix flickering on some maps
// for god knows why, on secret slide the renderer assumes some double sided linedefs have insanely tall walls
// since such tall walls are effectively nonsense in any case
// just skip them
if (yl > FRACUNIT*3)
{
continue;
}
if (markceiling) if (markceiling)
{ {
bottom = yl > floorclip[rw_x] ? floorclip[rw_x] : yl; bottom = yl > floorclip[rw_x] ? floorclip[rw_x] : yl;
@@ -1381,7 +1444,7 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
// calculate lighting // calculate lighting
pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT; pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
if (pindex >= MAXLIGHTSCALE) if (pindex >= MAXLIGHTSCALE)
pindex = MAXLIGHTSCALE-1; pindex = MAXLIGHTSCALE-1;
dc->colormap = walllights[pindex]; dc->colormap = walllights[pindex];
@@ -1416,7 +1479,7 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT; pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
if (pindex >= MAXLIGHTSCALE) if (pindex >= MAXLIGHTSCALE)
pindex = MAXLIGHTSCALE-1; pindex = MAXLIGHTSCALE-1;
if (dc->lightlist[i].extra_colormap) if (dc->lightlist[i].extra_colormap)
@@ -2141,7 +2204,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
topremap = (encoremap && !(curline->linedef->flags & ML_TFERLINE)); topremap = (encoremap && !(curline->linedef->flags & ML_TFERLINE));
if ((linedef->flags & (ML_DONTPEGTOP) && (linedef->flags & ML_DONTPEGBOTTOM)) if ((linedef->flags & (ML_DONTPEGTOP) && (linedef->flags & ML_DONTPEGBOTTOM))
&& linedef->sidenum[1] != 0xffff) && linedef->sidenum[1] != NO_INDEX)
{ {
// Special case... use offsets from 2nd side but only if it has a texture. // Special case... use offsets from 2nd side but only if it has a texture.
side_t *def = &sides[linedef->sidenum[1]]; side_t *def = &sides[linedef->sidenum[1]];
+2 -2
View File
@@ -712,7 +712,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
// skip to end of this skin's frames // skip to end of this skin's frames
lastlump = lump; lastlump = lump;
while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname,4)==0) while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname, 4) == 0)
lastlump++; lastlump++;
// allocate (or replace) sprite frames, and set spritedef // allocate (or replace) sprite frames, and set spritedef
@@ -774,7 +774,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
// So just let the function in the while loop take care of it for us. // So just let the function in the while loop take care of it for us.
} }
R_FlushTranslationColormapCache(); //R_FlushTranslationColormapCache();
CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name); CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name);
#ifdef SKINVALUES #ifdef SKINVALUES
Loaded 100 of 118 files, more files were not shown because too many files have changed in this diff. Show more