thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'origin/master' into new-spb

Browse source
This commit is contained in:
AJ Martinez 2022-09-23 22:20:24 -07:00
commit e10d6124d6
20 changed files with 293 additions and 265 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

180
src/command.c
View file

@ -1024,15 +1024,17 @@ static void COM_Help_f(void)
/** Toggles a console variable. Useful for on/off values.
*
* This works on on/off, yes/no values only
* This works on on/off, yes/no values by default. Given
* a list of values, cycles between them.
*/
static void COM_Toggle_f(void)
{
consvar_t *cvar;
if (COM_Argc() != 2)
if (COM_Argc() == 1 || COM_Argc() == 3)
{
CONS_Printf(M_GetText("Toggle <cvar_name>: Toggle the value of a cvar\n"));
CONS_Printf("Toggle <cvar_name> <value1> <value2>...: Cycle along a set of values\n");
return;
}
cvar = CV_FindVar(COM_Argv(1));
@ -1042,15 +1044,44 @@ static void COM_Toggle_f(void)
return;
}
if (COM_Argc() == 2)
{
if (!(cvar->PossibleValue == CV_YesNo || cvar->PossibleValue == CV_OnOff))
{
CONS_Alert(CONS_NOTICE, M_GetText("%s is not a boolean value\n"), COM_Argv(1));
return;
}
}
// netcvar don't change imediately
cvar->flags |= CV_SHOWMODIFONETIME;
if (COM_Argc() == 2)
{
CV_AddValue(cvar, +1);
}
else
{
size_t i;
for (i = 2; i < COM_Argc() - 1; ++i)
{
const char *str = COM_Argv(i);
INT32 val;
if (CV_CompleteValue(cvar, &str, &val))
{
if (str ? !stricmp(cvar->string, str)
: cvar->value == val)
{
CV_Set(cvar, COM_Argv(i + 1));
return;
}
}
}
CV_Set(cvar, COM_Argv(2));
}
}
/** Command variant of CV_AddValue
@ -1424,26 +1455,27 @@ const char *CV_CompleteVar(char *partial, INT32 skips)
return NULL;
}
/** Sets a value to a variable with less checking. Only for internal use.
*
* \param var Variable to set.
* \param valstr String value for the variable.
*/
static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
boolean CV_CompleteValue(consvar_t *var, const char **valstrp, INT32 *intval)
{
boolean override = false;
const char *valstr = *valstrp;
INT32 overrideval = 0;
// If we want messages informing us if cheats have been enabled or disabled,
// we need to rework the consvars a little bit. This call crashes the game
// on load because not all variables will be registered at that time.
/* boolean prevcheats = false;
if (var->flags & CV_CHEAT)
prevcheats = CV_CheatsEnabled(); */
INT32 v;
if (var == &cv_forceskin)
{
v = R_SkinAvailable(valstr);
if (!R_SkinUsable(-1, v))
v = -1;
goto finish;
}
if (var->PossibleValue)
{
INT32 v;
INT32 i;
if (var->flags & CV_FLOAT)
{
@ -1464,7 +1496,6 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
{
#define MINVAL 0
#define MAXVAL 1
INT32 i;
#ifdef PARANOIA
if (!var->PossibleValue[MAXVAL].strvalue)
I_Error("Bounded cvar \"%s\" without maximum!\n", var->name);
@ -1473,52 +1504,26 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
// search for other
for (i = MAXVAL+1; var->PossibleValue[i].strvalue; i++)
if (v == var->PossibleValue[i].value || !stricmp(var->PossibleValue[i].strvalue, valstr))
{
if (client && execversion_enabled)
{
if (var->revert.allocated)
{
Z_Free(var->revert.v.string);
var->revert.allocated = false; // the below value is not allocated in zone memory, don't try to free it!
}
var->revert.v.const_munge = var->PossibleValue[i].strvalue;
return;
}
// free the old value string
Z_Free(var->zstring);
var->zstring = NULL;
var->value = var->PossibleValue[i].value;
var->string = var->PossibleValue[i].strvalue;
goto finish;
}
goto found;
if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || !stricmp(valstr, "MIN"))
{
v = var->PossibleValue[MINVAL].value;
valstr = var->PossibleValue[MINVAL].strvalue;
override = true;
overrideval = v;
i = MINVAL;
goto found;
}
else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || !stricmp(valstr, "MAX"))
{
v = var->PossibleValue[MAXVAL].value;
valstr = var->PossibleValue[MAXVAL].strvalue;
override = true;
overrideval = v;
i = MAXVAL;
goto found;
}
if (v == INT32_MIN)
goto badinput;
valstr = NULL; // not a preset value
#undef MINVAL
#undef MAXVAL
}
else
{
INT32 i;
// check first strings
for (i = 0; var->PossibleValue[i].strvalue; i++)
if (!stricmp(var->PossibleValue[i].strvalue, valstr))
@ -1550,26 +1555,68 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
// ...or not.
goto badinput;
found:
if (client && execversion_enabled)
{
var->revert.v.const_munge = var->PossibleValue[i].strvalue;
return;
v = var->PossibleValue[i].value;
valstr = var->PossibleValue[i].strvalue;
}
var->value = var->PossibleValue[i].value;
var->string = var->PossibleValue[i].strvalue;
goto finish;
finish:
if (intval)
*intval = v;
*valstrp = valstr;
return true;
}
// landing point for possiblevalue failures
badinput:
return false;
}
/** Sets a value to a variable with less checking. Only for internal use.
*
* \param var Variable to set.
* \param valstr String value for the variable.
*/
static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
{
boolean override = false;
INT32 overrideval = 0;
// If we want messages informing us if cheats have been enabled or disabled,
// we need to rework the consvars a little bit. This call crashes the game
// on load because not all variables will be registered at that time.
/* boolean prevcheats = false;
if (var->flags & CV_CHEAT)
prevcheats = CV_CheatsEnabled(); */
const char *overridestr = valstr;
if (CV_CompleteValue(var, &overridestr, &overrideval))
{
if (overridestr)
{
valstr = overridestr;
override = true;
}
}
else if (var->PossibleValue)
goto badinput;
if (client && execversion_enabled)
{
if (var->revert.allocated)
{
Z_Free(var->revert.v.string);
// Z_StrDup creates a new zone memory block, so we can keep the allocated flag on
if (override)
var->revert.allocated = false; // the below value is not allocated in zone memory, don't try to free it!
}
if (override)
var->revert.v.const_munge = valstr;
else
var->revert.v.string = Z_StrDup(valstr);
return;
@ -1578,28 +1625,25 @@ found:
// free the old value string
Z_Free(var->zstring);
if (override)
{
var->zstring = NULL;
var->value = overrideval;
var->string = valstr;
}
else
{
var->string = var->zstring = Z_StrDup(valstr);
if (override)
var->value = overrideval;
else if (var->flags & CV_FLOAT)
if (var->flags & CV_FLOAT)
{
double d = atof(var->string);
var->value = (INT32)(d * FRACUNIT);
}
else
{
if (var == &cv_forceskin)
{
var->value = R_SkinAvailable(var->string);
if (!R_SkinUsable(-1, var->value))
var->value = -1;
}
else
var->value = atoi(var->string);
}
finish:
// See the note above.
/* if (var->flags & CV_CHEAT)
{

6
src/command.h
View file

@ -194,6 +194,12 @@ void CV_ClearChangedFlags(void);
// returns the name of the nearest console variable name found
const char *CV_CompleteVar(char *partial, INT32 skips);
// Returns true if valstrp is within the PossibleValues of
// var. If an exact string value exists, it is returned in
// valstrp. An integer value is returned in intval if it
// is not NULL.
boolean CV_CompleteValue(consvar_t *var, const char **valstrp, INT32 *intval);
// equivalent to "<varname> <value>" typed at the console
void CV_Set(consvar_t *var, const char *value);

11
src/d_player.h
View file

@ -58,11 +58,11 @@ typedef enum
//
typedef enum
{
// True if button down last tic.
PF_ATTACKDOWN = 1,
PF_ACCELDOWN = 1<<1,
PF_BRAKEDOWN = 1<<2,
PF_LOOKDOWN = 1<<3,
// free: 1<<0 to 1<<2
// Look back VFX has been spawned
// TODO: Is there a better way to track this?
PF_GAINAX = 1<<3,
// Accessibility and cheats
PF_KICKSTARTACCEL = 1<<4, // Is accelerate in kickstart mode?
@ -330,6 +330,7 @@ typedef struct player_s
// Caveat: ticcmd_t is ATTRPACK! Be careful what precedes it.
ticcmd_t cmd;
ticcmd_t oldcmd; // from the previous tic
playerstate_t playerstate;

13
src/deh_tables.c
View file

@ -5729,11 +5729,14 @@ const char *const MAPTHINGFLAG_LIST[4] = {
};
const char *const PLAYERFLAG_LIST[] = {
// True if button down last tic.
"ATTACKDOWN",
"ACCELDOWN",
"BRAKEDOWN",
"LOOKDOWN",
// free: 1<<0 to 1<<2 (name un-matchable)
"\x01",
"\x01",
"\x01",
// Look back VFX has been spawned
// TODO: Is there a better way to track this?
"GAINAX",
// Accessibility and cheats
"KICKSTARTACCEL", // Is accelerate in kickstart mode?

5
src/g_game.c
View file

@ -2410,11 +2410,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
// ^ Not necessary anyway since it will be respawned regardless considering it doesn't exist anymore.
// Don't do anything immediately
p->pflags |= PF_BRAKEDOWN;
p->pflags |= PF_ATTACKDOWN;
p->pflags |= PF_ACCELDOWN;
p->playerstate = PST_LIVE;
p->panim = PA_STILL; // standing animation

44
src/hardware/hw_draw.c
View file

@ -31,6 +31,7 @@
#include "../p_local.h" // stplyr
#include "../g_game.h" // players
#include "../k_hud.h"
#include "../r_plane.h" // R_FlatDimensionsFromLumpSize
#include <fcntl.h>
#include "../i_video.h" // for rendermode != render_glide
@ -482,42 +483,17 @@ void HWR_DrawPic(INT32 x, INT32 y, lumpnum_t lumpnum)
// --------------------------------------------------------------------------
void HWR_DrawFlatFill (INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
{
FOutVector v[4];
double dflatsize;
INT32 flatflag;
const size_t len = W_LumpLength(flatlumpnum);
switch (len)
{
case 4194304: // 2048x2048 lump
dflatsize = 2048.0f;
flatflag = 2047;
break;
case 1048576: // 1024x1024 lump
dflatsize = 1024.0f;
flatflag = 1023;
break;
case 262144:// 512x512 lump
dflatsize = 512.0f;
flatflag = 511;
break;
case 65536: // 256x256 lump
dflatsize = 256.0f;
flatflag = 255;
break;
case 16384: // 128x128 lump
dflatsize = 128.0f;
flatflag = 127;
break;
case 1024: // 32x32 lump
dflatsize = 32.0f;
flatflag = 31;
break;
default: // 64x64 lump
dflatsize = 64.0f;
flatflag = 63;
break;
}
size_t sflatsize;
double dflatsize;
INT32 flatflag;
FOutVector v[4];
sflatsize = R_FlatDimensionsFromLumpSize(len);
dflatsize = (double)sflatsize;
flatflag = sflatsize - 1;
// 3--2
// | /|

57
src/hardware/hw_main.c
View file

@ -46,6 +46,7 @@
// SRB2Kart
#include "../k_kart.h" // HITLAGJITTERS
#include "../r_fps.h"
#include "../r_plane.h" // R_FlatDimensionsFromLumpSize
#ifdef NEWCLIP
#include "hw_clip.h"
@ -393,31 +394,9 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
if (levelflat->type == LEVELFLAT_FLAT)
{
size_t len = W_LumpLength(levelflat->u.flat.lumpnum);
switch (len)
{
case 4194304: // 2048x2048 lump
fflatwidth = fflatheight = 2048.0f;
break;
case 1048576: // 1024x1024 lump
fflatwidth = fflatheight = 1024.0f;
break;
case 262144:// 512x512 lump
fflatwidth = fflatheight = 512.0f;
break;
case 65536: // 256x256 lump
fflatwidth = fflatheight = 256.0f;
break;
case 16384: // 128x128 lump
fflatwidth = fflatheight = 128.0f;
break;
case 1024: // 32x32 lump
fflatwidth = fflatheight = 32.0f;
break;
default: // 64x64 lump
fflatwidth = fflatheight = 64.0f;
break;
}
flatflag = ((INT32)fflatwidth)-1;
size_t sflatsize = R_FlatDimensionsFromLumpSize(len);
fflatwidth = fflatheight = (double)sflatsize;
flatflag = sflatsize-1;
}
else
{
@ -2756,31 +2735,9 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
if (levelflat->type == LEVELFLAT_FLAT)
{
size_t len = W_LumpLength(levelflat->u.flat.lumpnum);
switch (len)
{
case 4194304: // 2048x2048 lump
fflatwidth = fflatheight = 2048.0f;
break;
case 1048576: // 1024x1024 lump
fflatwidth = fflatheight = 1024.0f;
break;
case 262144:// 512x512 lump
fflatwidth = fflatheight = 512.0f;
break;
case 65536: // 256x256 lump
fflatwidth = fflatheight = 256.0f;
break;
case 16384: // 128x128 lump
fflatwidth = fflatheight = 128.0f;
break;
case 1024: // 32x32 lump
fflatwidth = fflatheight = 32.0f;
break;
default: // 64x64 lump
fflatwidth = fflatheight = 64.0f;
break;
}
flatflag = ((INT32)fflatwidth)-1;
size_t sflatsize = R_FlatDimensionsFromLumpSize(len);
fflatwidth = fflatheight = (double)sflatsize;
flatflag = sflatsize-1;
}
else
{

29
src/k_botitem.c
View file

@ -27,6 +27,23 @@
#include "m_random.h"
#include "r_things.h" // numskins
/*--------------------------------------------------
static inline boolean K_ItemButtonWasDown(player_t *player)
Looks for players around the bot, and presses the item button
if there is one in range.
Input Arguments:-
player - Bot to check.
Return:-
true if the item button was pressed last tic, otherwise false.
--------------------------------------------------*/
static inline boolean K_ItemButtonWasDown(player_t *player)
{
return (player->oldcmd.buttons & BT_ATTACK);
}
/*--------------------------------------------------
static boolean K_BotUseItemNearPlayer(player_t *player, ticcmd_t *cmd, fixed_t radius)
@ -45,7 +62,7 @@ static boolean K_BotUseItemNearPlayer(player_t *player, ticcmd_t *cmd, fixed_t r
{
UINT8 i;
if (player->pflags & PF_ATTACKDOWN)
if (K_ItemButtonWasDown(player) == true)
{
return false;
}
@ -327,7 +344,7 @@ static void K_ItemConfirmForTarget(player_t *bot, player_t *target, UINT16 amoun
--------------------------------------------------*/
static boolean K_BotGenericPressItem(player_t *player, ticcmd_t *cmd, SINT8 dir)
{
if (player->pflags & PF_ATTACKDOWN)
if (K_ItemButtonWasDown(player) == true)
{
return false;
}
@ -352,7 +369,7 @@ static boolean K_BotGenericPressItem(player_t *player, ticcmd_t *cmd, SINT8 dir)
--------------------------------------------------*/
static void K_BotItemGenericTap(player_t *player, ticcmd_t *cmd)
{
if (!(player->pflags & PF_ATTACKDOWN))
if (K_ItemButtonWasDown(player) == false)
{
cmd->buttons |= BT_ATTACK;
player->botvars.itemconfirm = 0;
@ -475,7 +492,7 @@ static void K_BotItemSneaker(player_t *player, ticcmd_t *cmd)
|| player->speedboost > (FRACUNIT/8) // Have another type of boost (tethering)
|| player->botvars.itemconfirm > 4*TICRATE) // Held onto it for too long
{
if (!player->sneakertimer && !(player->pflags & PF_ATTACKDOWN))
if (player->sneakertimer == 0 && K_ItemButtonWasDown(player) == false)
{
cmd->buttons |= BT_ATTACK;
player->botvars.itemconfirm = 2*TICRATE;
@ -503,7 +520,7 @@ static void K_BotItemRocketSneaker(player_t *player, ticcmd_t *cmd)
{
if (player->botvars.itemconfirm > TICRATE)
{
if (!player->sneakertimer && !(player->pflags & PF_ATTACKDOWN))
if (player->sneakertimer == 0 && K_ItemButtonWasDown(player) == false)
{
cmd->buttons |= BT_ATTACK;
player->botvars.itemconfirm = 0;
@ -1193,7 +1210,7 @@ static void K_BotItemRouletteMash(player_t *player, ticcmd_t *cmd)
{
boolean mash = false;
if (player->pflags & PF_ATTACKDOWN)
if (K_ItemButtonWasDown(player) == true)
{
return;
}

32
src/k_kart.c
View file

@ -1159,9 +1159,6 @@ static void K_KartItemRoulette(player_t *player, ticcmd_t *cmd)
else if (!(player->itemroulette >= (TICRATE*3)))
return;
if (cmd->buttons & BT_ATTACK)
player->pflags |= PF_ATTACKDOWN;
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i] && !players[i].spectator
@ -2682,7 +2679,7 @@ void K_KartMoveAnimation(player_t *player)
if (!lookback)
{
player->pflags &= ~PF_LOOKDOWN;
player->pflags &= ~PF_GAINAX;
// Uses turning over steering -- it's important to show player feedback immediately.
if (player->cmd.turning < -minturn)
@ -2706,7 +2703,7 @@ void K_KartMoveAnimation(player_t *player)
destGlanceDir = -(2*intsign(player->aizdriftturn));
player->glanceDir = destGlanceDir;
drift = turndir = 0;
player->pflags &= ~PF_LOOKDOWN;
player->pflags &= ~PF_GAINAX;
}
else if (player->aizdriftturn)
{
@ -2752,14 +2749,14 @@ void K_KartMoveAnimation(player_t *player)
gainaxstate = S_GAINAX_MID1;
}
if (destGlanceDir && !(player->pflags & PF_LOOKDOWN))
if (destGlanceDir && !(player->pflags & PF_GAINAX))
{
mobj_t *gainax = P_SpawnMobjFromMobj(player->mo, 0, 0, 0, MT_GAINAX);
gainax->movedir = (destGlanceDir < 0) ? (ANGLE_270-ANG10) : (ANGLE_90+ANG10);
P_SetTarget(&gainax->target, player->mo);
P_SetMobjState(gainax, gainaxstate);
gainax->flags2 |= MF2_AMBUSH;
player->pflags |= PF_LOOKDOWN;
player->pflags |= PF_GAINAX;
}
}
else if (K_GetForwardMove(player) < 0 && destGlanceDir == 0)
@ -3016,7 +3013,7 @@ void K_KartMoveAnimation(player_t *player)
}
if (!player->glanceDir)
player->pflags &= ~PF_LOOKDOWN;
player->pflags &= ~PF_GAINAX;
// Update lastspeed value -- we use to display slow driving frames instead of fast driving when slowing down.
player->lastspeed = player->speed;
@ -6069,11 +6066,6 @@ void K_DoSneaker(player_t *player, INT32 type)
}
}
if (type != 0)
{
player->pflags |= PF_ATTACKDOWN;
}
player->sneakertimer = sneakertime;
// set angle for spun out players:
@ -6082,8 +6074,7 @@ void K_DoSneaker(player_t *player, INT32 type)
static void K_DoShrink(player_t *user)
{
S_StartSound(NULL, sfx_kc46); // Sound the BANG!
user->pflags |= PF_ATTACKDOWN;
S_StartSound(user->mo, sfx_kc46); // Sound the BANG!
Obj_CreateShrinkPohbees(user);
@ -10076,7 +10067,7 @@ void K_UnsetItemOut(player_t *player)
void K_MoveKartPlayer(player_t *player, boolean onground)
{
ticcmd_t *cmd = &player->cmd;
boolean ATTACK_IS_DOWN = ((cmd->buttons & BT_ATTACK) && !(player->pflags & PF_ATTACKDOWN));
boolean ATTACK_IS_DOWN = ((cmd->buttons & BT_ATTACK) && !(player->oldcmd.buttons & BT_ATTACK));
boolean HOLDING_ITEM = (player->pflags & (PF_ITEMOUT|PF_EGGMANOUT));
boolean NO_HYUDORO = (player->stealingtimer == 0);
@ -10111,11 +10102,6 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
player->pflags &= ~PF_USERINGS;
}
if ((player->pflags & PF_ATTACKDOWN) && !(cmd->buttons & BT_ATTACK))
player->pflags &= ~PF_ATTACKDOWN;
else if (cmd->buttons & BT_ATTACK)
player->pflags |= PF_ATTACKDOWN;
if (player && player->mo && player->mo->health > 0 && !player->spectator && !P_PlayerInPain(player) && !mapreset && leveltime > introtime)
{
// First, the really specific, finicky items that function without the item being directly in your item slot.
@ -10123,7 +10109,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
// Ring boosting
if (player->pflags & PF_USERINGS)
{
if ((player->pflags & PF_ATTACKDOWN) && !player->ringdelay && player->rings > 0)
if ((cmd->buttons & BT_ATTACK) && !player->ringdelay && player->rings > 0)
{
mobj_t *ring = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_RING);
P_SetMobjState(ring, S_FASTRING1);
@ -10882,6 +10868,8 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
player->trickpanel = 0;
K_trickPanelTimingVisual(player, momz); // fail trick visual
P_SetPlayerMobjState(player->mo, S_KART_SPINOUT);
if (player->pflags & (PF_ITEMOUT|PF_EGGMANOUT))
K_DropHnextList(player, true);
}
else if (!(player->pflags & PF_TRICKDELAY)) // don't allow tricking at the same frame you tumble obv

2
src/k_menu.h
View file

@ -536,7 +536,7 @@ extern struct menutransition_s {
extern boolean menuwipe;
extern consvar_t cv_showfocuslost;
extern consvar_t cv_chooseskin, cv_serversort;
extern consvar_t cv_chooseskin, cv_serversort, cv_menujam_update;
void M_SetMenuDelay(UINT8 i);

34
src/k_menufunc.c
View file

@ -143,6 +143,10 @@ consvar_t cv_showfocuslost = CVAR_INIT ("showfocuslost", "Yes", CV_SAVE, CV_YesN
static CV_PossibleValue_t skins_cons_t[MAXSKINS+1] = {{1, DEFAULTSKIN}};
consvar_t cv_chooseskin = CVAR_INIT ("chooseskin", DEFAULTSKIN, CV_HIDDEN, skins_cons_t, NULL);
consvar_t cv_menujam_update = CVAR_INIT ("menujam_update", "Off", CV_SAVE, CV_OnOff, NULL);
static CV_PossibleValue_t menujam_cons_t[] = {{0, "menu"}, {1, "menu2"}, {2, "menu3"}, {0, NULL}};
static consvar_t cv_menujam = CVAR_INIT ("menujam", "0", CV_SAVE, menujam_cons_t, NULL);
// This gametype list is integral for many different reasons.
// When you add gametypes here, don't forget to update them in dehacked.c and doomstat.h!
CV_PossibleValue_t gametype_cons_t[NUMGAMETYPES+1];
@ -945,7 +949,13 @@ void M_StartControlPanel(void)
paused = false;
CON_ToggleOff();
S_ChangeMusicInternal("menu", true);
if (cv_menujam_update.value)
{
CV_AddValue(&cv_menujam, 1);
CV_SetValue(&cv_menujam_update, 0);
}
S_ChangeMusicInternal(cv_menujam.string, true);
}
menuactive = true;
@ -1686,6 +1696,14 @@ void M_Init(void)
CV_RegisterVar(&cv_chooseskin);
CV_RegisterVar(&cv_autorecord);
// don't lose your position in the jam cycle
CV_RegisterVar(&cv_menujam_update);
CV_RegisterVar(&cv_menujam);
#ifndef NONET
CV_RegisterVar(&cv_serversort);
#endif
if (dedicated)
return;
@ -1712,20 +1730,6 @@ void M_Init(void)
CV_RegisterVar(&cv_dummyaddonsearch);
M_UpdateMenuBGImage(true);
#if 0
#ifdef HWRENDER
// Permanently hide some options based on render mode
if (rendermode == render_soft)
OP_VideoOptionsMenu[op_video_ogl].status =
OP_VideoOptionsMenu[op_video_kartman].status =
OP_VideoOptionsMenu[op_video_md2] .status = IT_DISABLED;
#endif
#endif
#ifndef NONET
CV_RegisterVar(&cv_serversort);
#endif
}
// ==================================================

4
src/lua_playerlib.c
View file

@ -192,6 +192,8 @@ static int player_get(lua_State *L)
LUA_PushUserdata(L, plr->mo, META_MOBJ);
else if (fastcmp(field,"cmd"))
LUA_PushUserdata(L, &plr->cmd, META_TICCMD);
else if (fastcmp(field,"oldcmd"))
LUA_PushUserdata(L, &plr->oldcmd, META_TICCMD);
else if (fastcmp(field,"respawn"))
LUA_PushUserdata(L, &plr->respawn, META_RESPAWN);
else if (fastcmp(field,"playerstate"))
@ -530,6 +532,8 @@ static int player_set(lua_State *L)
}
else if (fastcmp(field,"cmd"))
return NOSET;
else if (fastcmp(field,"oldcmd"))
return NOSET;
else if (fastcmp(field,"respawn"))
return NOSET;
else if (fastcmp(field,"playerstate"))

10
src/m_cheat.c
View file

@ -1053,11 +1053,11 @@ void OP_ObjectplaceMovement(player_t *player)
}
if (player->pflags & PF_ATTACKDOWN)
if (player->pflags & PF_STASIS)
{
// Are ANY objectplace buttons pressed? If no, remove flag.
if (!(cmd->buttons & (BT_ATTACK|BT_DRIFT)))
player->pflags &= ~PF_ATTACKDOWN;
player->pflags &= ~PF_STASIS;
// Do nothing.
return;
@ -1066,12 +1066,12 @@ void OP_ObjectplaceMovement(player_t *player)
/*if (cmd->buttons & BT_FORWARD)
{
OP_CycleThings(-1);
player->pflags |= PF_ATTACKDOWN;
player->pflags |= PF_STASIS;
}
else*/ if (cmd->buttons & BT_DRIFT)
{
OP_CycleThings(1);
player->pflags |= PF_ATTACKDOWN;
player->pflags |= PF_STASIS;
}
// Place an object and add it to the maplist
@ -1082,7 +1082,7 @@ void OP_ObjectplaceMovement(player_t *player)
mobjtype_t spawnthing = op_currentdoomednum;
boolean ceiling;
player->pflags |= PF_ATTACKDOWN;
player->pflags |= PF_STASIS;
if (cv_mapthingnum.value > 0 && cv_mapthingnum.value < 4096)
{

2
src/p_inter.c
View file

@ -2032,7 +2032,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
player->gateBoost = 0;
player->ringboost = 0;
player->glanceDir = 0;
player->pflags &= ~PF_LOOKDOWN;
player->pflags &= ~PF_GAINAX;
switch (type)
{

3
src/p_setup.c
View file

@ -4079,6 +4079,9 @@ static void P_InitGametype(void)
G_RecordDemo(buf);
}
// Started a game? Move on to the next jam when you go back to the title screen
CV_SetValue(&cv_menujam_update, 1);
}
/** Loads a level from a lump or external wad.

5
src/p_tick.c
View file

@ -767,6 +767,11 @@ void P_Ticker(boolean run)
K_TimerInit();
}
for (i = 0; i < MAXPLAYERS; i++)
{
G_CopyTiccmd(&players[i].oldcmd, &players[i].cmd, 1);
}
// Z_CheckMemCleanup();
}

17
src/p_user.c
View file

@ -2218,7 +2218,7 @@ void P_MovePlayer(player_t *player)
player->drawangle -= ANGLE_22h;
player->mo->rollangle = 0;
player->glanceDir = 0;
player->pflags &= ~PF_LOOKDOWN;
player->pflags &= ~PF_GAINAX;
}
else if ((player->pflags & PF_FAULT) || (player->spinouttimer > 0))
{
@ -4186,7 +4186,7 @@ void P_PlayerThink(player_t *player)
}
else if (cmd->buttons & BT_ACCELERATE)
{
if (!player->exiting && !(player->pflags & PF_ACCELDOWN))
if (!player->exiting && !(player->oldcmd.buttons & BT_ACCELERATE))
{
player->kickstartaccel = 0;
}
@ -4394,19 +4394,6 @@ void P_PlayerThink(player_t *player)
P_DoBubbleBreath(player); // Spawn Sonic's bubbles
P_CheckInvincibilityTimer(player); // Spawn Invincibility Sparkles
// check for buttons
if (cmd->buttons & BT_ACCELERATE)
player->pflags |= PF_ACCELDOWN;
else
player->pflags &= ~PF_ACCELDOWN;
if (cmd->buttons & BT_BRAKE)
player->pflags |= PF_BRAKEDOWN;
else
player->pflags &= ~PF_BRAKEDOWN;
// PF_LOOKDOWN handled in K_KartMoveAnimation
// Counters, time dependent power ups.
// Time Bonus & Ring Bonus count settings

1
src/r_plane.h
View file

@ -89,6 +89,7 @@ visplane_t *R_CheckPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_ExpandPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_PlaneBounds(visplane_t *plane);
size_t R_FlatDimensionsFromLumpSize(size_t size);
void R_CheckFlatLength(size_t size);
boolean R_CheckPowersOfTwo(void);

77
src/r_textures.c
View file

@ -656,6 +656,44 @@ boolean R_CheckPowersOfTwo(void)
return ds_powersoftwo;
}
//
// R_FlatDimensionsFromLumpSize
//
// Returns the flat's square size from its lump length.
//
size_t R_FlatDimensionsFromLumpSize(size_t size)
{
switch (size)
{
case 4194304: // 2048x2048 lump
return 2048;
case 1048576: // 1024x1024 lump
return 1024;
case 262144:// 512x512 lump
return 512;
case 65536: // 256x256 lump
return 256;
case 16384: // 128x128 lump
return 128;
case 1024: // 32x32 lump
return 32;
case 256: // 16x16 lump
return 16;
case 64: // 8x8 lump
return 8;
default: // 64x64 lump
return 64;
}
}
//
// R_CheckFlatLength
//
@ -707,6 +745,20 @@ void R_CheckFlatLength(size_t size)
nflatshiftup = 11;
ds_flatwidth = ds_flatheight = 32;
break;
case 256: // 16x16 lump
nflatmask = 0xF0;
nflatxshift = 28;
nflatyshift = 24;
nflatshiftup = 12;
ds_flatwidth = ds_flatheight = 16;
break;
case 64: // 8x8 lump
nflatmask = 0x38;
nflatxshift = 29;
nflatyshift = 26;
nflatshiftup = 13;
ds_flatwidth = ds_flatheight = 8;
break;
default: // 64x64 lump
nflatmask = 0xFC0;
nflatxshift = 26;
@ -774,30 +826,7 @@ Rloadflats (INT32 i, INT32 w)
W_ReadLumpHeaderPwad(wadnum, lumpnum, header, sizeof header, 0);
lumplength = W_LumpLengthPwad(wadnum, lumpnum);
switch (lumplength)
{
case 4194304: // 2048x2048 lump
flatsize = 2048;
break;
case 1048576: // 1024x1024 lump
flatsize = 1024;
break;
case 262144:// 512x512 lump
flatsize = 512;
break;
case 65536: // 256x256 lump
flatsize = 256;
break;
case 16384: // 128x128 lump
flatsize = 128;
break;
case 1024: // 32x32 lump
flatsize = 32;
break;
default: // 64x64 lump
flatsize = 64;
break;
}
flatsize = R_FlatDimensionsFromLumpSize(lumplength);
//CONS_Printf("\n\"%s\" is a flat, dimensions %d x %d",W_CheckNameForNumPwad((UINT16)w,texstart+j),flatsize,flatsize);
texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);

16
src/v_video.c
View file

@ -1236,19 +1236,19 @@ void V_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatnum)
{
case 4194304: // 2048x2048 lump
lflatsize = 2048;
flatshift = 10;
flatshift = 11;
break;
case 1048576: // 1024x1024 lump
lflatsize = 1024;
flatshift = 9;
flatshift = 10;
break;
case 262144:// 512x512 lump
lflatsize = 512;
flatshift = 8;
flatshift = 9;
break;
case 65536: // 256x256 lump
lflatsize = 256;
flatshift = 7;
flatshift = 8;
break;
case 16384: // 128x128 lump
lflatsize = 128;
@ -1258,6 +1258,14 @@ void V_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatnum)
lflatsize = 32;
flatshift = 5;
break;
case 256: // 16x16 lump
lflatsize = 16;
flatshift = 4;
break;
case 64: // 8x8 lump
lflatsize = 8;
flatshift = 3;
break;
default: // 64x64 lump
lflatsize = 64;
flatshift = 6;