Merge remote-tracking branch 'upstream/next' into lua-railstuff
# Conflicts: # src/p_map.c
This commit is contained in:
commit
943ede737a
15
appveyor.yml
15
appveyor.yml
|
@ -9,7 +9,7 @@ environment:
|
|||
# c:\mingw-w64 i686 has gcc 6.3.0, so use c:\msys64 7.3.0 instead
|
||||
MINGW_SDK: c:\msys64\mingw32
|
||||
# c:\msys64 x86_64 has gcc 8.2.0, so use c:\mingw-w64 7.3.0 instead
|
||||
MINGW_SDK_64: C:\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev0\mingw64
|
||||
MINGW_SDK_64: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64
|
||||
CFLAGS: -Wall -W -Werror -Wno-error=implicit-fallthrough -Wimplicit-fallthrough=3 -Wno-tautological-compare -Wno-error=suggest-attribute=noreturn
|
||||
NASM_ZIP: nasm-2.12.01
|
||||
NASM_URL: http://www.nasm.us/pub/nasm/releasebuilds/2.12.01/win64/nasm-2.12.01-win64.zip
|
||||
|
@ -55,8 +55,6 @@ cache:
|
|||
install:
|
||||
- if [%CONFIGURATION%] == [SDL64] ( set "X86_64=1" )
|
||||
- if [%CONFIGURATION%] == [SDL64] ( set "CONFIGURATION=SDL" )
|
||||
- if [%CONFIGURATION%] == [DD64] ( set "X86_64=1" )
|
||||
- if [%CONFIGURATION%] == [DD64] ( set "CONFIGURATION=DD" )
|
||||
- if [%X86_64%] == [1] ( set "MINGW_SDK=%MINGW_SDK_64%" )
|
||||
- if [%X86_64%] == [1] ( set "CCACHE_CC=%CCACHE_CC_64%" )
|
||||
|
||||
|
@ -75,13 +73,6 @@ install:
|
|||
configuration:
|
||||
- SDL
|
||||
- SDL64
|
||||
- DD
|
||||
- DD64
|
||||
|
||||
matrix:
|
||||
allow_failures:
|
||||
- configuration: DD
|
||||
- configuration: DD64
|
||||
|
||||
before_build:
|
||||
- set "Path=%MINGW_SDK%\bin;%Path%"
|
||||
|
@ -92,8 +83,8 @@ before_build:
|
|||
- ccache -V
|
||||
- ccache -s
|
||||
- if [%NOUPX%] == [1] ( set "NOUPX=NOUPX=1" ) else ( set "NOUPX=" )
|
||||
- set "SRB2_MFLAGS=-C src WARNINGMODE=1 CCACHE=1 GCC73=1 NOOBJDUMP=1 %NOUPX%"
|
||||
- if [%X86_64%] == [1] ( set "MINGW_FLAGS=MINGW64=1 X86_64=1" ) else ( set "MINGW_FLAGS=MINGW=1 GCC91=1" )
|
||||
- set "SRB2_MFLAGS=-C src WARNINGMODE=1 CCACHE=1 NOOBJDUMP=1 %NOUPX%"
|
||||
- if [%X86_64%] == [1] ( set "MINGW_FLAGS=MINGW64=1 X86_64=1 GCC81=1" ) else ( set "MINGW_FLAGS=MINGW=1 GCC91=1" )
|
||||
- set "SRB2_MFLAGS=%SRB2_MFLAGS% %MINGW_FLAGS% %CONFIGURATION%=1"
|
||||
|
||||
build_script:
|
||||
|
|
|
@ -245,6 +245,8 @@ void I_GetJoystick2Events(void){}
|
|||
|
||||
void I_GetMouseEvents(void){}
|
||||
|
||||
void I_UpdateMouseGrab(void){}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
LOGW("I_GetEnv() called?!");
|
||||
|
|
|
@ -19,6 +19,7 @@ boolean allow_fullscreen = false;
|
|||
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
void I_StartupGraphics(void){}
|
||||
void I_StartupHardwareGraphics(void){}
|
||||
|
||||
void I_ShutdownGraphics(void){}
|
||||
|
||||
|
@ -51,6 +52,11 @@ INT32 VID_SetMode(INT32 modenum)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void)
|
||||
{
|
||||
// ..............
|
||||
}
|
||||
|
||||
const char *VID_GetModeName(INT32 modenum)
|
||||
{
|
||||
return "A320x240";
|
||||
|
|
68
src/b_bot.c
68
src/b_bot.c
|
@ -127,13 +127,17 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
}
|
||||
|
||||
// Orientation
|
||||
if ((bot->pflags & (PF_SPINNING|PF_STARTDASH)) || flymode == 2)
|
||||
if (bot->pflags & (PF_SPINNING|PF_STARTDASH))
|
||||
{
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
}
|
||||
else if (flymode == 2)
|
||||
{
|
||||
cmd->angleturn = sonic->player->cmd.angleturn - (tails->angle >> 16);
|
||||
}
|
||||
else
|
||||
{
|
||||
cmd->angleturn = (ang - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (ang - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
}
|
||||
|
||||
// ********
|
||||
|
@ -222,7 +226,7 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
{
|
||||
if (dist < followthres && dist > touchdist) // Do positioning
|
||||
{
|
||||
cmd->angleturn = (ang - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (ang - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
cmd->forwardmove = 50;
|
||||
spinmode = true;
|
||||
}
|
||||
|
@ -230,7 +234,7 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
{
|
||||
if (!bmom && (!(bot->pflags & PF_SPINNING) || (bot->dashspeed && bot->pflags & PF_SPINNING)))
|
||||
{
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
spin = true;
|
||||
}
|
||||
spinmode = true;
|
||||
|
@ -244,7 +248,7 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
if (bot->pflags & PF_SPINNING || !spin_last)
|
||||
{
|
||||
spin = true;
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
cmd->forwardmove = MAXPLMOVE;
|
||||
spinmode = true;
|
||||
}
|
||||
|
@ -290,7 +294,7 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
else if (dist < followmin)
|
||||
{
|
||||
// Copy inputs
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> FRACBITS;
|
||||
cmd->angleturn = (sonic->angle - tails->angle) >> 16; // NOT FRACBITS DAMNIT
|
||||
bot->drawangle = ang;
|
||||
cmd->forwardmove = 8 * pcmd->forwardmove / 10;
|
||||
cmd->sidemove = 8 * pcmd->sidemove / 10;
|
||||
|
@ -335,27 +339,6 @@ static void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
|
|||
jump_last = jump;
|
||||
spin_last = spin;
|
||||
|
||||
// ********
|
||||
// Thinkfly overlay
|
||||
if (thinkfly)
|
||||
{
|
||||
if (!tails->hnext)
|
||||
{
|
||||
P_SetTarget(&tails->hnext, P_SpawnMobjFromMobj(tails, 0, 0, 0, MT_OVERLAY));
|
||||
if (tails->hnext)
|
||||
{
|
||||
P_SetTarget(&tails->hnext->target, tails);
|
||||
P_SetTarget(&tails->hnext->hprev, tails);
|
||||
P_SetMobjState(tails->hnext, S_FLIGHTINDICATOR);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (tails->hnext && tails->hnext->type == MT_OVERLAY && tails->hnext->state == states+S_FLIGHTINDICATOR)
|
||||
{
|
||||
P_RemoveMobj(tails->hnext);
|
||||
P_SetTarget(&tails->hnext, NULL);
|
||||
}
|
||||
|
||||
// Turn the virtual keypresses into ticcmd_t.
|
||||
B_KeysToTiccmd(tails, cmd, forward, backward, left, right, false, false, jump, spin);
|
||||
|
||||
|
@ -379,7 +362,7 @@ void B_BuildTiccmd(player_t *player, ticcmd_t *cmd)
|
|||
}
|
||||
|
||||
// Bot AI isn't programmed in analog.
|
||||
CV_SetValue(&cv_analog2, false);
|
||||
CV_SetValue(&cv_analog[1], false);
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
// Let Lua scripts build ticcmds
|
||||
|
@ -565,3 +548,30 @@ void B_RespawnBot(INT32 playernum)
|
|||
P_SetScale(tails, sonic->scale);
|
||||
tails->destscale = sonic->destscale;
|
||||
}
|
||||
|
||||
void B_HandleFlightIndicator(player_t *player)
|
||||
{
|
||||
mobj_t *tails = player->mo;
|
||||
|
||||
if (!tails)
|
||||
return;
|
||||
|
||||
if (thinkfly && player->bot == 1 && tails->health)
|
||||
{
|
||||
if (!tails->hnext)
|
||||
{
|
||||
P_SetTarget(&tails->hnext, P_SpawnMobjFromMobj(tails, 0, 0, 0, MT_OVERLAY));
|
||||
if (tails->hnext)
|
||||
{
|
||||
P_SetTarget(&tails->hnext->target, tails);
|
||||
P_SetTarget(&tails->hnext->hprev, tails);
|
||||
P_SetMobjState(tails->hnext, S_FLIGHTINDICATOR);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (tails->hnext && tails->hnext->type == MT_OVERLAY && tails->hnext->state == states+S_FLIGHTINDICATOR)
|
||||
{
|
||||
P_RemoveMobj(tails->hnext);
|
||||
P_SetTarget(&tails->hnext, NULL);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -15,3 +15,4 @@ void B_KeysToTiccmd(mobj_t *mo, ticcmd_t *cmd, boolean forward, boolean backward
|
|||
boolean B_CheckRespawn(player_t *player);
|
||||
void B_MoveBlocked(player_t *player);
|
||||
void B_RespawnBot(INT32 playernum);
|
||||
void B_HandleFlightIndicator(player_t *player);
|
||||
|
|
114
src/command.c
114
src/command.c
|
@ -54,13 +54,15 @@ static void COM_Add_f(void);
|
|||
static void CV_EnforceExecVersion(void);
|
||||
static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr);
|
||||
static boolean CV_Command(void);
|
||||
static consvar_t *CV_FindVar(const char *name);
|
||||
consvar_t *CV_FindVar(const char *name);
|
||||
static const char *CV_StringValue(const char *var_name);
|
||||
static consvar_t *consvar_vars; // list of registered console variables
|
||||
|
||||
static char com_token[1024];
|
||||
static char *COM_Parse(char *data);
|
||||
|
||||
static char * COM_Purge (char *text, int *lenp);
|
||||
|
||||
CV_PossibleValue_t CV_OnOff[] = {{0, "Off"}, {1, "On"}, {0, NULL}};
|
||||
CV_PossibleValue_t CV_YesNo[] = {{0, "No"}, {1, "Yes"}, {0, NULL}};
|
||||
CV_PossibleValue_t CV_Unsigned[] = {{0, "MIN"}, {999999999, "MAX"}, {0, NULL}};
|
||||
|
@ -100,31 +102,61 @@ static cmdalias_t *com_alias; // aliases list
|
|||
|
||||
static vsbuf_t com_text; // variable sized buffer
|
||||
|
||||
/** Purges control characters out of some text.
|
||||
*
|
||||
* \param s The text.
|
||||
* \param np Optionally a pointer to fill with the new string length.
|
||||
* \return The text.
|
||||
* \sa COM_ExecuteString
|
||||
*/
|
||||
static char *
|
||||
COM_Purge (char *s, int *np)
|
||||
{
|
||||
char *t;
|
||||
char *p;
|
||||
int n;
|
||||
n = strlen(s);
|
||||
t = s + n + 1;
|
||||
p = s;
|
||||
while (( p = strchr(p, '\033') ))
|
||||
{
|
||||
memmove(p, &p[1], t - p - 1);
|
||||
n--;
|
||||
}
|
||||
if (np)
|
||||
(*np) = n;
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Adds text into the command buffer for later execution.
|
||||
*
|
||||
* \param ptext The text to add.
|
||||
* \sa COM_BufInsertText
|
||||
* \sa COM_BufInsertTextEx
|
||||
*/
|
||||
void COM_BufAddText(const char *ptext)
|
||||
void COM_BufAddTextEx(const char *ptext, int flags)
|
||||
{
|
||||
size_t l;
|
||||
int l;
|
||||
char *text;
|
||||
|
||||
l = strlen(ptext);
|
||||
text = COM_Purge(Z_StrDup(ptext), &l);
|
||||
|
||||
if (com_text.cursize + l >= com_text.maxsize)
|
||||
if (com_text.cursize + 2 + l >= com_text.maxsize)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Command buffer full!\n"));
|
||||
return;
|
||||
}
|
||||
VS_Write(&com_text, ptext, l);
|
||||
|
||||
VS_WriteEx(&com_text, text, l, flags);
|
||||
|
||||
Z_Free(text);
|
||||
}
|
||||
|
||||
/** Adds command text and executes it immediately.
|
||||
*
|
||||
* \param ptext The text to execute. A newline is automatically added.
|
||||
* \sa COM_BufAddText
|
||||
* \sa COM_BufAddTextEx
|
||||
*/
|
||||
void COM_BufInsertText(const char *ptext)
|
||||
void COM_BufInsertTextEx(const char *ptext, int flags)
|
||||
{
|
||||
char *temp = NULL;
|
||||
size_t templen;
|
||||
|
@ -138,7 +170,7 @@ void COM_BufInsertText(const char *ptext)
|
|||
}
|
||||
|
||||
// add the entire text of the file (or alias)
|
||||
COM_BufAddText(ptext);
|
||||
COM_BufAddTextEx(ptext, flags);
|
||||
COM_BufExecute(); // do it right away
|
||||
|
||||
// add the copied off data
|
||||
|
@ -272,6 +304,7 @@ static size_t com_argc;
|
|||
static char *com_argv[MAX_ARGS];
|
||||
static const char *com_null_string = "";
|
||||
static char *com_args = NULL; // current command args or NULL
|
||||
static int com_flags;
|
||||
|
||||
static void Got_NetVar(UINT8 **p, INT32 playernum);
|
||||
|
||||
|
@ -394,12 +427,21 @@ static void COM_TokenizeString(char *ptext)
|
|||
|
||||
com_argc = 0;
|
||||
com_args = NULL;
|
||||
com_flags = 0;
|
||||
|
||||
while (com_argc < MAX_ARGS)
|
||||
{
|
||||
// Skip whitespace up to a newline.
|
||||
while (*ptext != '\0' && *ptext <= ' ' && *ptext != '\n')
|
||||
ptext++;
|
||||
{
|
||||
if (ptext[0] == '\033')
|
||||
{
|
||||
com_flags = (unsigned)ptext[1];
|
||||
ptext += 2;
|
||||
}
|
||||
else
|
||||
ptext++;
|
||||
}
|
||||
|
||||
// A newline means end of command in buffer,
|
||||
// thus end of this command's args too.
|
||||
|
@ -1016,6 +1058,15 @@ void VS_Write(vsbuf_t *buf, const void *data, size_t length)
|
|||
M_Memcpy(VS_GetSpace(buf, length), data, length);
|
||||
}
|
||||
|
||||
void VS_WriteEx(vsbuf_t *buf, const void *data, size_t length, int flags)
|
||||
{
|
||||
char *p;
|
||||
p = VS_GetSpace(buf, 2 + length);
|
||||
p[0] = '\033';
|
||||
p[1] = flags;
|
||||
M_Memcpy(&p[2], data, length);
|
||||
}
|
||||
|
||||
/** Prints text in a variable buffer. Like VS_Write() plus a
|
||||
* trailing NUL.
|
||||
*
|
||||
|
@ -1055,7 +1106,7 @@ static const char *cv_null_string = "";
|
|||
* \return Pointer to the variable if found, or NULL.
|
||||
* \sa CV_FindNetVar
|
||||
*/
|
||||
static consvar_t *CV_FindVar(const char *name)
|
||||
consvar_t *CV_FindVar(const char *name)
|
||||
{
|
||||
consvar_t *cvar;
|
||||
|
||||
|
@ -2015,6 +2066,9 @@ static boolean CV_Command(void)
|
|||
if (!v)
|
||||
return false;
|
||||
|
||||
if (( com_flags & COM_SAFE ) && ( v->flags & CV_NOLUA ))
|
||||
return false;
|
||||
|
||||
// perform a variable print or set
|
||||
if (COM_Argc() == 1)
|
||||
{
|
||||
|
@ -2060,7 +2114,12 @@ void CV_SaveVariables(FILE *f)
|
|||
|
||||
// Silly hack for Min/Max vars
|
||||
if (!strcmp(cvar->string, "MAX") || !strcmp(cvar->string, "MIN"))
|
||||
sprintf(stringtowrite, "%d", cvar->value);
|
||||
{
|
||||
if (cvar->flags & CV_FLOAT)
|
||||
sprintf(stringtowrite, "%f", FIXED_TO_FLOAT(cvar->value));
|
||||
else
|
||||
sprintf(stringtowrite, "%d", cvar->value);
|
||||
}
|
||||
else
|
||||
strcpy(stringtowrite, cvar->string);
|
||||
|
||||
|
@ -2116,8 +2175,13 @@ skipwhite:
|
|||
com_token[len] = 0;
|
||||
return data;
|
||||
}
|
||||
com_token[len] = c;
|
||||
len++;
|
||||
if (c == '\033')
|
||||
data++;
|
||||
else
|
||||
{
|
||||
com_token[len] = c;
|
||||
len++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2133,10 +2197,22 @@ skipwhite:
|
|||
// parse a regular word
|
||||
do
|
||||
{
|
||||
com_token[len] = c;
|
||||
data++;
|
||||
len++;
|
||||
c = *data;
|
||||
if (c == '\033')
|
||||
{
|
||||
do
|
||||
{
|
||||
data += 2;
|
||||
c = *data;
|
||||
}
|
||||
while (c == '\033') ;
|
||||
}
|
||||
else
|
||||
{
|
||||
com_token[len] = c;
|
||||
data++;
|
||||
len++;
|
||||
c = *data;
|
||||
}
|
||||
if (c == '{' || c == '}' || c == ')'|| c == '(' || c == '\'')
|
||||
break;
|
||||
} while (c > 32);
|
||||
|
|
|
@ -20,6 +20,20 @@
|
|||
// Command buffer & command execution
|
||||
//===================================
|
||||
|
||||
/* Lua command registration flags. */
|
||||
enum
|
||||
{
|
||||
COM_ADMIN = 1,
|
||||
COM_SPLITSCREEN = 2,
|
||||
COM_LOCAL = 4,
|
||||
};
|
||||
|
||||
/* Command buffer flags. */
|
||||
enum
|
||||
{
|
||||
COM_SAFE = 1,
|
||||
};
|
||||
|
||||
typedef void (*com_func_t)(void);
|
||||
|
||||
void COM_AddCommand(const char *name, com_func_t func);
|
||||
|
@ -36,10 +50,12 @@ size_t COM_FirstOption(void);
|
|||
const char *COM_CompleteCommand(const char *partial, INT32 skips);
|
||||
|
||||
// insert at queu (at end of other command)
|
||||
void COM_BufAddText(const char *btext);
|
||||
#define COM_BufAddText(s) COM_BufAddTextEx(s, 0)
|
||||
void COM_BufAddTextEx(const char *btext, int flags);
|
||||
|
||||
// insert in head (before other command)
|
||||
void COM_BufInsertText(const char *btext);
|
||||
#define COM_BufInsertText(s) COM_BufInsertTextEx(s, 0)
|
||||
void COM_BufInsertTextEx(const char *btext, int flags);
|
||||
|
||||
// don't bother inserting, just do immediately
|
||||
void COM_ImmedExecute(const char *ptext);
|
||||
|
@ -71,6 +87,7 @@ void VS_Free(vsbuf_t *buf);
|
|||
void VS_Clear(vsbuf_t *buf);
|
||||
void *VS_GetSpace(vsbuf_t *buf, size_t length);
|
||||
void VS_Write(vsbuf_t *buf, const void *data, size_t length);
|
||||
void VS_WriteEx(vsbuf_t *buf, const void *data, size_t length, int flags);
|
||||
void VS_Print(vsbuf_t *buf, const char *data); // strcats onto the sizebuf
|
||||
|
||||
//==================
|
||||
|
@ -100,7 +117,8 @@ typedef enum
|
|||
CV_HIDEN = 1024, // variable is not part of the cvar list so cannot be accessed by the console
|
||||
// can only be set when we have the pointer to it
|
||||
// used on menus
|
||||
CV_CHEAT = 2048 // Don't let this be used in multiplayer unless cheats are on.
|
||||
CV_CHEAT = 2048, // Don't let this be used in multiplayer unless cheats are on.
|
||||
CV_NOLUA = 4096,/* don't let this be called from Lua */
|
||||
} cvflags_t;
|
||||
|
||||
typedef struct CV_PossibleValue_s
|
||||
|
@ -140,6 +158,9 @@ void CV_ToggleExecVersion(boolean enable);
|
|||
// register a variable for use at the console
|
||||
void CV_RegisterVar(consvar_t *variable);
|
||||
|
||||
// returns a console variable by name
|
||||
consvar_t *CV_FindVar(const char *name);
|
||||
|
||||
// sets changed to 0 for every console variable
|
||||
void CV_ClearChangedFlags(void);
|
||||
|
||||
|
|
|
@ -20,6 +20,7 @@
|
|||
#include "g_input.h"
|
||||
#include "hu_stuff.h"
|
||||
#include "keys.h"
|
||||
#include "r_main.h"
|
||||
#include "r_defs.h"
|
||||
#include "sounds.h"
|
||||
#include "st_stuff.h"
|
||||
|
@ -591,6 +592,8 @@ void CON_ToggleOff(void)
|
|||
CON_ClearHUD();
|
||||
con_forcepic = 0;
|
||||
con_clipviewtop = -1; // remove console clipping of view
|
||||
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
|
||||
boolean CON_Ready(void)
|
||||
|
@ -615,6 +618,7 @@ void CON_Ticker(void)
|
|||
consoletoggle = false;
|
||||
con_destlines = 0;
|
||||
CON_ClearHUD();
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
|
||||
// console key was pushed
|
||||
|
@ -627,6 +631,7 @@ void CON_Ticker(void)
|
|||
{
|
||||
con_destlines = 0;
|
||||
CON_ClearHUD();
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
else
|
||||
CON_ChangeHeight();
|
||||
|
@ -1285,10 +1290,10 @@ void CONS_Printf(const char *fmt, ...)
|
|||
con_scrollup = 0;
|
||||
|
||||
// if not in display loop, force screen update
|
||||
if (con_startup)
|
||||
if (con_startup && (!setrenderneeded))
|
||||
{
|
||||
#ifdef _WINDOWS
|
||||
patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_CACHE);
|
||||
patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
|
||||
|
||||
// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
|
||||
V_DrawScaledPatch(0, 0, 0, con_backpic);
|
||||
|
@ -1545,7 +1550,7 @@ static void CON_DrawConsole(void)
|
|||
// draw console background
|
||||
if (cons_backpic.value || con_forcepic)
|
||||
{
|
||||
patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_CACHE);
|
||||
patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
|
||||
|
||||
// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
|
||||
V_DrawScaledPatch(0, 0, 0, con_backpic);
|
||||
|
@ -1602,8 +1607,18 @@ void CON_Drawer(void)
|
|||
if (!con_started || !graphics_started)
|
||||
return;
|
||||
|
||||
if (needpatchrecache)
|
||||
{
|
||||
W_FlushCachedPatches();
|
||||
HU_LoadGraphics();
|
||||
}
|
||||
|
||||
if (con_recalc)
|
||||
{
|
||||
CON_RecalcSize();
|
||||
if (con_curlines <= 0)
|
||||
CON_ClearHUD();
|
||||
}
|
||||
|
||||
if (con_curlines > 0)
|
||||
CON_DrawConsole();
|
||||
|
|
|
@ -1265,8 +1265,12 @@ static boolean CL_SendJoin(void)
|
|||
if (splitscreen || botingame)
|
||||
localplayers++;
|
||||
netbuffer->u.clientcfg.localplayers = localplayers;
|
||||
netbuffer->u.clientcfg._255 = 255;
|
||||
netbuffer->u.clientcfg.packetversion = PACKETVERSION;
|
||||
netbuffer->u.clientcfg.version = VERSION;
|
||||
netbuffer->u.clientcfg.subversion = SUBVERSION;
|
||||
strncpy(netbuffer->u.clientcfg.application, SRB2APPLICATION,
|
||||
sizeof netbuffer->u.clientcfg.application);
|
||||
strncpy(netbuffer->u.clientcfg.names[0], cv_playername.zstring, MAXPLAYERNAME);
|
||||
strncpy(netbuffer->u.clientcfg.names[1], cv_playername2.zstring, MAXPLAYERNAME);
|
||||
return HSendPacket(servernode, true, 0, sizeof (clientconfig_pak));
|
||||
|
@ -1277,15 +1281,20 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
|
|||
UINT8 *p;
|
||||
|
||||
netbuffer->packettype = PT_SERVERINFO;
|
||||
netbuffer->u.serverinfo._255 = 255;
|
||||
netbuffer->u.serverinfo.packetversion = PACKETVERSION;
|
||||
netbuffer->u.serverinfo.version = VERSION;
|
||||
netbuffer->u.serverinfo.subversion = SUBVERSION;
|
||||
strncpy(netbuffer->u.serverinfo.application, SRB2APPLICATION,
|
||||
sizeof netbuffer->u.serverinfo.application);
|
||||
// return back the time value so client can compute their ping
|
||||
netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
|
||||
netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
|
||||
|
||||
netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
|
||||
netbuffer->u.serverinfo.maxplayer = (UINT8)cv_maxplayers.value;
|
||||
netbuffer->u.serverinfo.gametype = (UINT8)gametype;
|
||||
strncpy(netbuffer->u.serverinfo.gametypename, Gametype_Names[gametype],
|
||||
sizeof netbuffer->u.serverinfo.gametypename);
|
||||
netbuffer->u.serverinfo.modifiedgame = (UINT8)modifiedgame;
|
||||
netbuffer->u.serverinfo.cheatsenabled = CV_CheatsEnabled();
|
||||
netbuffer->u.serverinfo.isdedicated = (UINT8)dedicated;
|
||||
|
@ -1712,12 +1721,21 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
|
|||
if (serverlistcount >= MAXSERVERLIST)
|
||||
return; // list full
|
||||
|
||||
if (info->_255 != 255)
|
||||
return;/* old packet format */
|
||||
|
||||
if (info->packetversion != PACKETVERSION)
|
||||
return;/* old new packet format */
|
||||
|
||||
if (info->version != VERSION)
|
||||
return; // Not same version.
|
||||
|
||||
if (info->subversion != SUBVERSION)
|
||||
return; // Close, but no cigar.
|
||||
|
||||
if (strcmp(info->application, SRB2APPLICATION))
|
||||
return;/* that's a different mod */
|
||||
|
||||
i = serverlistcount++;
|
||||
}
|
||||
|
||||
|
@ -2105,13 +2123,10 @@ static void CL_ConnectToServer(boolean viams)
|
|||
|
||||
if (i != -1)
|
||||
{
|
||||
UINT16 num = serverlist[i].info.gametype;
|
||||
const char *gametypestr = NULL;
|
||||
char *gametypestr = serverlist[i].info.gametypename;
|
||||
CONS_Printf(M_GetText("Connecting to: %s\n"), serverlist[i].info.servername);
|
||||
if (num < gametypecount)
|
||||
gametypestr = Gametype_Names[num];
|
||||
if (gametypestr)
|
||||
CONS_Printf(M_GetText("Gametype: %s\n"), gametypestr);
|
||||
gametypestr[sizeof serverlist[i].info.gametypename - 1] = '\0';
|
||||
CONS_Printf(M_GetText("Gametype: %s\n"), gametypestr);
|
||||
CONS_Printf(M_GetText("Version: %d.%d.%u\n"), serverlist[i].info.version/100,
|
||||
serverlist[i].info.version%100, serverlist[i].info.subversion);
|
||||
}
|
||||
|
@ -2987,8 +3002,8 @@ static void Got_KickCmd(UINT8 **p, INT32 playernum)
|
|||
CL_RemovePlayer(pnum, kickreason);
|
||||
}
|
||||
|
||||
consvar_t cv_allownewplayer = {"allowjoin", "On", CV_SAVE|CV_NETVAR, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL };
|
||||
consvar_t cv_joinnextround = {"joinnextround", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; /// \todo not done
|
||||
consvar_t cv_allownewplayer = {"allowjoin", "On", CV_NETVAR, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL };
|
||||
consvar_t cv_joinnextround = {"joinnextround", "Off", CV_NETVAR, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; /// \todo not done
|
||||
static CV_PossibleValue_t maxplayers_cons_t[] = {{2, "MIN"}, {32, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_maxplayers = {"maxplayers", "8", CV_SAVE, maxplayers_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static CV_PossibleValue_t resynchattempts_cons_t[] = {{1, "MIN"}, {20, "MAX"}, {0, "No"}, {0, NULL}};
|
||||
|
@ -3509,6 +3524,12 @@ static void HandleConnect(SINT8 node)
|
|||
|
||||
if (bannednode && bannednode[node])
|
||||
SV_SendRefuse(node, M_GetText("You have been banned\nfrom the server"));
|
||||
else if (netbuffer->u.clientcfg._255 != 255 ||
|
||||
netbuffer->u.clientcfg.packetversion != PACKETVERSION)
|
||||
SV_SendRefuse(node, "Incompatible packet formats.");
|
||||
else if (strncmp(netbuffer->u.clientcfg.application, SRB2APPLICATION,
|
||||
sizeof netbuffer->u.clientcfg.application))
|
||||
SV_SendRefuse(node, "Different SRB2 modifications\nare not compatible.");
|
||||
else if (netbuffer->u.clientcfg.version != VERSION
|
||||
|| netbuffer->u.clientcfg.subversion != SUBVERSION)
|
||||
SV_SendRefuse(node, va(M_GetText("Different SRB2 versions cannot\nplay a netgame!\n(server version %d.%d.%d)"), VERSION/100, VERSION%100, SUBVERSION));
|
||||
|
@ -3631,6 +3652,10 @@ static void HandleServerInfo(SINT8 node)
|
|||
const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
|
||||
netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
|
||||
netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
|
||||
netbuffer->u.serverinfo.application
|
||||
[sizeof netbuffer->u.serverinfo.application - 1] = '\0';
|
||||
netbuffer->u.serverinfo.gametypename
|
||||
[sizeof netbuffer->u.serverinfo.gametypename - 1] = '\0';
|
||||
|
||||
SL_InsertServer(&netbuffer->u.serverinfo, node);
|
||||
}
|
||||
|
@ -4626,9 +4651,9 @@ static void Local_Maketic(INT32 realtics)
|
|||
// and G_MapEventsToControls
|
||||
if (!dedicated) rendergametic = gametic;
|
||||
// translate inputs (keyboard/mouse/joystick) into game controls
|
||||
G_BuildTiccmd(&localcmds, realtics);
|
||||
G_BuildTiccmd(&localcmds, realtics, 1);
|
||||
if (splitscreen || botingame)
|
||||
G_BuildTiccmd2(&localcmds2, realtics);
|
||||
G_BuildTiccmd(&localcmds2, realtics, 2);
|
||||
|
||||
localcmds.angleturn |= TICCMD_RECEIVED;
|
||||
}
|
||||
|
|
|
@ -19,6 +19,16 @@
|
|||
#include "tables.h"
|
||||
#include "d_player.h"
|
||||
|
||||
/*
|
||||
The 'packet version' may be used with packets whose
|
||||
format is expected to change between versions.
|
||||
|
||||
This version is independent of the mod name, and standard
|
||||
version and subversion. It should only account for the
|
||||
basic fields of the packet, and change infrequently.
|
||||
*/
|
||||
#define PACKETVERSION 1
|
||||
|
||||
// Network play related stuff.
|
||||
// There is a data struct that stores network
|
||||
// communication related stuff, and another
|
||||
|
@ -320,8 +330,13 @@ typedef struct {
|
|||
#pragma warning(default : 4200)
|
||||
#endif
|
||||
|
||||
#define MAXAPPLICATION 16
|
||||
|
||||
typedef struct
|
||||
{
|
||||
UINT8 _255;/* see serverinfo_pak */
|
||||
UINT8 packetversion;
|
||||
char application[MAXAPPLICATION];
|
||||
UINT8 version; // Different versions don't work
|
||||
UINT8 subversion; // Contains build version
|
||||
UINT8 localplayers;
|
||||
|
@ -334,11 +349,19 @@ typedef struct
|
|||
// This packet is too large
|
||||
typedef struct
|
||||
{
|
||||
/*
|
||||
In the old packet, 'version' is the first field. Now that field is set
|
||||
to 255 always, so older versions won't be confused with the new
|
||||
versions or vice-versa.
|
||||
*/
|
||||
UINT8 _255;
|
||||
UINT8 packetversion;
|
||||
char application[MAXAPPLICATION];
|
||||
UINT8 version;
|
||||
UINT8 subversion;
|
||||
UINT8 numberofplayer;
|
||||
UINT8 maxplayer;
|
||||
UINT8 gametype;
|
||||
char gametypename[24];
|
||||
UINT8 modifiedgame;
|
||||
UINT8 cheatsenabled;
|
||||
UINT8 isdedicated;
|
||||
|
|
115
src/d_main.c
115
src/d_main.c
|
@ -108,6 +108,8 @@ boolean devparm = false; // started game with -devparm
|
|||
boolean singletics = false; // timedemo
|
||||
boolean lastdraw = false;
|
||||
|
||||
static void D_CheckRendererState(void);
|
||||
|
||||
postimg_t postimgtype = postimg_none;
|
||||
INT32 postimgparam;
|
||||
postimg_t postimgtype2 = postimg_none;
|
||||
|
@ -212,6 +214,7 @@ INT16 wipetypepost = -1;
|
|||
|
||||
static void D_Display(void)
|
||||
{
|
||||
INT32 setrenderstillneeded = 0;
|
||||
boolean forcerefresh = false;
|
||||
static boolean wipe = false;
|
||||
INT32 wipedefindex = 0;
|
||||
|
@ -222,11 +225,38 @@ static void D_Display(void)
|
|||
if (nodrawers)
|
||||
return; // for comparative timing/profiling
|
||||
|
||||
// check for change of screen size (video mode)
|
||||
if (setmodeneeded && !wipe)
|
||||
SCR_SetMode(); // change video mode
|
||||
// Lactozilla: Switching renderers works by checking
|
||||
// if the game has to do it right when the frame
|
||||
// needs to render. If so, five things will happen:
|
||||
// 1. Interface functions will be called so
|
||||
// that switching to OpenGL creates a
|
||||
// GL context, and switching to Software
|
||||
// allocates screen buffers.
|
||||
// 2. Software will set drawer functions,
|
||||
// and OpenGL will load textures and
|
||||
// create plane polygons, if necessary.
|
||||
// 3. Functions related to switching video
|
||||
// modes (resolution) are called.
|
||||
// 4. Patch data is freed from memory,
|
||||
// and recached if necessary.
|
||||
// 5. The frame is ready to be drawn!
|
||||
|
||||
if (vid.recalc)
|
||||
// stop movie if needs to change renderer
|
||||
if (setrenderneeded && (moviemode == MM_APNG))
|
||||
M_StopMovie();
|
||||
|
||||
// check for change of renderer or screen size (video mode)
|
||||
if ((setrenderneeded || setmodeneeded) && !wipe)
|
||||
{
|
||||
if (setrenderneeded)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "setrenderneeded set (%d)\n", setrenderneeded);
|
||||
setrenderstillneeded = setrenderneeded;
|
||||
}
|
||||
SCR_SetMode(); // change video mode
|
||||
}
|
||||
|
||||
if (vid.recalc || setrenderstillneeded)
|
||||
{
|
||||
SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc()
|
||||
#ifdef HWRENDER
|
||||
|
@ -237,12 +267,15 @@ static void D_Display(void)
|
|||
}
|
||||
|
||||
// change the view size if needed
|
||||
if (setsizeneeded)
|
||||
if (setsizeneeded || setrenderstillneeded)
|
||||
{
|
||||
R_ExecuteSetViewSize();
|
||||
forcerefresh = true; // force background redraw
|
||||
}
|
||||
|
||||
// Lactozilla: Renderer switching
|
||||
D_CheckRendererState();
|
||||
|
||||
// draw buffered stuff to screen
|
||||
// Used only by linux GGI version
|
||||
I_UpdateNoBlit();
|
||||
|
@ -457,7 +490,7 @@ static void D_Display(void)
|
|||
py = 4;
|
||||
else
|
||||
py = viewwindowy + 4;
|
||||
patch = W_CachePatchName("M_PAUSE", PU_CACHE);
|
||||
patch = W_CachePatchName("M_PAUSE", PU_PATCH);
|
||||
V_DrawScaledPatch(viewwindowx + (BASEVIDWIDTH - SHORT(patch->width))/2, py, 0, patch);
|
||||
#else
|
||||
INT32 y = ((automapactive) ? (32) : (BASEVIDHEIGHT/2));
|
||||
|
@ -557,6 +590,25 @@ static void D_Display(void)
|
|||
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
}
|
||||
|
||||
needpatchflush = false;
|
||||
needpatchrecache = false;
|
||||
}
|
||||
|
||||
// Lactozilla: Check the renderer's state
|
||||
// after a possible renderer switch.
|
||||
void D_CheckRendererState(void)
|
||||
{
|
||||
// flush all patches from memory
|
||||
// (also frees memory tagged with PU_CACHE)
|
||||
// (which are not necessarily patches but I don't care)
|
||||
if (needpatchflush)
|
||||
Z_FlushCachedPatches();
|
||||
|
||||
// some patches have been freed,
|
||||
// so cache them again
|
||||
if (needpatchrecache)
|
||||
R_ReloadHUDGraphics();
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
|
@ -600,8 +652,7 @@ void D_SRB2Loop(void)
|
|||
// hack to start on a nice clear console screen.
|
||||
COM_ImmedExecute("cls;version");
|
||||
|
||||
if (rendermode == render_soft)
|
||||
V_DrawScaledPatch(0, 0, 0, (patch_t *)W_CacheLumpNum(W_GetNumForName("CONSBACK"), PU_CACHE));
|
||||
V_DrawScaledPatch(0, 0, 0, W_CachePatchNum(W_GetNumForName("CONSBACK"), PU_CACHE));
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
|
||||
for (;;)
|
||||
|
@ -715,7 +766,7 @@ void D_StartTitle(void)
|
|||
|
||||
if (netgame)
|
||||
{
|
||||
if (gametype == GT_COOP)
|
||||
if (gametyperules & GTR_CAMPAIGN)
|
||||
{
|
||||
G_SetGamestate(GS_WAITINGPLAYERS); // hack to prevent a command repeat
|
||||
|
||||
|
@ -781,7 +832,7 @@ void D_StartTitle(void)
|
|||
CV_SetValue(&cv_usemouse, tutorialusemouse);
|
||||
CV_SetValue(&cv_alwaysfreelook, tutorialfreelook);
|
||||
CV_SetValue(&cv_mousemove, tutorialmousemove);
|
||||
CV_SetValue(&cv_analog, tutorialanalog);
|
||||
CV_SetValue(&cv_analog[0], tutorialanalog);
|
||||
M_StartMessage("Do you want to \x82save the recommended \x82movement controls?\x80\n\nPress 'Y' or 'Enter' to confirm\nPress 'N' or any key to keep \nyour current controls",
|
||||
M_TutorialSaveControlResponse, MM_YESNO);
|
||||
}
|
||||
|
@ -1118,26 +1169,6 @@ void D_SRB2Main(void)
|
|||
if (M_CheckParm("-server") || dedicated)
|
||||
netgame = server = true;
|
||||
|
||||
if (M_CheckParm("-warp") && M_IsNextParm())
|
||||
{
|
||||
const char *word = M_GetNextParm();
|
||||
char ch; // use this with sscanf to catch non-digits with
|
||||
if (fastncmp(word, "MAP", 3)) // MAPxx name
|
||||
pstartmap = M_MapNumber(word[3], word[4]);
|
||||
else if (sscanf(word, "%d%c", &pstartmap, &ch) != 1) // a plain number
|
||||
I_Error("Cannot warp to map %s (invalid map name)\n", word);
|
||||
// Don't check if lump exists just yet because the wads haven't been loaded!
|
||||
// Just do a basic range check here.
|
||||
if (pstartmap < 1 || pstartmap > NUMMAPS)
|
||||
I_Error("Cannot warp to map %d (out of range)\n", pstartmap);
|
||||
else
|
||||
{
|
||||
if (!M_CheckParm("-server"))
|
||||
G_SetGameModified(true);
|
||||
autostart = true;
|
||||
}
|
||||
}
|
||||
|
||||
CONS_Printf("Z_Init(): Init zone memory allocation daemon. \n");
|
||||
Z_Init();
|
||||
|
||||
|
@ -1194,6 +1225,20 @@ void D_SRB2Main(void)
|
|||
|
||||
mainwadstally = packetsizetally; // technically not accurate atm, remember to port the two-stage -file process from kart in 2.2.x
|
||||
|
||||
if (M_CheckParm("-warp") && M_IsNextParm())
|
||||
{
|
||||
const char *word = M_GetNextParm();
|
||||
pstartmap = G_FindMapByNameOrCode(word, 0);
|
||||
if (! pstartmap)
|
||||
I_Error("Cannot find a map remotely named '%s'\n", word);
|
||||
else
|
||||
{
|
||||
if (!M_CheckParm("-server"))
|
||||
G_SetGameModified(true);
|
||||
autostart = true;
|
||||
}
|
||||
}
|
||||
|
||||
cht_Init();
|
||||
|
||||
//---------------------------------------------------- READY SCREEN
|
||||
|
@ -1239,6 +1284,16 @@ void D_SRB2Main(void)
|
|||
// set user default mode or mode set at cmdline
|
||||
SCR_CheckDefaultMode();
|
||||
|
||||
// Lactozilla: Does the render mode need to change?
|
||||
if ((setrenderneeded != 0) && (setrenderneeded != rendermode))
|
||||
{
|
||||
needpatchflush = true;
|
||||
needpatchrecache = true;
|
||||
VID_CheckRenderer();
|
||||
SCR_ChangeRendererCVars(setrenderneeded);
|
||||
}
|
||||
D_CheckRendererState();
|
||||
|
||||
wipegamestate = gamestate;
|
||||
|
||||
savedata.lives = 0; // flag this as not-used
|
||||
|
|
101
src/d_netcmd.c
101
src/d_netcmd.c
|
@ -781,6 +781,10 @@ void D_RegisterClientCommands(void)
|
|||
CV_RegisterVar(&cv_fireaxis2);
|
||||
CV_RegisterVar(&cv_firenaxis);
|
||||
CV_RegisterVar(&cv_firenaxis2);
|
||||
CV_RegisterVar(&cv_deadzone);
|
||||
CV_RegisterVar(&cv_deadzone2);
|
||||
CV_RegisterVar(&cv_digitaldeadzone);
|
||||
CV_RegisterVar(&cv_digitaldeadzone2);
|
||||
|
||||
// filesrch.c
|
||||
CV_RegisterVar(&cv_addons_option);
|
||||
|
@ -819,20 +823,34 @@ void D_RegisterClientCommands(void)
|
|||
CV_RegisterVar(&cv_joyscale2);
|
||||
|
||||
// Analog Control
|
||||
CV_RegisterVar(&cv_analog);
|
||||
CV_RegisterVar(&cv_analog2);
|
||||
CV_RegisterVar(&cv_useranalog);
|
||||
CV_RegisterVar(&cv_useranalog2);
|
||||
CV_RegisterVar(&cv_analog[0]);
|
||||
CV_RegisterVar(&cv_analog[1]);
|
||||
CV_RegisterVar(&cv_useranalog[0]);
|
||||
CV_RegisterVar(&cv_useranalog[1]);
|
||||
|
||||
// deez New User eXperiences
|
||||
CV_RegisterVar(&cv_directionchar);
|
||||
CV_RegisterVar(&cv_directionchar2);
|
||||
CV_RegisterVar(&cv_directionchar[0]);
|
||||
CV_RegisterVar(&cv_directionchar[1]);
|
||||
CV_RegisterVar(&cv_autobrake);
|
||||
CV_RegisterVar(&cv_autobrake2);
|
||||
|
||||
// Ported from kart
|
||||
CV_RegisterVar(&cv_deadzone);
|
||||
CV_RegisterVar(&cv_deadzone2);
|
||||
// hi here's some new controls
|
||||
CV_RegisterVar(&cv_cam_shiftfacing[0]);
|
||||
CV_RegisterVar(&cv_cam_shiftfacing[1]);
|
||||
CV_RegisterVar(&cv_cam_turnfacing[0]);
|
||||
CV_RegisterVar(&cv_cam_turnfacing[1]);
|
||||
CV_RegisterVar(&cv_cam_turnfacingability[0]);
|
||||
CV_RegisterVar(&cv_cam_turnfacingability[1]);
|
||||
CV_RegisterVar(&cv_cam_turnfacingspindash[0]);
|
||||
CV_RegisterVar(&cv_cam_turnfacingspindash[1]);
|
||||
CV_RegisterVar(&cv_cam_turnfacinginput[0]);
|
||||
CV_RegisterVar(&cv_cam_turnfacinginput[1]);
|
||||
CV_RegisterVar(&cv_cam_centertoggle[0]);
|
||||
CV_RegisterVar(&cv_cam_centertoggle[1]);
|
||||
CV_RegisterVar(&cv_cam_lockedinput[0]);
|
||||
CV_RegisterVar(&cv_cam_lockedinput[1]);
|
||||
CV_RegisterVar(&cv_cam_lockonboss[0]);
|
||||
CV_RegisterVar(&cv_cam_lockonboss[1]);
|
||||
|
||||
// s_sound.c
|
||||
CV_RegisterVar(&cv_soundvolume);
|
||||
|
@ -848,6 +866,10 @@ void D_RegisterClientCommands(void)
|
|||
// screen.c
|
||||
CV_RegisterVar(&cv_fullscreen);
|
||||
CV_RegisterVar(&cv_renderview);
|
||||
CV_RegisterVar(&cv_renderer);
|
||||
#ifdef HWRENDER
|
||||
CV_RegisterVar(&cv_newrenderer);
|
||||
#endif
|
||||
CV_RegisterVar(&cv_scr_depth);
|
||||
CV_RegisterVar(&cv_scr_width);
|
||||
CV_RegisterVar(&cv_scr_height);
|
||||
|
@ -1497,9 +1519,9 @@ void SendWeaponPref(void)
|
|||
buf[0] = 0;
|
||||
if (cv_flipcam.value)
|
||||
buf[0] |= 1;
|
||||
if (cv_analog.value)
|
||||
if (cv_analog[0].value && cv_directionchar[0].value != 2)
|
||||
buf[0] |= 2;
|
||||
if (cv_directionchar.value)
|
||||
if (cv_directionchar[0].value == 1)
|
||||
buf[0] |= 4;
|
||||
if (cv_autobrake.value)
|
||||
buf[0] |= 8;
|
||||
|
@ -1513,9 +1535,9 @@ void SendWeaponPref2(void)
|
|||
buf[0] = 0;
|
||||
if (cv_flipcam2.value)
|
||||
buf[0] |= 1;
|
||||
if (cv_analog2.value)
|
||||
if (cv_analog[1].value && cv_directionchar[1].value != 2)
|
||||
buf[0] |= 2;
|
||||
if (cv_directionchar2.value)
|
||||
if (cv_directionchar[1].value == 1)
|
||||
buf[0] |= 4;
|
||||
if (cv_autobrake2.value)
|
||||
buf[0] |= 8;
|
||||
|
@ -1809,18 +1831,15 @@ static void Command_Map_f(void)
|
|||
boolean newresetplayers;
|
||||
|
||||
boolean mustmodifygame;
|
||||
boolean usemapcode = false;
|
||||
|
||||
INT32 newmapnum;
|
||||
|
||||
char * mapname;
|
||||
size_t mapnamelen;
|
||||
char *realmapname = NULL;
|
||||
|
||||
INT32 newgametype = gametype;
|
||||
|
||||
INT32 d;
|
||||
char *p;
|
||||
|
||||
if (client && !IsPlayerAdmin(consoleplayer))
|
||||
{
|
||||
|
@ -1880,43 +1899,8 @@ static void Command_Map_f(void)
|
|||
}
|
||||
|
||||
mapname = ConcatCommandArgv(1, first_option);
|
||||
mapnamelen = strlen(mapname);
|
||||
|
||||
if (mapnamelen == 2)/* maybe two digit code */
|
||||
{
|
||||
if (( newmapnum = M_MapNumber(mapname[0], mapname[1]) ))
|
||||
usemapcode = true;
|
||||
}
|
||||
else if (mapnamelen == 5 && strnicmp(mapname, "MAP", 3) == 0)
|
||||
{
|
||||
if (( newmapnum = M_MapNumber(mapname[3], mapname[4]) ) == 0)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Invalid map code '%s'.\n"), mapname);
|
||||
Z_Free(mapname);
|
||||
return;
|
||||
}
|
||||
usemapcode = true;
|
||||
}
|
||||
|
||||
if (!usemapcode)
|
||||
{
|
||||
/* Now detect map number in base 10, which no one asked for. */
|
||||
newmapnum = strtol(mapname, &p, 10);
|
||||
if (*p == '\0')/* we got it */
|
||||
{
|
||||
if (newmapnum < 1 || newmapnum > NUMMAPS)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Invalid map number %d.\n"), newmapnum);
|
||||
Z_Free(mapname);
|
||||
return;
|
||||
}
|
||||
usemapcode = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
newmapnum = G_FindMap(mapname, &realmapname, NULL, NULL);
|
||||
}
|
||||
}
|
||||
newmapnum = G_FindMapByNameOrCode(mapname, &realmapname);
|
||||
|
||||
if (newmapnum == 0)
|
||||
{
|
||||
|
@ -1925,11 +1909,6 @@ static void Command_Map_f(void)
|
|||
return;
|
||||
}
|
||||
|
||||
if (usemapcode)
|
||||
{
|
||||
realmapname = G_BuildMapTitle(newmapnum);
|
||||
}
|
||||
|
||||
if (mustmodifygame && option_force)
|
||||
{
|
||||
G_SetGameModified(false);
|
||||
|
@ -2023,7 +2002,7 @@ static void Command_Map_f(void)
|
|||
CV_SetValue(&cv_usemouse, tutorialusemouse);
|
||||
CV_SetValue(&cv_alwaysfreelook, tutorialfreelook);
|
||||
CV_SetValue(&cv_mousemove, tutorialmousemove);
|
||||
CV_SetValue(&cv_analog, tutorialanalog);
|
||||
CV_SetValue(&cv_analog[0], tutorialanalog);
|
||||
}
|
||||
tutorialmode = false; // warping takes us out of tutorial mode
|
||||
|
||||
|
@ -2209,6 +2188,8 @@ static void Got_Pause(UINT8 **cp, INT32 playernum)
|
|||
else
|
||||
S_ResumeAudio();
|
||||
}
|
||||
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
|
||||
// Command for stuck characters in netgames, griefing, etc.
|
||||
|
@ -3745,7 +3726,7 @@ static void CoopStarposts_OnChange(void)
|
|||
{
|
||||
INT32 i;
|
||||
|
||||
if (!(netgame || multiplayer) || gametype != GT_COOP)
|
||||
if (!(netgame || multiplayer) || !G_GametypeUsesCoopStarposts())
|
||||
return;
|
||||
|
||||
switch (cv_coopstarposts.value)
|
||||
|
@ -3800,7 +3781,7 @@ static void CoopLives_OnChange(void)
|
|||
{
|
||||
INT32 i;
|
||||
|
||||
if (!(netgame || multiplayer) || gametype != GT_COOP)
|
||||
if (!(netgame || multiplayer) || !G_GametypeUsesCoopLives())
|
||||
return;
|
||||
|
||||
switch (cv_cooplives.value)
|
||||
|
|
|
@ -3430,6 +3430,8 @@ static void readextraemblemdata(MYFILE *f, INT32 num)
|
|||
sizeof (extraemblems[num-1].description), va("Extra emblem %d: objective", num));
|
||||
else if (fastcmp(word, "CONDITIONSET"))
|
||||
extraemblems[num-1].conditionset = (UINT8)value;
|
||||
else if (fastcmp(word, "SHOWCONDITIONSET"))
|
||||
extraemblems[num-1].showconditionset = (UINT8)value;
|
||||
else
|
||||
{
|
||||
strupr(word2);
|
||||
|
@ -3516,6 +3518,8 @@ static void readunlockable(MYFILE *f, INT32 num)
|
|||
unlockables[num].height = (UINT16)i;
|
||||
else if (fastcmp(word, "CONDITIONSET"))
|
||||
unlockables[num].conditionset = (UINT8)i;
|
||||
else if (fastcmp(word, "SHOWCONDITIONSET"))
|
||||
unlockables[num].showconditionset = (UINT8)i;
|
||||
else if (fastcmp(word, "NOCECHO"))
|
||||
unlockables[num].nocecho = (UINT8)(i || word2[0] == 'T' || word2[0] == 'Y');
|
||||
else if (fastcmp(word, "NOCHECKLIST"))
|
||||
|
@ -4804,11 +4808,13 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
|
|||
if (introchanged)
|
||||
{
|
||||
menuactive = false;
|
||||
I_UpdateMouseGrab();
|
||||
COM_BufAddText("playintro");
|
||||
}
|
||||
else if (titlechanged)
|
||||
{
|
||||
menuactive = false;
|
||||
I_UpdateMouseGrab();
|
||||
COM_BufAddText("exitgame"); // Command_ExitGame_f() but delayed
|
||||
}
|
||||
}
|
||||
|
@ -8667,6 +8673,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
|
|||
"MT_NIGHTSCHIP", // NiGHTS Chip
|
||||
"MT_FLINGNIGHTSCHIP", // Lost NiGHTS Chip
|
||||
"MT_NIGHTSSTAR", // NiGHTS Star
|
||||
"MT_FLINGNIGHTSSTAR", // Lost NiGHTS Star
|
||||
"MT_NIGHTSSUPERLOOP",
|
||||
"MT_NIGHTSDRILLREFILL",
|
||||
"MT_NIGHTSHELPER",
|
||||
|
@ -8904,32 +8911,35 @@ static const char *const GAMETYPERULE_LIST[] = {
|
|||
"CAMPAIGN",
|
||||
"RINGSLINGER",
|
||||
"SPECTATORS",
|
||||
"FRIENDLYFIRE",
|
||||
"LIVES",
|
||||
"TEAMS",
|
||||
"FIRSTPERSON",
|
||||
"POWERSTONES",
|
||||
"TEAMFLAGS",
|
||||
"FRIENDLY",
|
||||
"SPECIALSTAGES",
|
||||
"EMERALDTOKENS",
|
||||
"EMERALDHUNT",
|
||||
"RACE",
|
||||
"TAG",
|
||||
"POINTLIMIT",
|
||||
"TIMELIMIT",
|
||||
"HIDETIME",
|
||||
"OVERTIME",
|
||||
"HURTMESSAGES",
|
||||
"FRIENDLYFIRE",
|
||||
"STARTCOUNTDOWN",
|
||||
"HIDEFROZEN",
|
||||
"BLINDFOLDED",
|
||||
"FIRSTPERSON",
|
||||
"MATCHEMERALDS",
|
||||
"TEAMFLAGS",
|
||||
"RESPAWNDELAY",
|
||||
"PITYSHIELD",
|
||||
"DEATHPENALTY",
|
||||
"NOSPECTATORSPAWN",
|
||||
"DEATHMATCHSTARTS",
|
||||
"SPECIALSTAGES",
|
||||
"EMERALDTOKENS",
|
||||
"EMERALDHUNT",
|
||||
"SPAWNINVUL",
|
||||
"SPAWNENEMIES",
|
||||
"ALLOWEXIT",
|
||||
"NOTITLECARD",
|
||||
"OVERTIME",
|
||||
"HURTMESSAGES",
|
||||
"SPAWNINVUL",
|
||||
"CUTSCENES",
|
||||
NULL
|
||||
};
|
||||
|
||||
|
@ -9456,6 +9466,10 @@ struct {
|
|||
{"SF_MULTIABILITY",SF_MULTIABILITY},
|
||||
{"SF_NONIGHTSROTATION",SF_NONIGHTSROTATION},
|
||||
|
||||
// Dashmode constants
|
||||
{"DASHMODE_THRESHOLD",DASHMODE_THRESHOLD},
|
||||
{"DASHMODE_MAX",DASHMODE_MAX},
|
||||
|
||||
// Character abilities!
|
||||
// Primary
|
||||
{"CA_NONE",CA_NONE}, // now slot 0!
|
||||
|
@ -9732,6 +9746,11 @@ struct {
|
|||
{"BT_CUSTOM2",BT_CUSTOM2}, // Lua customizable
|
||||
{"BT_CUSTOM3",BT_CUSTOM3}, // Lua customizable
|
||||
|
||||
// Lua command registration flags
|
||||
{"COM_ADMIN",COM_ADMIN},
|
||||
{"COM_SPLITSCREEN",COM_SPLITSCREEN},
|
||||
{"COM_LOCAL",COM_LOCAL},
|
||||
|
||||
// cvflags_t
|
||||
{"CV_SAVE",CV_SAVE},
|
||||
{"CV_CALL",CV_CALL},
|
||||
|
@ -9746,6 +9765,7 @@ struct {
|
|||
{"CV_HIDEN",CV_HIDEN},
|
||||
{"CV_HIDDEN",CV_HIDEN},
|
||||
{"CV_CHEAT",CV_CHEAT},
|
||||
{"CV_NOLUA",CV_NOLUA},
|
||||
|
||||
// v_video flags
|
||||
{"V_NOSCALEPATCH",V_NOSCALEPATCH},
|
||||
|
|
|
@ -338,3 +338,8 @@ void I_StartupGraphics(void)
|
|||
graphics_started = true;
|
||||
|
||||
}
|
||||
|
||||
void I_StartupHardwareGraphics(void)
|
||||
{
|
||||
// oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo y
|
||||
}
|
||||
|
|
|
@ -378,6 +378,11 @@ INT32 VID_SetMode (INT32 modenum) //, UINT8 *palette)
|
|||
return 1;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void)
|
||||
{
|
||||
// ..............
|
||||
}
|
||||
|
||||
|
||||
|
||||
// converts a segm:offs 32bit pair to a 32bit flat ptr
|
||||
|
|
|
@ -130,6 +130,9 @@ extern FILE *logstream;
|
|||
extern char logfilename[1024];
|
||||
#endif
|
||||
|
||||
/* A mod name to further distinguish versions. */
|
||||
#define SRB2APPLICATION "SRB2"
|
||||
|
||||
//#define DEVELOP // Disable this for release builds to remove excessive cheat commands and enable MD5 checking and stuff, all in one go. :3
|
||||
#ifdef DEVELOP
|
||||
#define VERSION 0 // Game version
|
||||
|
@ -461,6 +464,8 @@ extern void *(*M_Memcpy)(void* dest, const void* src, size_t n) FUNCNONNULL;
|
|||
char *va(const char *format, ...) FUNCPRINTF;
|
||||
char *M_GetToken(const char *inputString);
|
||||
void M_UnGetToken(void);
|
||||
UINT32 M_GetTokenPos(void);
|
||||
void M_SetTokenPos(UINT32 newPos);
|
||||
char *sizeu1(size_t num);
|
||||
char *sizeu2(size_t num);
|
||||
char *sizeu3(size_t num);
|
||||
|
@ -624,6 +629,9 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
|||
/// SRB2CB itself ported this from PrBoom+
|
||||
#define NEWCLIP
|
||||
|
||||
/// Cache patches in Lua in a way that renderer switching will work flawlessly.
|
||||
//#define LUA_PATCH_SAFETY
|
||||
|
||||
/// Sprite rotation
|
||||
#define ROTSPRITE
|
||||
#define ROTANGLES 72 // Needs to be a divisor of 360 (45, 60, 90, 120...)
|
||||
|
|
|
@ -140,7 +140,7 @@ extern INT32 tutorialgcs; // which control scheme is loaded?
|
|||
extern INT32 tutorialusemouse; // store cv_usemouse user value
|
||||
extern INT32 tutorialfreelook; // store cv_alwaysfreelook user value
|
||||
extern INT32 tutorialmousemove; // store cv_mousemove user value
|
||||
extern INT32 tutorialanalog; // store cv_analog user value
|
||||
extern INT32 tutorialanalog; // store cv_analog[0] user value
|
||||
|
||||
extern boolean looptitle;
|
||||
|
||||
|
@ -397,32 +397,35 @@ enum GameTypeRules
|
|||
GTR_CAMPAIGN = 1, // Linear Co-op map progression, don't allow random maps
|
||||
GTR_RINGSLINGER = 1<<1, // Outside of Co-op, Competition, and Race (overriden by cv_ringslinger)
|
||||
GTR_SPECTATORS = 1<<2, // Outside of Co-op, Competition, and Race
|
||||
GTR_FRIENDLYFIRE = 1<<3, // Always allow friendly fire
|
||||
GTR_LIVES = 1<<4, // Co-op and Competition
|
||||
GTR_TEAMS = 1<<5, // Team Match, CTF
|
||||
GTR_RACE = 1<<6, // Race and Competition
|
||||
GTR_TAG = 1<<7, // Tag and Hide and Seek
|
||||
GTR_POINTLIMIT = 1<<8, // Ringslinger point limit
|
||||
GTR_TIMELIMIT = 1<<9, // Ringslinger time limit
|
||||
GTR_HIDETIME = 1<<10, // Hide time (Tag and Hide and Seek)
|
||||
GTR_HIDEFROZEN = 1<<11, // Frozen after hide time (Hide and Seek, but not Tag)
|
||||
GTR_BLINDFOLDED = 1<<12, // Blindfolded view (Tag and Hide and Seek)
|
||||
GTR_FIRSTPERSON = 1<<13, // First person camera
|
||||
GTR_MATCHEMERALDS = 1<<14, // Ringslinger emeralds (Match and CTF)
|
||||
GTR_TEAMFLAGS = 1<<15, // Gametype has team flags (CTF)
|
||||
GTR_PITYSHIELD = 1<<16, // Award pity shield
|
||||
GTR_DEATHPENALTY = 1<<17, // Death score penalty
|
||||
GTR_NOSPECTATORSPAWN = 1<<18, // Use with GTR_SPECTATORS, spawn in the map instead of with the spectators
|
||||
GTR_DEATHMATCHSTARTS = 1<<19, // Use deathmatch starts
|
||||
GTR_SPECIALSTAGES = 1<<20, // Allow special stages
|
||||
GTR_EMERALDTOKENS = 1<<21, // Spawn emerald tokens
|
||||
GTR_EMERALDHUNT = 1<<22, // Emerald Hunt
|
||||
GTR_SPAWNENEMIES = 1<<23, // Spawn enemies
|
||||
GTR_ALLOWEXIT = 1<<24, // Allow exit sectors
|
||||
GTR_NOTITLECARD = 1<<25, // Don't show the title card
|
||||
GTR_OVERTIME = 1<<26, // Allow overtime
|
||||
GTR_HURTMESSAGES = 1<<27, // Hit and death messages
|
||||
GTR_SPAWNINVUL = 1<<28, // Babysitting deterrent
|
||||
GTR_LIVES = 1<<3, // Co-op and Competition
|
||||
GTR_TEAMS = 1<<4, // Team Match, CTF
|
||||
GTR_FIRSTPERSON = 1<<5, // First person camera
|
||||
GTR_POWERSTONES = 1<<6, // Power stones (Match and CTF)
|
||||
GTR_TEAMFLAGS = 1<<7, // Gametype has team flags (CTF)
|
||||
GTR_FRIENDLY = 1<<8, // Co-op
|
||||
GTR_SPECIALSTAGES = 1<<9, // Allow special stages
|
||||
GTR_EMERALDTOKENS = 1<<10, // Spawn emerald tokens
|
||||
GTR_EMERALDHUNT = 1<<11, // Emerald Hunt
|
||||
GTR_RACE = 1<<12, // Race and Competition
|
||||
GTR_TAG = 1<<13, // Tag and Hide and Seek
|
||||
GTR_POINTLIMIT = 1<<14, // Ringslinger point limit
|
||||
GTR_TIMELIMIT = 1<<15, // Ringslinger time limit
|
||||
GTR_OVERTIME = 1<<16, // Allow overtime
|
||||
GTR_HURTMESSAGES = 1<<17, // Hit and death messages
|
||||
GTR_FRIENDLYFIRE = 1<<18, // Always allow friendly fire
|
||||
GTR_STARTCOUNTDOWN = 1<<19, // Hide time countdown (Tag and Hide and Seek)
|
||||
GTR_HIDEFROZEN = 1<<20, // Frozen after hide time (Hide and Seek, but not Tag)
|
||||
GTR_BLINDFOLDED = 1<<21, // Blindfolded view (Tag and Hide and Seek)
|
||||
GTR_RESPAWNDELAY = 1<<22, // Respawn delay
|
||||
GTR_PITYSHIELD = 1<<23, // Award pity shield
|
||||
GTR_DEATHPENALTY = 1<<24, // Death score penalty
|
||||
GTR_NOSPECTATORSPAWN = 1<<25, // Use with GTR_SPECTATORS, spawn in the map instead of with the spectators
|
||||
GTR_DEATHMATCHSTARTS = 1<<26, // Use deathmatch starts
|
||||
GTR_SPAWNINVUL = 1<<27, // Babysitting deterrent
|
||||
GTR_SPAWNENEMIES = 1<<28, // Spawn enemies
|
||||
GTR_ALLOWEXIT = 1<<29, // Allow exit sectors
|
||||
GTR_NOTITLECARD = 1<<30, // Don't show the title card
|
||||
GTR_CUTSCENES = 1<<31, // Play cutscenes, ending, credits, and evaluation
|
||||
};
|
||||
|
||||
// String names for gametypes
|
||||
|
|
|
@ -150,6 +150,8 @@ void I_GetJoystick2Events(void){}
|
|||
|
||||
void I_GetMouseEvents(void){}
|
||||
|
||||
void I_UpdateMouseGrab(void){}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
(void)name;
|
||||
|
|
|
@ -11,6 +11,7 @@ boolean allow_fullscreen = false;
|
|||
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
void I_StartupGraphics(void){}
|
||||
void I_StartupHardwareGraphics(void){}
|
||||
|
||||
void I_ShutdownGraphics(void){}
|
||||
|
||||
|
@ -39,6 +40,11 @@ INT32 VID_SetMode(INT32 modenum)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void)
|
||||
{
|
||||
// ..............
|
||||
}
|
||||
|
||||
const char *VID_GetModeName(INT32 modenum)
|
||||
{
|
||||
(void)modenum;
|
||||
|
|
427
src/f_finale.c
427
src/f_finale.c
|
@ -530,78 +530,78 @@ static void F_IntroDrawScene(void)
|
|||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
background = W_CachePatchName("INTRO1", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO1", PU_PATCH);
|
||||
break;
|
||||
case 2:
|
||||
background = W_CachePatchName("INTRO2", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO2", PU_PATCH);
|
||||
break;
|
||||
case 3:
|
||||
background = W_CachePatchName("INTRO3", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO3", PU_PATCH);
|
||||
break;
|
||||
case 4:
|
||||
background = W_CachePatchName("INTRO4", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO4", PU_PATCH);
|
||||
break;
|
||||
case 5:
|
||||
if (intro_curtime >= 5*TICRATE)
|
||||
background = W_CachePatchName("RADAR", PU_CACHE);
|
||||
background = W_CachePatchName("RADAR", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("DRAT", PU_CACHE);
|
||||
background = W_CachePatchName("DRAT", PU_PATCH);
|
||||
break;
|
||||
case 6:
|
||||
background = W_CachePatchName("INTRO6", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO6", PU_PATCH);
|
||||
cx = 180;
|
||||
cy = 8;
|
||||
break;
|
||||
case 7:
|
||||
{
|
||||
if (intro_curtime >= 7*TICRATE + ((TICRATE/7)*2))
|
||||
background = W_CachePatchName("SGRASS5", PU_CACHE);
|
||||
background = W_CachePatchName("SGRASS5", PU_PATCH);
|
||||
else if (intro_curtime >= 7*TICRATE + (TICRATE/7))
|
||||
background = W_CachePatchName("SGRASS4", PU_CACHE);
|
||||
background = W_CachePatchName("SGRASS4", PU_PATCH);
|
||||
else if (intro_curtime >= 7*TICRATE)
|
||||
background = W_CachePatchName("SGRASS3", PU_CACHE);
|
||||
background = W_CachePatchName("SGRASS3", PU_PATCH);
|
||||
else if (intro_curtime >= 6*TICRATE)
|
||||
background = W_CachePatchName("SGRASS2", PU_CACHE);
|
||||
background = W_CachePatchName("SGRASS2", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("SGRASS1", PU_CACHE);
|
||||
background = W_CachePatchName("SGRASS1", PU_PATCH);
|
||||
break;
|
||||
}
|
||||
case 8:
|
||||
background = W_CachePatchName("WATCHING", PU_CACHE);
|
||||
background = W_CachePatchName("WATCHING", PU_PATCH);
|
||||
break;
|
||||
case 9:
|
||||
background = W_CachePatchName("ZOOMING", PU_CACHE);
|
||||
background = W_CachePatchName("ZOOMING", PU_PATCH);
|
||||
break;
|
||||
case 10:
|
||||
break;
|
||||
case 11:
|
||||
background = W_CachePatchName("INTRO5", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO5", PU_PATCH);
|
||||
break;
|
||||
case 12:
|
||||
background = W_CachePatchName("REVENGE", PU_CACHE);
|
||||
background = W_CachePatchName("REVENGE", PU_PATCH);
|
||||
cx = 208;
|
||||
cy = 8;
|
||||
break;
|
||||
case 13:
|
||||
background = W_CachePatchName("CONFRONT", PU_CACHE);
|
||||
background = W_CachePatchName("CONFRONT", PU_PATCH);
|
||||
cy += 48;
|
||||
break;
|
||||
case 14:
|
||||
background = W_CachePatchName("TAILSSAD", PU_CACHE);
|
||||
background = W_CachePatchName("TAILSSAD", PU_PATCH);
|
||||
bgxoffs = 144;
|
||||
cx = 8;
|
||||
cy = 8;
|
||||
break;
|
||||
case 15:
|
||||
if (intro_curtime >= 7*TICRATE)
|
||||
background = W_CachePatchName("SONICDO2", PU_CACHE);
|
||||
background = W_CachePatchName("SONICDO2", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("SONICDO1", PU_CACHE);
|
||||
background = W_CachePatchName("SONICDO1", PU_PATCH);
|
||||
cx = 224;
|
||||
cy = 8;
|
||||
break;
|
||||
case 16:
|
||||
background = W_CachePatchName("INTRO7", PU_CACHE);
|
||||
background = W_CachePatchName("INTRO7", PU_PATCH);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -631,30 +631,30 @@ static void F_IntroDrawScene(void)
|
|||
S_ChangeMusicInternal("_stjr", false);
|
||||
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(334<<FRACBITS, aspect)/2;
|
||||
y = (BASEVIDHEIGHT<<FRACBITS)/2 - FixedMul(358<<FRACBITS, aspect)/2;
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH1", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH1", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
if (finalecount > 6) {
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH2", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH2", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
if (finalecount > 10) {
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH3", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH3", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
if (finalecount > 14) {
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH4", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH4", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
}
|
||||
else if (finalecount-30 < 20) { // Big eggy
|
||||
background = W_CachePatchName("FEEDIN", PU_CACHE);
|
||||
background = W_CachePatchName("FEEDIN", PU_PATCH);
|
||||
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2;
|
||||
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, aspect);
|
||||
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, aspect);
|
||||
}
|
||||
else if (finalecount-50 < 30) { // Zoom out
|
||||
fixed_t scale = FixedDiv(aspect, FixedDiv((finalecount-50)<<FRACBITS, (15<<FRACBITS))+FRACUNIT);
|
||||
background = W_CachePatchName("FEEDIN", PU_CACHE);
|
||||
background = W_CachePatchName("FEEDIN", PU_PATCH);
|
||||
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2 + (FixedMul(560<<FRACBITS, aspect) - FixedMul(560<<FRACBITS, scale));
|
||||
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, scale);
|
||||
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, scale);
|
||||
|
@ -664,7 +664,7 @@ static void F_IntroDrawScene(void)
|
|||
{
|
||||
// Draw tiny eggy
|
||||
fixed_t scale = FixedMul(FRACUNIT/3, aspect);
|
||||
background = W_CachePatchName("FEEDIN", PU_CACHE);
|
||||
background = W_CachePatchName("FEEDIN", PU_PATCH);
|
||||
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2 + (FixedMul(560<<FRACBITS, aspect) - FixedMul(560<<FRACBITS, scale));
|
||||
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, scale);
|
||||
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, scale);
|
||||
|
@ -675,34 +675,34 @@ static void F_IntroDrawScene(void)
|
|||
x = (-189*FRACUNIT) + (FixedMul((6<<FRACBITS)+FRACUNIT/3, ftime<<FRACBITS) - FixedMul((6<<FRACBITS)+FRACUNIT/3, FixedDiv(FixedMul(ftime<<FRACBITS, ftime<<FRACBITS), 120<<FRACBITS)));
|
||||
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(417<<FRACBITS, aspect);
|
||||
// Draw the body
|
||||
V_DrawSciencePatch(x, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the door
|
||||
V_DrawSciencePatch(x+FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x+FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the wheel
|
||||
V_DrawSciencePatch(x+FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName(va("TYRE%02u",(abs(finalecount-144)/3)%16), PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x+FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName(va("TYRE%02u",(abs(finalecount-144)/3)%16), PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the wheel cover
|
||||
V_DrawSciencePatch(x+FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(x+FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
} else { // Pure Fat has stopped!
|
||||
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(417<<FRACBITS, aspect);
|
||||
// Draw the body
|
||||
V_DrawSciencePatch(0, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(0, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the wheel
|
||||
V_DrawSciencePatch(FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("TYRE00", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("TYRE00", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the wheel cover
|
||||
V_DrawSciencePatch(FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Draw the door
|
||||
if (finalecount-TICRATE/2 > 4*TICRATE) { // Door is being raised!
|
||||
int ftime = (finalecount-TICRATE/2-4*TICRATE);
|
||||
y -= FixedDiv((ftime*ftime)<<FRACBITS, 23<<FRACBITS);
|
||||
}
|
||||
V_DrawSciencePatch(FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_CACHE)), aspect);
|
||||
V_DrawSciencePatch(FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_PATCH)), aspect);
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
}
|
||||
|
@ -716,27 +716,27 @@ static void F_IntroDrawScene(void)
|
|||
if (timetonext > 5*TICRATE && timetonext < 6*TICRATE)
|
||||
{
|
||||
if (!(finalecount & 3))
|
||||
background = W_CachePatchName("BRITEGG1", PU_CACHE);
|
||||
background = W_CachePatchName("BRITEGG1", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("DARKEGG1", PU_CACHE);
|
||||
background = W_CachePatchName("DARKEGG1", PU_PATCH);
|
||||
|
||||
V_DrawSmallScaledPatch(0, 0, 0, background);
|
||||
}
|
||||
else if (timetonext > 3*TICRATE && timetonext < 4*TICRATE)
|
||||
{
|
||||
if (!(finalecount & 3))
|
||||
background = W_CachePatchName("BRITEGG2", PU_CACHE);
|
||||
background = W_CachePatchName("BRITEGG2", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("DARKEGG2", PU_CACHE);
|
||||
background = W_CachePatchName("DARKEGG2", PU_PATCH);
|
||||
|
||||
V_DrawSmallScaledPatch(0, 0, 0, background);
|
||||
}
|
||||
else if (timetonext > 1*TICRATE && timetonext < 2*TICRATE)
|
||||
{
|
||||
if (!(finalecount & 3))
|
||||
background = W_CachePatchName("BRITEGG3", PU_CACHE);
|
||||
background = W_CachePatchName("BRITEGG3", PU_PATCH);
|
||||
else
|
||||
background = W_CachePatchName("DARKEGG3", PU_CACHE);
|
||||
background = W_CachePatchName("DARKEGG3", PU_PATCH);
|
||||
|
||||
V_DrawSmallScaledPatch(0, 0, 0, background);
|
||||
}
|
||||
|
@ -768,79 +768,79 @@ static void F_IntroDrawScene(void)
|
|||
knucklesx += sonicx;
|
||||
sonicx += P_ReturnThrustX(NULL, finalecount * ANG10, 3);
|
||||
|
||||
V_DrawSmallScaledPatch(skyx, 0, 0, (patch = W_CachePatchName("INTROSKY", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(skyx, 0, 0, (patch = W_CachePatchName("INTROSKY", PU_PATCH)));
|
||||
V_DrawSmallScaledPatch(skyx - 320, 0, 0, patch);
|
||||
W_UnlockCachedPatch(patch);
|
||||
V_DrawSmallScaledPatch(grassx, 0, 0, (patch = W_CachePatchName("INTROGRS", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(grassx, 0, 0, (patch = W_CachePatchName("INTROGRS", PU_PATCH)));
|
||||
V_DrawSmallScaledPatch(grassx - 320, 0, 0, patch);
|
||||
W_UnlockCachedPatch(patch);
|
||||
|
||||
if (finalecount & 1)
|
||||
{
|
||||
// Sonic
|
||||
V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
|
||||
// Appendages
|
||||
if (finalecount & 2)
|
||||
{
|
||||
// Sonic's feet
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT4", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT4", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Tails' tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Sonic's feet
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Tails' tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
|
||||
// Tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
|
||||
// Knuckles
|
||||
V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Sonic
|
||||
V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
|
||||
// Appendages
|
||||
if (finalecount & 2)
|
||||
{
|
||||
// Sonic's feet
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT3", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT3", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Tails' tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Sonic's feet
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
// Tails' tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
|
||||
// Tails
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
|
||||
// Knuckles
|
||||
V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE1", PU_CACHE)));
|
||||
V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE1", PU_PATCH)));
|
||||
W_UnlockCachedPatch(patch);
|
||||
}
|
||||
|
||||
|
@ -873,8 +873,8 @@ static void F_IntroDrawScene(void)
|
|||
y += (30*(FRACUNIT-scale));
|
||||
}
|
||||
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (worktics % 35)), PU_LEVEL);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(worktics & 1)), PU_LEVEL);
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (worktics % 35)), PU_PATCH);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(worktics & 1)), PU_PATCH);
|
||||
|
||||
if (worktics >= 5)
|
||||
trans = (worktics-5)>>1;
|
||||
|
@ -988,7 +988,7 @@ void F_IntroDrawer(void)
|
|||
{
|
||||
if (intro_scenenum == 5 && intro_curtime == 5*TICRATE)
|
||||
{
|
||||
patch_t *radar = W_CachePatchName("RADAR", PU_CACHE);
|
||||
patch_t *radar = W_CachePatchName("RADAR", PU_PATCH);
|
||||
|
||||
F_WipeStartScreen();
|
||||
F_WipeColorFill(31);
|
||||
|
@ -1001,7 +1001,7 @@ void F_IntroDrawer(void)
|
|||
}
|
||||
else if (intro_scenenum == 7 && intro_curtime == 6*TICRATE) // Force a wipe here
|
||||
{
|
||||
patch_t *grass = W_CachePatchName("SGRASS2", PU_CACHE);
|
||||
patch_t *grass = W_CachePatchName("SGRASS2", PU_PATCH);
|
||||
|
||||
F_WipeStartScreen();
|
||||
F_WipeColorFill(31);
|
||||
|
@ -1014,7 +1014,7 @@ void F_IntroDrawer(void)
|
|||
}
|
||||
/*else if (intro_scenenum == 12 && intro_curtime == 7*TICRATE)
|
||||
{
|
||||
patch_t *confront = W_CachePatchName("CONFRONT", PU_CACHE);
|
||||
patch_t *confront = W_CachePatchName("CONFRONT", PU_PATCH);
|
||||
|
||||
F_WipeStartScreen();
|
||||
F_WipeColorFill(31);
|
||||
|
@ -1027,7 +1027,7 @@ void F_IntroDrawer(void)
|
|||
}*/
|
||||
if (intro_scenenum == 15 && intro_curtime == 7*TICRATE)
|
||||
{
|
||||
patch_t *sdo = W_CachePatchName("SONICDO2", PU_CACHE);
|
||||
patch_t *sdo = W_CachePatchName("SONICDO2", PU_PATCH);
|
||||
|
||||
F_WipeStartScreen();
|
||||
F_WipeColorFill(31);
|
||||
|
@ -1359,14 +1359,14 @@ void F_CreditDrawer(void)
|
|||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
|
||||
|
||||
// Zig Zagz
|
||||
V_DrawScaledPatch(-16, zagpos, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_CACHE));
|
||||
V_DrawScaledPatch(-16, zagpos - 320, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_CACHE));
|
||||
V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_CACHE));
|
||||
V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos - 320, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_CACHE));
|
||||
V_DrawScaledPatch(-16, zagpos, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_PATCH));
|
||||
V_DrawScaledPatch(-16, zagpos - 320, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_PATCH));
|
||||
V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_PATCH));
|
||||
V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos - 320, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_PATCH));
|
||||
|
||||
// Draw background pictures first
|
||||
for (i = 0; credits_pics[i].patch; i++)
|
||||
V_DrawSciencePatch(credits_pics[i].x<<FRACBITS, (280<<FRACBITS) + (((i*credits_height)<<FRACBITS)/(credits_numpics)) - 4*(animtimer<<FRACBITS)/5, 0, W_CachePatchName(credits_pics[i].patch, PU_CACHE), FRACUNIT>>1);
|
||||
V_DrawSciencePatch(credits_pics[i].x<<FRACBITS, (280<<FRACBITS) + (((i*credits_height)<<FRACBITS)/(credits_numpics)) - 4*(animtimer<<FRACBITS)/5, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH), FRACUNIT>>1);
|
||||
|
||||
// Dim the background
|
||||
V_DrawFadeScreen(0xFF00, 16);
|
||||
|
@ -1574,14 +1574,14 @@ void F_GameEvaluationDrawer(void)
|
|||
|
||||
if (goodending)
|
||||
{
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (finalecount % 35)), PU_LEVEL);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(finalecount & 1)), PU_LEVEL);
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (finalecount % 35)), PU_PATCH);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(finalecount & 1)), PU_PATCH);
|
||||
x -= FRACUNIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
rockpat = W_CachePatchName("ROID0000", PU_LEVEL);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", (finalecount & 1)), PU_LEVEL);
|
||||
glow = W_CachePatchName(va("ENDGLOW%.1d", (finalecount & 1)), PU_PATCH);
|
||||
}
|
||||
|
||||
if (finalecount >= 5)
|
||||
|
@ -1613,20 +1613,20 @@ void F_GameEvaluationDrawer(void)
|
|||
// if j == 0 - alternate between 0 and 1
|
||||
// 1 - 1 and 2
|
||||
// 2 - 2 and not rendered
|
||||
V_DrawFixedPatch(x+sparkloffs[j-1][0], y+sparkloffs[j-1][1], FRACUNIT, 0, W_CachePatchName(va("ENDSPKL%.1d", (j - ((sparklloop & 1) ? 0 : 1))), PU_LEVEL), R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_AQUA, GTC_CACHE));
|
||||
V_DrawFixedPatch(x+sparkloffs[j-1][0], y+sparkloffs[j-1][1], FRACUNIT, 0, W_CachePatchName(va("ENDSPKL%.1d", (j - ((sparklloop & 1) ? 0 : 1))), PU_PATCH), R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_AQUA, GTC_CACHE));
|
||||
}
|
||||
j--;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
patch_t *eggrock = W_CachePatchName("ENDEGRK5", PU_LEVEL);
|
||||
patch_t *eggrock = W_CachePatchName("ENDEGRK5", PU_PATCH);
|
||||
V_DrawFixedPatch(x, y, scale, 0, eggrock, colormap[0]);
|
||||
if (trans < 10)
|
||||
V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, eggrock, colormap[1]);
|
||||
else if (sparklloop)
|
||||
V_DrawFixedPatch(x, y, scale, (10-sparklloop)<<V_ALPHASHIFT,
|
||||
W_CachePatchName("ENDEGRK0", PU_LEVEL), colormap[1]);
|
||||
W_CachePatchName("ENDEGRK0", PU_PATCH), colormap[1]);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1640,7 +1640,7 @@ void F_GameEvaluationDrawer(void)
|
|||
eemeralds_cur += (360<<FRACBITS)/7;
|
||||
|
||||
patchname[4] = 'A'+(char)i;
|
||||
V_DrawFixedPatch(x, y, FRACUNIT, ((emeralds & (1<<i)) ? 0 : V_80TRANS), W_CachePatchName(patchname, PU_LEVEL), NULL);
|
||||
V_DrawFixedPatch(x, y, FRACUNIT, ((emeralds & (1<<i)) ? 0 : V_80TRANS), W_CachePatchName(patchname, PU_PATCH), NULL);
|
||||
}
|
||||
|
||||
V_DrawCreditString((BASEVIDWIDTH - V_CreditStringWidth(endingtext))<<(FRACBITS-1), (BASEVIDHEIGHT-100)<<(FRACBITS-1), 0, endingtext);
|
||||
|
@ -1753,6 +1753,83 @@ void F_GameEvaluationTicker(void)
|
|||
#define STOPPINGPOINT (14*TICRATE)
|
||||
#define SPARKLLOOPTIME 15 // must be odd
|
||||
|
||||
static void F_CacheEnding(void)
|
||||
{
|
||||
endbrdr[1] = W_CachePatchName("ENDBRDR1", PU_PATCH);
|
||||
|
||||
endegrk[0] = W_CachePatchName("ENDEGRK0", PU_PATCH);
|
||||
endegrk[1] = W_CachePatchName("ENDEGRK1", PU_PATCH);
|
||||
|
||||
endglow[0] = W_CachePatchName("ENDGLOW0", PU_PATCH);
|
||||
endglow[1] = W_CachePatchName("ENDGLOW1", PU_PATCH);
|
||||
|
||||
endbgsp[0] = W_CachePatchName("ENDBGSP0", PU_PATCH);
|
||||
endbgsp[1] = W_CachePatchName("ENDBGSP1", PU_PATCH);
|
||||
endbgsp[2] = W_CachePatchName("ENDBGSP2", PU_PATCH);
|
||||
|
||||
endspkl[0] = W_CachePatchName("ENDSPKL0", PU_PATCH);
|
||||
endspkl[1] = W_CachePatchName("ENDSPKL1", PU_PATCH);
|
||||
endspkl[2] = W_CachePatchName("ENDSPKL2", PU_PATCH);
|
||||
|
||||
endxpld[0] = W_CachePatchName("ENDXPLD0", PU_PATCH);
|
||||
endxpld[1] = W_CachePatchName("ENDXPLD1", PU_PATCH);
|
||||
endxpld[2] = W_CachePatchName("ENDXPLD2", PU_PATCH);
|
||||
endxpld[3] = W_CachePatchName("ENDXPLD3", PU_PATCH);
|
||||
|
||||
endescp[0] = W_CachePatchName("ENDESCP0", PU_PATCH);
|
||||
endescp[1] = W_CachePatchName("ENDESCP1", PU_PATCH);
|
||||
endescp[2] = W_CachePatchName("ENDESCP2", PU_PATCH);
|
||||
endescp[3] = W_CachePatchName("ENDESCP3", PU_PATCH);
|
||||
endescp[4] = W_CachePatchName("ENDESCP4", PU_PATCH);
|
||||
|
||||
// so we only need to check once
|
||||
if ((goodending = ALL7EMERALDS(emeralds)))
|
||||
{
|
||||
UINT8 skinnum = players[consoleplayer].skin;
|
||||
spritedef_t *sprdef;
|
||||
spriteframe_t *sprframe;
|
||||
if (skins[skinnum].sprites[SPR2_XTRA].numframes > (XTRA_ENDING+2))
|
||||
{
|
||||
sprdef = &skins[skinnum].sprites[SPR2_XTRA];
|
||||
// character head, skin specific
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING];
|
||||
endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING+1];
|
||||
endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING+2];
|
||||
endfwrk[2] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
|
||||
}
|
||||
else // Show a star if your character doesn't have an ending firework display. (Basically the MISSINGs for this)
|
||||
{
|
||||
endfwrk[0] = W_CachePatchName("ENDFWRK3", PU_PATCH);
|
||||
endfwrk[1] = W_CachePatchName("ENDFWRK4", PU_PATCH);
|
||||
endfwrk[2] = W_CachePatchName("ENDFWRK5", PU_PATCH);
|
||||
}
|
||||
|
||||
endbrdr[0] = W_CachePatchName("ENDBRDR2", PU_PATCH);
|
||||
}
|
||||
else
|
||||
{
|
||||
// eggman, skin nonspecific
|
||||
endfwrk[0] = W_CachePatchName("ENDFWRK0", PU_PATCH);
|
||||
endfwrk[1] = W_CachePatchName("ENDFWRK1", PU_PATCH);
|
||||
endfwrk[2] = W_CachePatchName("ENDFWRK2", PU_PATCH);
|
||||
|
||||
endbrdr[0] = W_CachePatchName("ENDBRDR0", PU_LEVEL);
|
||||
}
|
||||
}
|
||||
|
||||
static void F_CacheGoodEnding(void)
|
||||
{
|
||||
endegrk[0] = W_CachePatchName("ENDEGRK2", PU_PATCH);
|
||||
endegrk[1] = W_CachePatchName("ENDEGRK3", PU_PATCH);
|
||||
|
||||
endglow[0] = W_CachePatchName("ENDGLOW2", PU_PATCH);
|
||||
endglow[1] = W_CachePatchName("ENDGLOW3", PU_PATCH);
|
||||
|
||||
endxpld[0] = W_CachePatchName("ENDEGRK4", PU_PATCH);
|
||||
}
|
||||
|
||||
void F_StartEnding(void)
|
||||
{
|
||||
G_SetGamestate(GS_ENDING);
|
||||
|
@ -1768,7 +1845,7 @@ void F_StartEnding(void)
|
|||
gameaction = ga_nothing;
|
||||
paused = false;
|
||||
CON_ToggleOff();
|
||||
S_StopMusic();
|
||||
S_StopMusic(); // todo: placeholder
|
||||
S_StopSounds();
|
||||
|
||||
finalecount = -10; // what? this totally isn't a hack. why are you asking?
|
||||
|
@ -1776,68 +1853,7 @@ void F_StartEnding(void)
|
|||
memset(sparkloffs, 0, sizeof(INT32)*3*2);
|
||||
sparklloop = 0;
|
||||
|
||||
endbrdr[1] = W_CachePatchName("ENDBRDR1", PU_LEVEL);
|
||||
|
||||
endegrk[0] = W_CachePatchName("ENDEGRK0", PU_LEVEL);
|
||||
endegrk[1] = W_CachePatchName("ENDEGRK1", PU_LEVEL);
|
||||
|
||||
endglow[0] = W_CachePatchName("ENDGLOW0", PU_LEVEL);
|
||||
endglow[1] = W_CachePatchName("ENDGLOW1", PU_LEVEL);
|
||||
|
||||
endbgsp[0] = W_CachePatchName("ENDBGSP0", PU_LEVEL);
|
||||
endbgsp[1] = W_CachePatchName("ENDBGSP1", PU_LEVEL);
|
||||
endbgsp[2] = W_CachePatchName("ENDBGSP2", PU_LEVEL);
|
||||
|
||||
endspkl[0] = W_CachePatchName("ENDSPKL0", PU_LEVEL);
|
||||
endspkl[1] = W_CachePatchName("ENDSPKL1", PU_LEVEL);
|
||||
endspkl[2] = W_CachePatchName("ENDSPKL2", PU_LEVEL);
|
||||
|
||||
endxpld[0] = W_CachePatchName("ENDXPLD0", PU_LEVEL);
|
||||
endxpld[1] = W_CachePatchName("ENDXPLD1", PU_LEVEL);
|
||||
endxpld[2] = W_CachePatchName("ENDXPLD2", PU_LEVEL);
|
||||
endxpld[3] = W_CachePatchName("ENDXPLD3", PU_LEVEL);
|
||||
|
||||
endescp[0] = W_CachePatchName("ENDESCP0", PU_LEVEL);
|
||||
endescp[1] = W_CachePatchName("ENDESCP1", PU_LEVEL);
|
||||
endescp[2] = W_CachePatchName("ENDESCP2", PU_LEVEL);
|
||||
endescp[3] = W_CachePatchName("ENDESCP3", PU_LEVEL);
|
||||
endescp[4] = W_CachePatchName("ENDESCP4", PU_LEVEL);
|
||||
|
||||
// so we only need to check once
|
||||
if ((goodending = ALL7EMERALDS(emeralds)))
|
||||
{
|
||||
UINT8 skinnum = players[consoleplayer].skin;
|
||||
spritedef_t *sprdef;
|
||||
spriteframe_t *sprframe;
|
||||
if (skins[skinnum].sprites[SPR2_XTRA].numframes > (XTRA_ENDING+2))
|
||||
{
|
||||
sprdef = &skins[skinnum].sprites[SPR2_XTRA];
|
||||
// character head, skin specific
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING];
|
||||
endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING+1];
|
||||
endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
|
||||
sprframe = &sprdef->spriteframes[XTRA_ENDING+2];
|
||||
endfwrk[2] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
|
||||
}
|
||||
else // Show a star if your character doesn't have an ending firework display. (Basically the MISSINGs for this)
|
||||
{
|
||||
endfwrk[0] = W_CachePatchName("ENDFWRK3", PU_LEVEL);
|
||||
endfwrk[1] = W_CachePatchName("ENDFWRK4", PU_LEVEL);
|
||||
endfwrk[2] = W_CachePatchName("ENDFWRK5", PU_LEVEL);
|
||||
}
|
||||
|
||||
endbrdr[0] = W_CachePatchName("ENDBRDR2", PU_LEVEL);
|
||||
}
|
||||
else
|
||||
{
|
||||
// eggman, skin nonspecific
|
||||
endfwrk[0] = W_CachePatchName("ENDFWRK0", PU_LEVEL);
|
||||
endfwrk[1] = W_CachePatchName("ENDFWRK1", PU_LEVEL);
|
||||
endfwrk[2] = W_CachePatchName("ENDFWRK2", PU_LEVEL);
|
||||
|
||||
endbrdr[0] = W_CachePatchName("ENDBRDR0", PU_LEVEL);
|
||||
}
|
||||
F_CacheEnding();
|
||||
}
|
||||
|
||||
void F_EndingTicker(void)
|
||||
|
@ -1853,15 +1869,7 @@ void F_EndingTicker(void)
|
|||
S_ChangeMusicInternal((goodending ? "_endg" : "_endb"), false);
|
||||
|
||||
if (goodending && finalecount == INFLECTIONPOINT) // time to swap some assets
|
||||
{
|
||||
endegrk[0] = W_CachePatchName("ENDEGRK2", PU_LEVEL);
|
||||
endegrk[1] = W_CachePatchName("ENDEGRK3", PU_LEVEL);
|
||||
|
||||
endglow[0] = W_CachePatchName("ENDGLOW2", PU_LEVEL);
|
||||
endglow[1] = W_CachePatchName("ENDGLOW3", PU_LEVEL);
|
||||
|
||||
endxpld[0] = W_CachePatchName("ENDEGRK4", PU_LEVEL);
|
||||
}
|
||||
F_CacheGoodEnding();
|
||||
|
||||
if (++sparklloop == SPARKLLOOPTIME) // time to roll the randomisation again
|
||||
{
|
||||
|
@ -1880,10 +1888,17 @@ void F_EndingDrawer(void)
|
|||
INT32 x, y, i, j, parallaxticker;
|
||||
patch_t *rockpat;
|
||||
|
||||
if (needpatchrecache)
|
||||
{
|
||||
F_CacheEnding();
|
||||
if (goodending && finalecount >= INFLECTIONPOINT) // time to swap some assets
|
||||
F_CacheGoodEnding();
|
||||
}
|
||||
|
||||
if (!goodending || finalecount < INFLECTIONPOINT)
|
||||
rockpat = W_CachePatchName("ROID0000", PU_LEVEL);
|
||||
rockpat = W_CachePatchName("ROID0000", PU_PATCH);
|
||||
else
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - ((finalecount - INFLECTIONPOINT) % 35)), PU_LEVEL);
|
||||
rockpat = W_CachePatchName(va("ROID00%.2d", 34 - ((finalecount - INFLECTIONPOINT) % 35)), PU_PATCH);
|
||||
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
|
||||
|
||||
|
@ -2367,11 +2382,11 @@ void F_SkyScroll(INT32 scrollxspeed, INT32 scrollyspeed, const char *patchname)
|
|||
|
||||
if (!scrollxspeed && !scrollyspeed)
|
||||
{
|
||||
V_DrawPatchFill(W_CachePatchName(patchname, PU_CACHE));
|
||||
V_DrawPatchFill(W_CachePatchName(patchname, PU_PATCH));
|
||||
return;
|
||||
}
|
||||
|
||||
pat = W_CachePatchName(patchname, PU_CACHE);
|
||||
pat = W_CachePatchName(patchname, PU_PATCH);
|
||||
|
||||
patwidth = SHORT(pat->width);
|
||||
patheight = SHORT(pat->height);
|
||||
|
@ -2432,6 +2447,45 @@ else if (strlen(name) <= 6) \
|
|||
else \
|
||||
arr[0] = 0;
|
||||
|
||||
static void F_CacheTitleScreen(void)
|
||||
{
|
||||
switch(curttmode)
|
||||
{
|
||||
case TTMODE_OLD:
|
||||
case TTMODE_NONE:
|
||||
ttbanner = W_CachePatchName("TTBANNER", PU_LEVEL);
|
||||
ttwing = W_CachePatchName("TTWING", PU_LEVEL);
|
||||
ttsonic = W_CachePatchName("TTSONIC", PU_LEVEL);
|
||||
ttswave1 = W_CachePatchName("TTSWAVE1", PU_LEVEL);
|
||||
ttswave2 = W_CachePatchName("TTSWAVE2", PU_LEVEL);
|
||||
ttswip1 = W_CachePatchName("TTSWIP1", PU_LEVEL);
|
||||
ttsprep1 = W_CachePatchName("TTSPREP1", PU_LEVEL);
|
||||
ttsprep2 = W_CachePatchName("TTSPREP2", PU_LEVEL);
|
||||
ttspop1 = W_CachePatchName("TTSPOP1", PU_LEVEL);
|
||||
ttspop2 = W_CachePatchName("TTSPOP2", PU_LEVEL);
|
||||
ttspop3 = W_CachePatchName("TTSPOP3", PU_LEVEL);
|
||||
ttspop4 = W_CachePatchName("TTSPOP4", PU_LEVEL);
|
||||
ttspop5 = W_CachePatchName("TTSPOP5", PU_LEVEL);
|
||||
ttspop6 = W_CachePatchName("TTSPOP6", PU_LEVEL);
|
||||
ttspop7 = W_CachePatchName("TTSPOP7", PU_LEVEL);
|
||||
break;
|
||||
|
||||
// don't load alacroix gfx yet; we do that upon first draw.
|
||||
case TTMODE_ALACROIX:
|
||||
break;
|
||||
|
||||
case TTMODE_USER:
|
||||
{
|
||||
UINT16 i;
|
||||
lumpnum_t lumpnum;
|
||||
char lumpname[9];
|
||||
|
||||
LOADTTGFX(ttuser, curttname, TTMAX_USER)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void F_StartTitleScreen(void)
|
||||
{
|
||||
if (menupres[MN_MAIN].musname[0])
|
||||
|
@ -2528,41 +2582,7 @@ void F_StartTitleScreen(void)
|
|||
demoDelayLeft = demoDelayTime;
|
||||
demoIdleLeft = demoIdleTime;
|
||||
|
||||
switch(curttmode)
|
||||
{
|
||||
case TTMODE_OLD:
|
||||
case TTMODE_NONE:
|
||||
ttbanner = W_CachePatchName("TTBANNER", PU_LEVEL);
|
||||
ttwing = W_CachePatchName("TTWING", PU_LEVEL);
|
||||
ttsonic = W_CachePatchName("TTSONIC", PU_LEVEL);
|
||||
ttswave1 = W_CachePatchName("TTSWAVE1", PU_LEVEL);
|
||||
ttswave2 = W_CachePatchName("TTSWAVE2", PU_LEVEL);
|
||||
ttswip1 = W_CachePatchName("TTSWIP1", PU_LEVEL);
|
||||
ttsprep1 = W_CachePatchName("TTSPREP1", PU_LEVEL);
|
||||
ttsprep2 = W_CachePatchName("TTSPREP2", PU_LEVEL);
|
||||
ttspop1 = W_CachePatchName("TTSPOP1", PU_LEVEL);
|
||||
ttspop2 = W_CachePatchName("TTSPOP2", PU_LEVEL);
|
||||
ttspop3 = W_CachePatchName("TTSPOP3", PU_LEVEL);
|
||||
ttspop4 = W_CachePatchName("TTSPOP4", PU_LEVEL);
|
||||
ttspop5 = W_CachePatchName("TTSPOP5", PU_LEVEL);
|
||||
ttspop6 = W_CachePatchName("TTSPOP6", PU_LEVEL);
|
||||
ttspop7 = W_CachePatchName("TTSPOP7", PU_LEVEL);
|
||||
break;
|
||||
|
||||
// don't load alacroix gfx yet; we do that upon first draw.
|
||||
case TTMODE_ALACROIX:
|
||||
break;
|
||||
|
||||
case TTMODE_USER:
|
||||
{
|
||||
UINT16 i;
|
||||
lumpnum_t lumpnum;
|
||||
char lumpname[9];
|
||||
|
||||
LOADTTGFX(ttuser, curttname, TTMAX_USER)
|
||||
break;
|
||||
}
|
||||
}
|
||||
F_CacheTitleScreen();
|
||||
}
|
||||
|
||||
static void F_UnloadAlacroixGraphics(SINT8 oldttscale)
|
||||
|
@ -2711,6 +2731,9 @@ void F_TitleScreenDrawer(void)
|
|||
if (modeattacking)
|
||||
return; // We likely came here from retrying. Don't do a damn thing.
|
||||
|
||||
if (needpatchrecache && (curttmode != TTMODE_ALACROIX))
|
||||
F_CacheTitleScreen();
|
||||
|
||||
// Draw that sky!
|
||||
if (curbgcolor >= 0)
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
|
||||
|
@ -2734,6 +2757,12 @@ void F_TitleScreenDrawer(void)
|
|||
return;
|
||||
#endif
|
||||
|
||||
if (needpatchrecache && (curttmode == TTMODE_ALACROIX))
|
||||
{
|
||||
ttloaded[0] = ttloaded[1] = ttloaded[2] = ttloaded[3] = ttloaded[4] = ttloaded[5] = 0;
|
||||
F_LoadAlacroixGraphics(activettscale);
|
||||
}
|
||||
|
||||
switch(curttmode)
|
||||
{
|
||||
case TTMODE_OLD:
|
||||
|
@ -3681,7 +3710,7 @@ void F_ContinueDrawer(void)
|
|||
V_DrawLevelTitle(x - (V_LevelNameWidth("Continue?")>>1), 16, 0, "Continue?");
|
||||
|
||||
// Two stars...
|
||||
patch = W_CachePatchName("CONTSTAR", PU_CACHE);
|
||||
patch = W_CachePatchName("CONTSTAR", PU_PATCH);
|
||||
V_DrawScaledPatch(x-32, 160, 0, patch);
|
||||
V_DrawScaledPatch(x+32, 160, 0, patch);
|
||||
|
||||
|
@ -3689,14 +3718,14 @@ void F_ContinueDrawer(void)
|
|||
if (timeleft > 9)
|
||||
{
|
||||
numbuf[7] = '1';
|
||||
V_DrawScaledPatch(x - 10, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
|
||||
V_DrawScaledPatch(x - 10, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
|
||||
numbuf[7] = '0';
|
||||
V_DrawScaledPatch(x + 10, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
|
||||
V_DrawScaledPatch(x + 10, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
|
||||
}
|
||||
else
|
||||
{
|
||||
numbuf[7] = '0'+timeleft;
|
||||
V_DrawScaledPatch(x, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
|
||||
V_DrawScaledPatch(x, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
|
||||
}
|
||||
|
||||
// Draw the continue markers! Show continues.
|
||||
|
@ -3723,7 +3752,7 @@ void F_ContinueDrawer(void)
|
|||
}
|
||||
|
||||
// Spotlight
|
||||
V_DrawScaledPatch(x, 140, 0, W_CachePatchName("CONTSPOT", PU_CACHE));
|
||||
V_DrawScaledPatch(x, 140, 0, W_CachePatchName("CONTSPOT", PU_PATCH));
|
||||
|
||||
// warping laser
|
||||
if (continuetime)
|
||||
|
@ -3760,8 +3789,8 @@ void F_ContinueDrawer(void)
|
|||
#define drawchar(dx, dy, n) {\
|
||||
sprdef = &contskins[n]->sprites[cont_spr2[n][0]];\
|
||||
sprframe = &sprdef->spriteframes[cont_spr2[n][1]];\
|
||||
patch = W_CachePatchNum(sprframe->lumppat[cont_spr2[n][2]], PU_CACHE);\
|
||||
V_DrawFixedPatch((dx), (dy), FRACUNIT, (sprframe->flip & (1<<cont_spr2[n][2])) ? V_FLIP : 0, patch, contcolormaps[n]);\
|
||||
patch = W_CachePatchNum(sprframe->lumppat[cont_spr2[n][2]], PU_PATCH);\
|
||||
V_DrawFixedPatch((dx), (dy), contskins[n]->highresscale, (sprframe->flip & (1<<cont_spr2[n][2])) ? V_FLIP : 0, patch, contcolormaps[n]);\
|
||||
}
|
||||
|
||||
if (offsy < 0)
|
||||
|
@ -4024,10 +4053,10 @@ void F_CutsceneDrawer(void)
|
|||
{
|
||||
if (cutscenes[cutnum]->scene[scenenum].pichires[picnum])
|
||||
V_DrawSmallScaledPatch(picxpos, picypos, 0,
|
||||
W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_CACHE));
|
||||
W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_PATCH));
|
||||
else
|
||||
V_DrawScaledPatch(picxpos,picypos, 0,
|
||||
W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_CACHE));
|
||||
W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_PATCH));
|
||||
}
|
||||
|
||||
if (dofadenow && rendermode != render_none)
|
||||
|
@ -4513,10 +4542,10 @@ void F_TextPromptDrawer(void)
|
|||
{
|
||||
if (textprompts[cutnum]->page[scenenum].pichires[picnum])
|
||||
V_DrawSmallScaledPatch(picxpos, picypos, 0,
|
||||
W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_CACHE));
|
||||
W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_PATCH));
|
||||
else
|
||||
V_DrawScaledPatch(picxpos,picypos, 0,
|
||||
W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_CACHE));
|
||||
W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_PATCH));
|
||||
}
|
||||
|
||||
// Draw background
|
||||
|
@ -4526,7 +4555,7 @@ void F_TextPromptDrawer(void)
|
|||
if (iconlump != LUMPERROR)
|
||||
{
|
||||
INT32 iconx, icony, scale, scaledsize;
|
||||
patch = W_CachePatchName(textprompts[cutnum]->page[scenenum].iconname, PU_CACHE);
|
||||
patch = W_CachePatchName(textprompts[cutnum]->page[scenenum].iconname, PU_PATCH);
|
||||
|
||||
// scale and center
|
||||
if (patch->width > patch->height)
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 2013-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2013-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 1999-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
|
1129
src/g_game.c
1129
src/g_game.c
File diff suppressed because it is too large
Load diff
46
src/g_game.h
46
src/g_game.h
|
@ -68,15 +68,37 @@ extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime,
|
|||
extern consvar_t cv_crosshair, cv_crosshair2;
|
||||
extern consvar_t cv_invertmouse, cv_alwaysfreelook, cv_chasefreelook, cv_mousemove;
|
||||
extern consvar_t cv_invertmouse2, cv_alwaysfreelook2, cv_chasefreelook2, cv_mousemove2;
|
||||
extern consvar_t cv_useranalog, cv_useranalog2;
|
||||
extern consvar_t cv_analog, cv_analog2;
|
||||
extern consvar_t cv_directionchar, cv_directionchar2;
|
||||
|
||||
extern consvar_t cv_useranalog[2], cv_analog[2];
|
||||
extern consvar_t cv_directionchar[2];
|
||||
|
||||
typedef enum {
|
||||
CS_LEGACY,
|
||||
CS_LMAOGALOG,
|
||||
CS_STANDARD,
|
||||
CS_SIMPLE = CS_LMAOGALOG|CS_STANDARD,
|
||||
} controlstyle_e;
|
||||
#define G_ControlStyle(ssplayer) (cv_directionchar[(ssplayer)-1].value == 3 ? CS_LMAOGALOG : ((cv_analog[(ssplayer)-1].value ? CS_LMAOGALOG : 0) | (cv_directionchar[(ssplayer)-1].value ? CS_STANDARD : 0)))
|
||||
#define P_ControlStyle(player) ((((player)->pflags & PF_ANALOGMODE) ? CS_LMAOGALOG : 0) | (((player)->pflags & PF_DIRECTIONCHAR) ? CS_STANDARD : 0))
|
||||
|
||||
extern consvar_t cv_autobrake, cv_autobrake2;
|
||||
extern consvar_t cv_deadzone, cv_deadzone2;
|
||||
extern consvar_t cv_sideaxis,cv_turnaxis,cv_moveaxis,cv_lookaxis,cv_jumpaxis,cv_spinaxis,cv_fireaxis,cv_firenaxis;
|
||||
extern consvar_t cv_sideaxis2,cv_turnaxis2,cv_moveaxis2,cv_lookaxis2,cv_jumpaxis2,cv_spinaxis2,cv_fireaxis2,cv_firenaxis2;
|
||||
extern consvar_t cv_sideaxis,cv_turnaxis,cv_moveaxis,cv_lookaxis,cv_jumpaxis,cv_spinaxis,cv_fireaxis,cv_firenaxis,cv_deadzone,cv_digitaldeadzone;
|
||||
extern consvar_t cv_sideaxis2,cv_turnaxis2,cv_moveaxis2,cv_lookaxis2,cv_jumpaxis2,cv_spinaxis2,cv_fireaxis2,cv_firenaxis2,cv_deadzone2,cv_digitaldeadzone2;
|
||||
extern consvar_t cv_ghost_bestscore, cv_ghost_besttime, cv_ghost_bestrings, cv_ghost_last, cv_ghost_guest;
|
||||
|
||||
// hi here's some new controls
|
||||
extern consvar_t cv_cam_shiftfacing[2], cv_cam_turnfacing[2],
|
||||
cv_cam_turnfacingability[2], cv_cam_turnfacingspindash[2], cv_cam_turnfacinginput[2],
|
||||
cv_cam_centertoggle[2], cv_cam_lockedinput[2], cv_cam_lockonboss[2];
|
||||
|
||||
typedef enum
|
||||
{
|
||||
LOCK_BOSS = 1<<0,
|
||||
LOCK_ENEMY = 1<<1,
|
||||
LOCK_INTERESTS = 1<<2,
|
||||
} lockassist_e;
|
||||
|
||||
|
||||
// mouseaiming (looking up/down with the mouse or keyboard)
|
||||
#define KB_LOOKSPEED (1<<25)
|
||||
#define MAXPLMOVE (50)
|
||||
|
@ -84,8 +106,10 @@ extern consvar_t cv_ghost_bestscore, cv_ghost_besttime, cv_ghost_bestrings, cv_g
|
|||
|
||||
// build an internal map name MAPxx from map number
|
||||
const char *G_BuildMapName(INT32 map);
|
||||
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics);
|
||||
void G_BuildTiccmd2(ticcmd_t *cmd, INT32 realtics);
|
||||
|
||||
extern boolean ticcmd_centerviewdown[2]; // For simple controls, lock the camera behind the player
|
||||
extern mobj_t *ticcmd_ztargetfocus[2]; // Locking onto an object?
|
||||
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
|
||||
|
||||
// copy ticcmd_t to and fro the normal way
|
||||
ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n);
|
||||
|
@ -130,6 +154,9 @@ INT32 G_FindMap(const char *query, char **foundmapnamep,
|
|||
mapsearchfreq_t **freqp, INT32 *freqc);
|
||||
void G_FreeMapSearch(mapsearchfreq_t *freq, INT32 freqc);
|
||||
|
||||
/* Match map name by search + 2 digit map code or map number. */
|
||||
INT32 G_FindMapByNameOrCode(const char *query, char **foundmapnamep);
|
||||
|
||||
// XMOD spawning
|
||||
mapthing_t *G_FindCTFStart(INT32 playernum);
|
||||
mapthing_t *G_FindMatchStart(INT32 playernum);
|
||||
|
@ -218,11 +245,14 @@ void G_SetGametypeDescription(INT16 gtype, char *descriptiontext, UINT8 leftcolo
|
|||
INT32 G_GetGametypeByName(const char *gametypestr);
|
||||
boolean G_IsSpecialStage(INT32 mapnum);
|
||||
boolean G_GametypeUsesLives(void);
|
||||
boolean G_GametypeUsesCoopLives(void);
|
||||
boolean G_GametypeUsesCoopStarposts(void);
|
||||
boolean G_GametypeHasTeams(void);
|
||||
boolean G_GametypeHasSpectators(void);
|
||||
boolean G_RingSlingerGametype(void);
|
||||
boolean G_PlatformGametype(void);
|
||||
boolean G_TagGametype(void);
|
||||
boolean G_CompetitionGametype(void);
|
||||
boolean G_EnoughPlayersFinished(void);
|
||||
void G_ExitLevel(void);
|
||||
void G_NextLevel(void);
|
||||
|
|
|
@ -132,6 +132,7 @@ extern INT32 gamecontroldefault[num_gamecontrolschemes][num_gamecontrols][2]; //
|
|||
extern INT32 gamecontrolbisdefault[num_gamecontrolschemes][num_gamecontrols][2];
|
||||
#define PLAYER1INPUTDOWN(gc) (gamekeydown[gamecontrol[gc][0]] || gamekeydown[gamecontrol[gc][1]])
|
||||
#define PLAYER2INPUTDOWN(gc) (gamekeydown[gamecontrolbis[gc][0]] || gamekeydown[gamecontrolbis[gc][1]])
|
||||
#define PLAYERINPUTDOWN(p, gc) ((p) == 2 ? PLAYER2INPUTDOWN(gc) : PLAYER1INPUTDOWN(gc))
|
||||
|
||||
#define num_gcl_tutorial_check 6
|
||||
#define num_gcl_tutorial_used 8
|
||||
|
|
|
@ -449,8 +449,12 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 count, poly_t *poly)
|
|||
// for each seg of the subsector
|
||||
for (; count--; lseg++)
|
||||
{
|
||||
//x,y,dx,dy (like a divline)
|
||||
line_t *line = lseg->linedef;
|
||||
|
||||
if (lseg->glseg)
|
||||
continue;
|
||||
|
||||
//x,y,dx,dy (like a divline)
|
||||
p1.x = FIXED_TO_FLOAT(lseg->side ? line->v2->x : line->v1->x);
|
||||
p1.y = FIXED_TO_FLOAT(lseg->side ? line->v2->y : line->v1->y);
|
||||
p2.x = FIXED_TO_FLOAT(lseg->side ? line->v1->x : line->v2->x);
|
||||
|
@ -836,8 +840,10 @@ static INT32 SolveTProblem(void)
|
|||
return 0;
|
||||
|
||||
CONS_Debug(DBG_RENDER, "Solving T-joins. This may take a while. Please wait...\n");
|
||||
#ifdef HWR_LOADING_SCREEN
|
||||
CON_Drawer(); //let the user know what we are doing
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
#endif
|
||||
|
||||
numsplitpoly = 0;
|
||||
|
||||
|
@ -964,9 +970,9 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
|
|||
CONS_Debug(DBG_RENDER, "Creating polygons, please wait...\n");
|
||||
#ifdef HWR_LOADING_SCREEN
|
||||
ls_count = ls_percent = 0; // reset the loading status
|
||||
#endif
|
||||
CON_Drawer(); //let the user know what we are doing
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
#endif
|
||||
|
||||
HWR_ClearPolys();
|
||||
|
||||
|
|
|
@ -122,11 +122,11 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
|
|||
if (mipmap->colormap)
|
||||
texel = mipmap->colormap[texel];
|
||||
|
||||
// transparent pixel
|
||||
if (texel == HWR_PATCHES_CHROMAKEY_COLORINDEX)
|
||||
// If the mipmap is chromakeyed, check if the texel's color
|
||||
// is equivalent to the chroma key's color index.
|
||||
alpha = 0xff;
|
||||
if ((mipmap->flags & TF_CHROMAKEYED) && (texel == HWR_PATCHES_CHROMAKEY_COLORINDEX))
|
||||
alpha = 0x00;
|
||||
else
|
||||
alpha = 0xff;
|
||||
|
||||
// hope compiler will get this switch out of the loops (dreams...)
|
||||
// gcc do it ! but vcc not ! (why don't use cygwin gcc for win32 ?)
|
||||
|
@ -654,7 +654,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLTexture_t *grtex)
|
|||
|
||||
#ifndef NO_PNG_LUMPS
|
||||
if (R_IsLumpPNG((UINT8 *)realpatch, lumplength))
|
||||
realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL, false);
|
||||
realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL);
|
||||
else
|
||||
#endif
|
||||
#ifdef WALLFLATS
|
||||
|
@ -698,7 +698,7 @@ void HWR_MakePatch (const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipm
|
|||
// lump is a png so convert it
|
||||
size_t len = W_LumpLengthPwad(grPatch->wadnum, grPatch->lumpnum);
|
||||
if ((patch != NULL) && R_IsLumpPNG((const UINT8 *)patch, len))
|
||||
patch = R_PNGToPatch((const UINT8 *)patch, len, NULL, true);
|
||||
patch = R_PNGToPatch((const UINT8 *)patch, len, NULL);
|
||||
#endif
|
||||
|
||||
// don't do it twice (like a cache)
|
||||
|
@ -764,13 +764,12 @@ void HWR_MakePatch (const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipm
|
|||
// CACHING HANDLING
|
||||
// =================================================
|
||||
|
||||
static size_t gr_numtextures; // Texture count
|
||||
static size_t gr_numtextures = 0; // Texture count
|
||||
static GLTexture_t *gr_textures; // For all textures
|
||||
static GLTexture_t *gr_flats; // For all (texture) flats, as normal flats don't need to be cached
|
||||
|
||||
void HWR_InitTextureCache(void)
|
||||
{
|
||||
gr_numtextures = 0;
|
||||
gr_textures = NULL;
|
||||
gr_flats = NULL;
|
||||
}
|
||||
|
@ -958,6 +957,9 @@ static void HWR_CacheTextureAsFlat(GLMipmap_t *grMipmap, INT32 texturenum)
|
|||
{
|
||||
UINT8 *flat;
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
// setup the texture info
|
||||
#ifdef GLIDE_API_COMPATIBILITY
|
||||
grMipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_64;
|
||||
|
@ -983,6 +985,9 @@ void HWR_LiterallyGetFlat(lumpnum_t flatlumpnum)
|
|||
if (flatlumpnum == LUMPERROR)
|
||||
return;
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
grmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
|
||||
if (!grmip->downloaded && !grmip->grInfo.data)
|
||||
HWR_CacheFlat(grmip, flatlumpnum);
|
||||
|
@ -1061,6 +1066,9 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
|
|||
// -----------------+
|
||||
void HWR_GetPatch(GLPatch_t *gpatch)
|
||||
{
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
// is it in hardware cache
|
||||
if (!gpatch->mipmap->downloaded && !gpatch->mipmap->grInfo.data)
|
||||
{
|
||||
|
@ -1091,6 +1099,9 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
|
|||
{
|
||||
GLMipmap_t *grmip, *newmip;
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
if (colormap == colormaps || colormap == NULL)
|
||||
{
|
||||
// Load the default (green) color in doom cache (temporary?) AND hardware cache
|
||||
|
@ -1216,6 +1227,9 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
|
|||
{
|
||||
GLPatch_t *grpatch;
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
grpatch = HWR_GetCachedGLPatch(lumpnum);
|
||||
|
||||
if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
|
||||
|
@ -1310,23 +1324,6 @@ GLPatch_t *HWR_GetCachedGLPatch(lumpnum_t lumpnum)
|
|||
return HWR_GetCachedGLPatchPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum));
|
||||
}
|
||||
|
||||
#ifdef ROTSPRITE
|
||||
GLPatch_t *HWR_GetCachedGLRotSprite(aatree_t *hwrcache, UINT16 rollangle, patch_t *rawpatch)
|
||||
{
|
||||
GLPatch_t *grpatch;
|
||||
|
||||
if (!(grpatch = M_AATreeGet(hwrcache, rollangle)))
|
||||
{
|
||||
grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
grpatch->rawpatch = rawpatch;
|
||||
grpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
M_AATreeSet(hwrcache, rollangle, grpatch);
|
||||
}
|
||||
|
||||
return grpatch;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Need to do this because they aren't powers of 2
|
||||
static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32 pblockheight,
|
||||
lumpnum_t fademasklumpnum, UINT16 fmwidth, UINT16 fmheight)
|
||||
|
@ -1419,6 +1416,9 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum)
|
|||
{
|
||||
GLMipmap_t *grmip;
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
grmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
|
||||
|
||||
if (!grmip->downloaded && !grmip->grInfo.data)
|
||||
|
|
|
@ -992,7 +992,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
|||
// top edge
|
||||
if (clearlines > basewindowy - 8)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_CACHE);
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH);
|
||||
for (x = 0; x < baseviewwidth; x += 8)
|
||||
HWR_DrawPatch(patch, basewindowx + x, basewindowy - 8,
|
||||
0);
|
||||
|
@ -1001,7 +1001,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
|||
// bottom edge
|
||||
if (clearlines > basewindowy + baseviewheight)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_CACHE);
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH);
|
||||
for (x = 0; x < baseviewwidth; x += 8)
|
||||
HWR_DrawPatch(patch, basewindowx + x,
|
||||
basewindowy + baseviewheight, 0);
|
||||
|
@ -1010,7 +1010,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
|||
// left edge
|
||||
if (clearlines > basewindowy)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_CACHE);
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
|
||||
for (y = 0; y < baseviewheight && basewindowy + y < clearlines;
|
||||
y += 8)
|
||||
{
|
||||
|
@ -1022,7 +1022,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
|||
// right edge
|
||||
if (clearlines > basewindowy)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_CACHE);
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
|
||||
for (y = 0; y < baseviewheight && basewindowy+y < clearlines;
|
||||
y += 8)
|
||||
{
|
||||
|
@ -1034,22 +1034,22 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
|||
// Draw beveled corners.
|
||||
if (clearlines > basewindowy - 8)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TL],
|
||||
PU_CACHE),
|
||||
PU_PATCH),
|
||||
basewindowx - 8, basewindowy - 8, 0);
|
||||
|
||||
if (clearlines > basewindowy - 8)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TR],
|
||||
PU_CACHE),
|
||||
PU_PATCH),
|
||||
basewindowx + baseviewwidth, basewindowy - 8, 0);
|
||||
|
||||
if (clearlines > basewindowy+baseviewheight)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BL],
|
||||
PU_CACHE),
|
||||
PU_PATCH),
|
||||
basewindowx - 8, basewindowy + baseviewheight, 0);
|
||||
|
||||
if (clearlines > basewindowy + baseviewheight)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BR],
|
||||
PU_CACHE),
|
||||
PU_PATCH),
|
||||
basewindowx + baseviewwidth,
|
||||
basewindowy + baseviewheight, 0);
|
||||
}
|
||||
|
|
|
@ -113,9 +113,6 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum);
|
|||
void HWR_SetPalette(RGBA_t *palette);
|
||||
GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wad, UINT16 lump);
|
||||
GLPatch_t *HWR_GetCachedGLPatch(lumpnum_t lumpnum);
|
||||
#ifdef ROTSPRITE
|
||||
GLPatch_t *HWR_GetCachedGLRotSprite(aatree_t *hwrcache, UINT16 rollangle, patch_t *rawpatch);
|
||||
#endif
|
||||
void HWR_GetFadeMask(lumpnum_t fademasklumpnum);
|
||||
|
||||
// --------
|
||||
|
|
|
@ -374,7 +374,6 @@ light_t *t_lspr[NUMSPRITES] =
|
|||
&lspr[NOLIGHT], // SPR_ADST
|
||||
&lspr[NOLIGHT], // SPR_MCRT
|
||||
&lspr[NOLIGHT], // SPR_MCSP
|
||||
&lspr[NOLIGHT], // SPR_NON2
|
||||
&lspr[NOLIGHT], // SPR_SALD
|
||||
&lspr[NOLIGHT], // SPR_TRAE
|
||||
&lspr[NOLIGHT], // SPR_TRAI
|
||||
|
|
|
@ -832,7 +832,7 @@ static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf)
|
|||
if (!M_PointInBox(segbbox,splat->v1.x,splat->v1.y) && !M_PointInBox(segbbox,splat->v2.x,splat->v2.y))
|
||||
continue;
|
||||
|
||||
gpatch = W_CachePatchNum(splat->patch, PU_CACHE);
|
||||
gpatch = W_CachePatchNum(splat->patch, PU_PATCH);
|
||||
HWR_GetPatch(gpatch);
|
||||
|
||||
wallVerts[0].x = wallVerts[3].x = FIXED_TO_FLOAT(splat->v1.x);
|
||||
|
@ -1026,6 +1026,34 @@ static float HWR_ClipViewSegment(INT32 x, polyvertex_t *v1, polyvertex_t *v2)
|
|||
}
|
||||
#endif
|
||||
|
||||
static FUINT HWR_CalcWallLight(FUINT lightnum, fixed_t v1x, fixed_t v1y, fixed_t v2x, fixed_t v2y)
|
||||
{
|
||||
INT16 finallight = lightnum;
|
||||
|
||||
if (cv_grfakecontrast.value != 0)
|
||||
{
|
||||
const UINT8 contrast = 8;
|
||||
fixed_t extralight = 0;
|
||||
|
||||
if (v1y == v2y)
|
||||
extralight = -contrast;
|
||||
else if (v1x == v2x)
|
||||
extralight = contrast;
|
||||
|
||||
if (extralight != 0)
|
||||
{
|
||||
finallight += extralight;
|
||||
|
||||
if (finallight < 0)
|
||||
finallight = 0;
|
||||
if (finallight > 255)
|
||||
finallight = 255;
|
||||
}
|
||||
}
|
||||
|
||||
return (FUINT)finallight;
|
||||
}
|
||||
|
||||
//
|
||||
// HWR_SplitWall
|
||||
//
|
||||
|
@ -1044,19 +1072,20 @@ static void HWR_SplitWall(sector_t *sector, wallVert3D *wallVerts, INT32 texnum,
|
|||
float endpegt, endpegb, endpegmul;
|
||||
float endheight = 0.0f, endbheight = 0.0f;
|
||||
|
||||
fixed_t v1x = FLOAT_TO_FIXED(wallVerts[0].x);
|
||||
fixed_t v1y = FLOAT_TO_FIXED(wallVerts[0].z); // not a typo
|
||||
fixed_t v2x = FLOAT_TO_FIXED(wallVerts[1].x);
|
||||
fixed_t v2y = FLOAT_TO_FIXED(wallVerts[1].z); // not a typo
|
||||
// compiler complains when P_GetZAt is used in FLOAT_TO_FIXED directly
|
||||
// use this as a temp var to store P_GetZAt's return value each time
|
||||
fixed_t temp;
|
||||
#endif
|
||||
|
||||
INT32 solid, i;
|
||||
fixed_t v1x = FLOAT_TO_FIXED(wallVerts[0].x);
|
||||
fixed_t v1y = FLOAT_TO_FIXED(wallVerts[0].z); // not a typo
|
||||
fixed_t v2x = FLOAT_TO_FIXED(wallVerts[1].x);
|
||||
fixed_t v2y = FLOAT_TO_FIXED(wallVerts[1].z); // not a typo
|
||||
|
||||
INT32 solid, i;
|
||||
lightlist_t * list = sector->lightlist;
|
||||
const UINT8 alpha = Surf->FlatColor.s.alpha;
|
||||
FUINT lightnum = sector->lightlevel;
|
||||
FUINT lightnum = HWR_CalcWallLight(sector->lightlevel, v1x, v1y, v2x, v2y);
|
||||
extracolormap_t *colormap = NULL;
|
||||
|
||||
realtop = top = wallVerts[3].y;
|
||||
|
@ -1086,12 +1115,12 @@ static void HWR_SplitWall(sector_t *sector, wallVert3D *wallVerts, INT32 texnum,
|
|||
{
|
||||
if (pfloor && (pfloor->flags & FF_FOG))
|
||||
{
|
||||
lightnum = pfloor->master->frontsector->lightlevel;
|
||||
lightnum = HWR_CalcWallLight(pfloor->master->frontsector->lightlevel, v1x, v1y, v2x, v2y);
|
||||
colormap = pfloor->master->frontsector->extra_colormap;
|
||||
}
|
||||
else
|
||||
{
|
||||
lightnum = *list[i].lightlevel;
|
||||
lightnum = HWR_CalcWallLight(*list[i].lightlevel, v1x, v1y, v2x, v2y);
|
||||
colormap = *list[i].extra_colormap;
|
||||
}
|
||||
}
|
||||
|
@ -1395,7 +1424,7 @@ static void HWR_StoreWallRange(double startfrac, double endfrac)
|
|||
cliphigh = (float)(texturehpeg + (gr_curline->flength*FRACUNIT));
|
||||
}
|
||||
|
||||
lightnum = gr_frontsector->lightlevel;
|
||||
lightnum = HWR_CalcWallLight(gr_frontsector->lightlevel, vs.x, vs.y, ve.x, ve.y);
|
||||
colormap = gr_frontsector->extra_colormap;
|
||||
|
||||
if (gr_frontsector)
|
||||
|
@ -2150,7 +2179,7 @@ static void HWR_StoreWallRange(double startfrac, double endfrac)
|
|||
|
||||
blendmode = PF_Fog|PF_NoTexture;
|
||||
|
||||
lightnum = rover->master->frontsector->lightlevel;
|
||||
lightnum = HWR_CalcWallLight(rover->master->frontsector->lightlevel, vs.x, vs.y, ve.x, ve.y);
|
||||
colormap = rover->master->frontsector->extra_colormap;
|
||||
|
||||
if (rover->master->frontsector->extra_colormap)
|
||||
|
@ -2270,7 +2299,7 @@ static void HWR_StoreWallRange(double startfrac, double endfrac)
|
|||
|
||||
blendmode = PF_Fog|PF_NoTexture;
|
||||
|
||||
lightnum = rover->master->frontsector->lightlevel;
|
||||
lightnum = HWR_CalcWallLight(rover->master->frontsector->lightlevel, vs.x, vs.y, ve.x, ve.y);
|
||||
colormap = rover->master->frontsector->extra_colormap;
|
||||
|
||||
if (rover->master->frontsector->extra_colormap)
|
||||
|
@ -2714,8 +2743,6 @@ static void HWR_AddLine(seg_t * line)
|
|||
static sector_t tempsec;
|
||||
|
||||
fixed_t v1x, v1y, v2x, v2y; // the seg's vertexes as fixed_t
|
||||
if (line->glseg)
|
||||
return;
|
||||
#ifdef POLYOBJECTS
|
||||
if (line->polyseg && !(line->polyseg->flags & POF_RENDERSIDES))
|
||||
return;
|
||||
|
@ -3773,11 +3800,16 @@ static void HWR_Subsector(size_t num)
|
|||
|
||||
while (count--)
|
||||
{
|
||||
|
||||
if (!line->glseg
|
||||
#ifdef POLYOBJECTS
|
||||
if (!line->polyseg) // ignore segs that belong to polyobjects
|
||||
&& !line->polyseg // ignore segs that belong to polyobjects
|
||||
#endif
|
||||
)
|
||||
{
|
||||
HWR_AddLine(line);
|
||||
line++;
|
||||
}
|
||||
line++;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -5115,7 +5147,12 @@ void HWR_AddTransparentFloor(levelflat_t *levelflat, extrasubsector_t *xsub, boo
|
|||
|
||||
planeinfo[numplanes].isceiling = isceiling;
|
||||
planeinfo[numplanes].fixedheight = fixedheight;
|
||||
planeinfo[numplanes].lightlevel = lightlevel;
|
||||
|
||||
if (planecolormap && (planecolormap->fog & 1))
|
||||
planeinfo[numplanes].lightlevel = lightlevel;
|
||||
else
|
||||
planeinfo[numplanes].lightlevel = 255;
|
||||
|
||||
planeinfo[numplanes].levelflat = levelflat;
|
||||
planeinfo[numplanes].xsub = xsub;
|
||||
planeinfo[numplanes].alpha = alpha;
|
||||
|
@ -5147,7 +5184,12 @@ void HWR_AddTransparentPolyobjectFloor(levelflat_t *levelflat, polyobj_t *polyse
|
|||
|
||||
polyplaneinfo[numpolyplanes].isceiling = isceiling;
|
||||
polyplaneinfo[numpolyplanes].fixedheight = fixedheight;
|
||||
polyplaneinfo[numpolyplanes].lightlevel = lightlevel;
|
||||
|
||||
if (planecolormap && (planecolormap->fog & 1))
|
||||
polyplaneinfo[numpolyplanes].lightlevel = lightlevel;
|
||||
else
|
||||
polyplaneinfo[numpolyplanes].lightlevel = 255;
|
||||
|
||||
polyplaneinfo[numpolyplanes].levelflat = levelflat;
|
||||
polyplaneinfo[numpolyplanes].polysector = polysector;
|
||||
polyplaneinfo[numpolyplanes].alpha = alpha;
|
||||
|
@ -5490,7 +5532,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
|
|||
spriteinfo_t *sprinfo;
|
||||
size_t lumpoff;
|
||||
unsigned rot;
|
||||
UINT8 flip;
|
||||
UINT16 flip;
|
||||
boolean vflip = (!(thing->eflags & MFE_VERTICALFLIP) != !(thing->frame & FF_VERTICALFLIP));
|
||||
|
||||
angle_t ang;
|
||||
|
@ -5576,12 +5618,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
|
|||
flip = sprframe->flip; // Will only be 0x00 or 0xFF
|
||||
|
||||
if (papersprite && ang < ANGLE_180)
|
||||
{
|
||||
if (flip)
|
||||
flip = 0;
|
||||
else
|
||||
flip = 255;
|
||||
}
|
||||
flip ^= 0xFFFF;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -5590,6 +5627,11 @@ static void HWR_ProjectSprite(mobj_t *thing)
|
|||
rot = 6; // F7 slot
|
||||
else if ((sprframe->rotate & SRF_LEFT) && (ang >= ANGLE_180)) // See from left
|
||||
rot = 2; // F3 slot
|
||||
else if (sprframe->rotate & SRF_3DGE) // 16-angle mode
|
||||
{
|
||||
rot = (ang+ANGLE_180+ANGLE_11hh)>>28;
|
||||
rot = ((rot & 1)<<3)|(rot>>1);
|
||||
}
|
||||
else // Normal behaviour
|
||||
rot = (ang+ANGLE_202h)>>29;
|
||||
|
||||
|
@ -5598,12 +5640,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
|
|||
flip = sprframe->flip & (1<<rot);
|
||||
|
||||
if (papersprite && ang < ANGLE_180)
|
||||
{
|
||||
if (flip)
|
||||
flip = 0;
|
||||
else
|
||||
flip = 1<<rot;
|
||||
}
|
||||
flip ^= (1<<rot);
|
||||
}
|
||||
|
||||
if (thing->skin && ((skin_t *)thing->skin)->flags & SF_HIRES)
|
||||
|
@ -5618,7 +5655,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
|
|||
if (thing->rollangle)
|
||||
{
|
||||
rollangle = R_GetRollAngle(thing->rollangle);
|
||||
if (!sprframe->rotsprite.cached[rot])
|
||||
if (!(sprframe->rotsprite.cached & (1<<rot)))
|
||||
R_CacheRotSprite(thing->sprite, (thing->frame & FF_FRAMEMASK), sprinfo, sprframe, rot, flip);
|
||||
rotsprite = sprframe->rotsprite.patch[rot][rollangle];
|
||||
if (rotsprite != NULL)
|
||||
|
@ -6575,6 +6612,7 @@ consvar_t cv_grmodellighting = {"gr_modellighting", "Off", CV_SAVE|CV_CALL, CV_O
|
|||
|
||||
consvar_t cv_grspritebillboarding = {"gr_spritebillboarding", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_grskydome = {"gr_skydome", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_grfakecontrast = {"gr_fakecontrast", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_grrounddown = {"gr_rounddown", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_grfov = {"gr_fov", "90", CV_FLOAT|CV_CALL, grfov_cons_t, CV_grfov_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
@ -6643,6 +6681,7 @@ void HWR_AddCommands(void)
|
|||
|
||||
CV_RegisterVar(&cv_grskydome);
|
||||
CV_RegisterVar(&cv_grspritebillboarding);
|
||||
CV_RegisterVar(&cv_grfakecontrast);
|
||||
|
||||
CV_RegisterVar(&cv_grfiltermode);
|
||||
CV_RegisterVar(&cv_grrounddown);
|
||||
|
@ -6656,7 +6695,13 @@ void HWR_AddCommands(void)
|
|||
|
||||
void HWR_AddSessionCommands(void)
|
||||
{
|
||||
static boolean alreadycalled = false;
|
||||
if (alreadycalled)
|
||||
return;
|
||||
|
||||
CV_RegisterVar(&cv_granisotropicmode);
|
||||
|
||||
alreadycalled = true;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
@ -6692,6 +6737,17 @@ void HWR_Startup(void)
|
|||
startupdone = true;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Called after switching to the hardware renderer
|
||||
// --------------------------------------------------------------------------
|
||||
void HWR_Switch(void)
|
||||
{
|
||||
// Set special states from CVARs
|
||||
HWD.pfnSetSpecialState(HWD_SET_MODEL_LIGHTING, cv_grmodellighting.value);
|
||||
HWD.pfnSetSpecialState(HWD_SET_FOG_DENSITY, cv_grfogdensity.value);
|
||||
HWD.pfnSetSpecialState(HWD_SET_TEXTUREFILTERMODE, cv_grfiltermode.value);
|
||||
HWD.pfnSetSpecialState(HWD_SET_TEXTUREANISOTROPICMODE, cv_granisotropicmode.value);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Free resources allocated by the hardware renderer
|
||||
|
|
|
@ -29,6 +29,7 @@
|
|||
|
||||
// Startup & Shutdown the hardware mode renderer
|
||||
void HWR_Startup(void);
|
||||
void HWR_Switch(void);
|
||||
void HWR_Shutdown(void);
|
||||
|
||||
void HWR_drawAMline(const fline_t *fl, INT32 color);
|
||||
|
@ -98,6 +99,7 @@ extern consvar_t cv_grfovchange;
|
|||
extern consvar_t cv_grsolvetjoin;
|
||||
extern consvar_t cv_grspritebillboarding;
|
||||
extern consvar_t cv_grskydome;
|
||||
extern consvar_t cv_grfakecontrast;
|
||||
|
||||
extern float gr_viewwidth, gr_viewheight, gr_baseviewwindowy;
|
||||
|
||||
|
|
|
@ -654,10 +654,14 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
|
|||
UINT16 w = gpatch->width, h = gpatch->height;
|
||||
UINT32 size = w*h;
|
||||
RGBA_t *image, *blendimage, *cur, blendcolor;
|
||||
UINT8 translation[16]; // First the color index
|
||||
UINT8 cutoff[16]; // Brightness cutoff before using the next color
|
||||
UINT8 translen = 0;
|
||||
UINT8 i;
|
||||
|
||||
// vanilla port
|
||||
UINT8 translation[16];
|
||||
blendcolor = V_GetColor(0); // initialize
|
||||
memset(translation, 0, sizeof(translation));
|
||||
memset(cutoff, 0, sizeof(cutoff));
|
||||
|
||||
if (grmip->width == 0)
|
||||
{
|
||||
|
@ -681,17 +685,46 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
|
|||
|
||||
image = gpatch->mipmap->grInfo.data;
|
||||
blendimage = blendgpatch->mipmap->grInfo.data;
|
||||
blendcolor = V_GetColor(0); // initialize
|
||||
|
||||
// TC_METALSONIC includes an actual skincolor translation, on top of its flashing.
|
||||
if (skinnum == TC_METALSONIC)
|
||||
color = SKINCOLOR_COBALT;
|
||||
|
||||
if (color != SKINCOLOR_NONE)
|
||||
memcpy(&translation, &Color_Index[color - 1], 16);
|
||||
{
|
||||
UINT8 numdupes = 1;
|
||||
|
||||
translation[translen] = Color_Index[color-1][0];
|
||||
cutoff[translen] = 255;
|
||||
|
||||
for (i = 1; i < 16; i++)
|
||||
{
|
||||
if (translation[translen] == Color_Index[color-1][i])
|
||||
{
|
||||
numdupes++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (translen > 0)
|
||||
{
|
||||
cutoff[translen] = cutoff[translen-1] - (256 / (16 / numdupes));
|
||||
}
|
||||
|
||||
numdupes = 1;
|
||||
translen++;
|
||||
|
||||
translation[translen] = (UINT8)Color_Index[color-1][i];
|
||||
}
|
||||
|
||||
translen++;
|
||||
}
|
||||
|
||||
while (size--)
|
||||
{
|
||||
if (skinnum == TC_BOSS)
|
||||
{
|
||||
// Turn everything below a certain threshold white
|
||||
if ((image->s.red == image->s.green) && (image->s.green == image->s.blue) && image->s.blue <= 82)
|
||||
if ((image->s.red == image->s.green) && (image->s.green == image->s.blue) && image->s.blue < 127)
|
||||
{
|
||||
// Lactozilla: Invert the colors
|
||||
cur->s.red = cur->s.green = cur->s.blue = (255 - image->s.blue);
|
||||
|
@ -705,53 +738,6 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
|
|||
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
else if (skinnum == TC_METALSONIC)
|
||||
{
|
||||
// Turn everything below a certain blue threshold white
|
||||
if (image->s.red == 0 && image->s.green == 0 && image->s.blue <= 82)
|
||||
{
|
||||
cur->s.red = cur->s.green = cur->s.blue = 255;
|
||||
}
|
||||
else
|
||||
{
|
||||
cur->s.red = image->s.red;
|
||||
cur->s.green = image->s.green;
|
||||
cur->s.blue = image->s.blue;
|
||||
}
|
||||
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
else if (skinnum == TC_DASHMODE)
|
||||
{
|
||||
if (image->s.alpha == 0 && blendimage->s.alpha == 0)
|
||||
{
|
||||
// Don't bother with blending the pixel if the alpha of the blend pixel is 0
|
||||
cur->rgba = image->rgba;
|
||||
}
|
||||
else
|
||||
{
|
||||
UINT8 ialpha = 255 - blendimage->s.alpha, balpha = blendimage->s.alpha;
|
||||
RGBA_t icolor = *image, bcolor;
|
||||
|
||||
memset(&bcolor, 0x00, sizeof(RGBA_t));
|
||||
|
||||
if (blendimage->s.alpha)
|
||||
{
|
||||
bcolor.s.blue = 0;
|
||||
bcolor.s.red = 255;
|
||||
bcolor.s.green = (blendimage->s.red + blendimage->s.green + blendimage->s.blue) / 3;
|
||||
}
|
||||
if (image->s.alpha && image->s.red > image->s.green << 1) // this is pretty arbitrary, but it works well for Metal Sonic
|
||||
{
|
||||
icolor.s.red = image->s.blue;
|
||||
icolor.s.blue = image->s.red;
|
||||
}
|
||||
cur->s.red = (ialpha * icolor.s.red + balpha * bcolor.s.red)/255;
|
||||
cur->s.green = (ialpha * icolor.s.green + balpha * bcolor.s.green)/255;
|
||||
cur->s.blue = (ialpha * icolor.s.blue + balpha * bcolor.s.blue)/255;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
}
|
||||
else if (skinnum == TC_ALLWHITE)
|
||||
{
|
||||
// Turn everything white
|
||||
|
@ -760,185 +746,268 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
|
|||
}
|
||||
else
|
||||
{
|
||||
UINT16 brightness;
|
||||
// Everything below requires a blend image
|
||||
if (blendimage == NULL)
|
||||
{
|
||||
cur->rgba = image->rgba;
|
||||
goto skippixel;
|
||||
}
|
||||
|
||||
// Don't bother with blending the pixel if the alpha of the blend pixel is 0
|
||||
if (skinnum == TC_RAINBOW)
|
||||
// Metal Sonic dash mode
|
||||
if (skinnum == TC_DASHMODE)
|
||||
{
|
||||
if (image->s.alpha == 0 && blendimage->s.alpha == 0)
|
||||
{
|
||||
// Don't bother with blending the pixel if the alpha of the blend pixel is 0
|
||||
cur->rgba = image->rgba;
|
||||
cur++; image++; blendimage++;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
UINT16 imagebright, blendbright;
|
||||
SETBRIGHTNESS(imagebright,image->s.red,image->s.green,image->s.blue);
|
||||
SETBRIGHTNESS(blendbright,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||||
// slightly dumb average between the blend image color and base image colour, usually one or the other will be fully opaque anyway
|
||||
brightness = (imagebright*(255-blendimage->s.alpha))/255 + (blendbright*blendimage->s.alpha)/255;
|
||||
UINT8 ialpha = 255 - blendimage->s.alpha, balpha = blendimage->s.alpha;
|
||||
RGBA_t icolor = *image, bcolor;
|
||||
|
||||
memset(&bcolor, 0x00, sizeof(RGBA_t));
|
||||
|
||||
if (blendimage->s.alpha)
|
||||
{
|
||||
bcolor.s.blue = 0;
|
||||
bcolor.s.red = 255;
|
||||
bcolor.s.green = (blendimage->s.red + blendimage->s.green + blendimage->s.blue) / 3;
|
||||
}
|
||||
|
||||
if (image->s.alpha && image->s.red > image->s.green << 1) // this is pretty arbitrary, but it works well for Metal Sonic
|
||||
{
|
||||
icolor.s.red = image->s.blue;
|
||||
icolor.s.blue = image->s.red;
|
||||
}
|
||||
|
||||
cur->s.red = (ialpha * icolor.s.red + balpha * bcolor.s.red)/255;
|
||||
cur->s.green = (ialpha * icolor.s.green + balpha * bcolor.s.green)/255;
|
||||
cur->s.blue = (ialpha * icolor.s.blue + balpha * bcolor.s.blue)/255;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (blendimage->s.alpha == 0)
|
||||
// All settings that use skincolors!
|
||||
UINT16 brightness;
|
||||
|
||||
if (translen <= 0)
|
||||
{
|
||||
cur->rgba = image->rgba;
|
||||
cur++; image++; blendimage++;
|
||||
continue;
|
||||
goto skippixel;
|
||||
}
|
||||
else
|
||||
{
|
||||
SETBRIGHTNESS(brightness,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate a sort of "gradient" for the skincolor
|
||||
// (Me splitting this into a function didn't work, so I had to ruin this entire function's groove...)
|
||||
{
|
||||
RGBA_t nextcolor;
|
||||
UINT8 firsti, secondi, mul;
|
||||
UINT32 r, g, b;
|
||||
|
||||
// Rainbow needs to find the closest match to the textures themselves, instead of matching brightnesses to other colors.
|
||||
// Ensue horrible mess.
|
||||
// Don't bother with blending the pixel if the alpha of the blend pixel is 0
|
||||
if (skinnum == TC_RAINBOW)
|
||||
{
|
||||
UINT16 brightdif = 256;
|
||||
UINT8 colorbrightnesses[16];
|
||||
INT32 compare, m, d;
|
||||
UINT8 i;
|
||||
|
||||
// Ignore pure white & pitch black
|
||||
if (brightness > 253 || brightness < 2)
|
||||
if (image->s.alpha == 0 && blendimage->s.alpha == 0)
|
||||
{
|
||||
cur->rgba = image->rgba;
|
||||
cur++; image++; blendimage++;
|
||||
continue;
|
||||
}
|
||||
|
||||
firsti = 0;
|
||||
mul = 0;
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
RGBA_t tempc = V_GetColor(translation[i]);
|
||||
SETBRIGHTNESS(colorbrightnesses[i], tempc.s.red, tempc.s.green, tempc.s.blue); // store brightnesses for comparison
|
||||
}
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
if (brightness > colorbrightnesses[i]) // don't allow greater matches (because calculating a makeshift gradient for this is already a huge mess as is)
|
||||
continue;
|
||||
compare = abs((INT16)(colorbrightnesses[i]) - (INT16)(brightness));
|
||||
if (compare < brightdif)
|
||||
{
|
||||
brightdif = (UINT16)compare;
|
||||
firsti = i; // best matching color that's equal brightness or darker
|
||||
}
|
||||
}
|
||||
|
||||
secondi = firsti+1; // next color in line
|
||||
if (secondi == 16)
|
||||
{
|
||||
m = (INT16)brightness; // - 0;
|
||||
d = (INT16)colorbrightnesses[firsti]; // - 0;
|
||||
goto skippixel;
|
||||
}
|
||||
else
|
||||
{
|
||||
m = (INT16)brightness - (INT16)colorbrightnesses[secondi];
|
||||
d = (INT16)colorbrightnesses[firsti] - (INT16)colorbrightnesses[secondi];
|
||||
UINT16 imagebright, blendbright;
|
||||
SETBRIGHTNESS(imagebright,image->s.red,image->s.green,image->s.blue);
|
||||
SETBRIGHTNESS(blendbright,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||||
// slightly dumb average between the blend image color and base image colour, usually one or the other will be fully opaque anyway
|
||||
brightness = (imagebright*(255-blendimage->s.alpha))/255 + (blendbright*blendimage->s.alpha)/255;
|
||||
}
|
||||
|
||||
if (m >= d)
|
||||
m = d-1;
|
||||
|
||||
// calculate the "gradient" multiplier based on how close this color is to the one next in line
|
||||
if (m <= 0 || d <= 0)
|
||||
mul = 0;
|
||||
else
|
||||
mul = 15 - ((m * 16) / d);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Thankfully, it's normally way more simple.
|
||||
// Just convert brightness to a skincolor value, use remainder to find the gradient multipler
|
||||
firsti = ((UINT8)(255-brightness) / 16);
|
||||
secondi = firsti+1;
|
||||
mul = ((UINT8)(255-brightness) % 16);
|
||||
}
|
||||
|
||||
blendcolor = V_GetColor(translation[firsti]);
|
||||
|
||||
if (mul > 0 // If it's 0, then we only need the first color.
|
||||
&& translation[firsti] != translation[secondi]) // Some colors have duplicate colors in a row, so let's just save the process
|
||||
{
|
||||
if (secondi == 16) // blend to black
|
||||
nextcolor = V_GetColor(31);
|
||||
if (blendimage->s.alpha == 0)
|
||||
{
|
||||
cur->rgba = image->rgba;
|
||||
goto skippixel; // for metal sonic blend
|
||||
}
|
||||
else
|
||||
nextcolor = V_GetColor(translation[secondi]);
|
||||
|
||||
// Find difference between points
|
||||
r = (UINT32)(nextcolor.s.red - blendcolor.s.red);
|
||||
g = (UINT32)(nextcolor.s.green - blendcolor.s.green);
|
||||
b = (UINT32)(nextcolor.s.blue - blendcolor.s.blue);
|
||||
|
||||
// Find the gradient of the two points
|
||||
r = ((mul * r) / 16);
|
||||
g = ((mul * g) / 16);
|
||||
b = ((mul * b) / 16);
|
||||
|
||||
// Add gradient value to color
|
||||
blendcolor.s.red += r;
|
||||
blendcolor.s.green += g;
|
||||
blendcolor.s.blue += b;
|
||||
{
|
||||
SETBRIGHTNESS(brightness,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (skinnum == TC_RAINBOW)
|
||||
{
|
||||
UINT32 tempcolor;
|
||||
UINT16 colorbright;
|
||||
// Calculate a sort of "gradient" for the skincolor
|
||||
// (Me splitting this into a function didn't work, so I had to ruin this entire function's groove...)
|
||||
{
|
||||
RGBA_t nextcolor;
|
||||
UINT8 firsti, secondi, mul, mulmax;
|
||||
INT32 r, g, b;
|
||||
|
||||
SETBRIGHTNESS(colorbright,blendcolor.s.red,blendcolor.s.green,blendcolor.s.blue);
|
||||
if (colorbright == 0)
|
||||
colorbright = 1; // no dividing by 0 please
|
||||
// Rainbow needs to find the closest match to the textures themselves, instead of matching brightnesses to other colors.
|
||||
// Ensue horrible mess.
|
||||
if (skinnum == TC_RAINBOW)
|
||||
{
|
||||
UINT16 brightdif = 256;
|
||||
UINT8 colorbrightnesses[16];
|
||||
INT32 compare, m, d;
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.red) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.red = (UINT8)tempcolor;
|
||||
// Ignore pure white & pitch black
|
||||
if (brightness > 253 || brightness < 2)
|
||||
{
|
||||
cur->rgba = image->rgba;
|
||||
cur++; image++; blendimage++;
|
||||
continue;
|
||||
}
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.green) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.green = (UINT8)tempcolor;
|
||||
firsti = 0;
|
||||
mul = 0;
|
||||
mulmax = 1;
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.blue) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.blue = (UINT8)tempcolor;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Color strength depends on image alpha
|
||||
INT32 tempcolor;
|
||||
for (i = 0; i < translen; i++)
|
||||
{
|
||||
RGBA_t tempc = V_GetColor(translation[i]);
|
||||
SETBRIGHTNESS(colorbrightnesses[i], tempc.s.red, tempc.s.green, tempc.s.blue); // store brightnesses for comparison
|
||||
}
|
||||
|
||||
tempcolor = ((image->s.red * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.red * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.red = (UINT8)tempcolor;
|
||||
for (i = 0; i < translen; i++)
|
||||
{
|
||||
if (brightness > colorbrightnesses[i]) // don't allow greater matches (because calculating a makeshift gradient for this is already a huge mess as is)
|
||||
continue;
|
||||
|
||||
tempcolor = ((image->s.green * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.green * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.green = (UINT8)tempcolor;
|
||||
compare = abs((INT16)(colorbrightnesses[i]) - (INT16)(brightness));
|
||||
|
||||
tempcolor = ((image->s.blue * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.blue * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.blue = (UINT8)tempcolor;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
if (compare < brightdif)
|
||||
{
|
||||
brightdif = (UINT16)compare;
|
||||
firsti = i; // best matching color that's equal brightness or darker
|
||||
}
|
||||
}
|
||||
|
||||
secondi = firsti+1; // next color in line
|
||||
if (secondi >= translen)
|
||||
{
|
||||
m = (INT16)brightness; // - 0;
|
||||
d = (INT16)colorbrightnesses[firsti]; // - 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m = (INT16)brightness - (INT16)colorbrightnesses[secondi];
|
||||
d = (INT16)colorbrightnesses[firsti] - (INT16)colorbrightnesses[secondi];
|
||||
}
|
||||
|
||||
if (m >= d)
|
||||
m = d-1;
|
||||
|
||||
mulmax = 16;
|
||||
|
||||
// calculate the "gradient" multiplier based on how close this color is to the one next in line
|
||||
if (m <= 0 || d <= 0)
|
||||
mul = 0;
|
||||
else
|
||||
mul = (mulmax-1) - ((m * mulmax) / d);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Just convert brightness to a skincolor value, use distance to next position to find the gradient multipler
|
||||
firsti = 0;
|
||||
|
||||
for (i = 1; i < translen; i++)
|
||||
{
|
||||
if (brightness >= cutoff[i])
|
||||
break;
|
||||
firsti = i;
|
||||
}
|
||||
|
||||
secondi = firsti+1;
|
||||
|
||||
mulmax = cutoff[firsti];
|
||||
if (secondi < translen)
|
||||
mulmax -= cutoff[secondi];
|
||||
|
||||
mul = cutoff[firsti] - brightness;
|
||||
}
|
||||
|
||||
blendcolor = V_GetColor(translation[firsti]);
|
||||
|
||||
if (mul > 0) // If it's 0, then we only need the first color.
|
||||
{
|
||||
if (secondi >= translen) // blend to black
|
||||
nextcolor = V_GetColor(31);
|
||||
else
|
||||
nextcolor = V_GetColor(translation[secondi]);
|
||||
|
||||
// Find difference between points
|
||||
r = (INT32)(nextcolor.s.red - blendcolor.s.red);
|
||||
g = (INT32)(nextcolor.s.green - blendcolor.s.green);
|
||||
b = (INT32)(nextcolor.s.blue - blendcolor.s.blue);
|
||||
|
||||
// Find the gradient of the two points
|
||||
r = ((mul * r) / mulmax);
|
||||
g = ((mul * g) / mulmax);
|
||||
b = ((mul * b) / mulmax);
|
||||
|
||||
// Add gradient value to color
|
||||
blendcolor.s.red += r;
|
||||
blendcolor.s.green += g;
|
||||
blendcolor.s.blue += b;
|
||||
}
|
||||
}
|
||||
|
||||
if (skinnum == TC_RAINBOW)
|
||||
{
|
||||
UINT32 tempcolor;
|
||||
UINT16 colorbright;
|
||||
|
||||
SETBRIGHTNESS(colorbright,blendcolor.s.red,blendcolor.s.green,blendcolor.s.blue);
|
||||
if (colorbright == 0)
|
||||
colorbright = 1; // no dividing by 0 please
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.red) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.red = (UINT8)tempcolor;
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.green) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.green = (UINT8)tempcolor;
|
||||
|
||||
tempcolor = (brightness * blendcolor.s.blue) / colorbright;
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.blue = (UINT8)tempcolor;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Color strength depends on image alpha
|
||||
INT32 tempcolor;
|
||||
|
||||
tempcolor = ((image->s.red * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.red * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.red = (UINT8)tempcolor;
|
||||
|
||||
tempcolor = ((image->s.green * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.green * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.green = (UINT8)tempcolor;
|
||||
|
||||
tempcolor = ((image->s.blue * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.blue * blendimage->s.alpha) / 255);
|
||||
tempcolor = min(255, tempcolor);
|
||||
cur->s.blue = (UINT8)tempcolor;
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
|
||||
skippixel:
|
||||
|
||||
// *Now* we can do Metal Sonic's flashing
|
||||
if (skinnum == TC_METALSONIC)
|
||||
{
|
||||
// Blend dark blue into white
|
||||
if (cur->s.alpha > 0 && cur->s.red == 0 && cur->s.green == 0 && cur->s.blue < 255 && cur->s.blue > 31)
|
||||
{
|
||||
// Sal: Invert non-blue
|
||||
cur->s.red = cur->s.green = (255 - cur->s.blue);
|
||||
cur->s.blue = 255;
|
||||
}
|
||||
|
||||
cur->s.alpha = image->s.alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur++; image++; blendimage++;
|
||||
cur++; image++;
|
||||
|
||||
if (blendimage != NULL)
|
||||
blendimage++;
|
||||
}
|
||||
|
||||
return;
|
||||
|
@ -977,6 +1046,14 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
|
|||
// If here, the blended texture has not been created
|
||||
// So we create it
|
||||
|
||||
if ((blendgpatch && blendgpatch->mipmap->grInfo.format)
|
||||
&& (gpatch->width != blendgpatch->width || gpatch->height != blendgpatch->height))
|
||||
{
|
||||
// Blend image exists, but it's bad.
|
||||
HWD.pfnSetTexture(gpatch->mipmap);
|
||||
return;
|
||||
}
|
||||
|
||||
//BP: WARNING: don't free it manually without clearing the cache of harware renderer
|
||||
// (it have a liste of mipmap)
|
||||
// this malloc is cleared in HWR_FreeTextureCache
|
||||
|
@ -1108,7 +1185,7 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
|
|||
{
|
||||
sector_t *sector = spr->mobj->subsector->sector;
|
||||
UINT8 lightlevel = 255;
|
||||
extracolormap_t *colormap = sector->extra_colormap;
|
||||
extracolormap_t *colormap = NULL;
|
||||
|
||||
if (sector->numlights)
|
||||
{
|
||||
|
@ -1145,6 +1222,7 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
|
|||
INT32 durs = spr->mobj->state->tics;
|
||||
INT32 tics = spr->mobj->tics;
|
||||
//mdlframe_t *next = NULL;
|
||||
const boolean papersprite = (spr->mobj->frame & FF_PAPERSPRITE);
|
||||
const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !(spr->mobj->frame & FF_VERTICALFLIP));
|
||||
spritedef_t *sprdef;
|
||||
spriteframe_t *sprframe;
|
||||
|
@ -1220,50 +1298,44 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
|
|||
|
||||
if (gpatch && gpatch->mipmap->grInfo.format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture
|
||||
{
|
||||
if (md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap->grInfo.format
|
||||
&& gpatch->width == ((GLPatch_t *)md2->blendgrpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendgrpatch)->height)
|
||||
{
|
||||
INT32 skinnum = INT32_MAX;
|
||||
if ((spr->mobj->flags & (MF_ENEMY|MF_BOSS)) && (spr->mobj->flags2 & MF2_FRET) && !(spr->mobj->flags & MF_GRENADEBOUNCE) && (leveltime & 1)) // Bosses "flash"
|
||||
{
|
||||
if (spr->mobj->type == MT_CYBRAKDEMON || spr->mobj->colorized)
|
||||
skinnum = TC_ALLWHITE;
|
||||
else if (spr->mobj->type == MT_METALSONIC_BATTLE)
|
||||
skinnum = TC_METALSONIC;
|
||||
else
|
||||
skinnum = TC_BOSS;
|
||||
}
|
||||
else if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE)
|
||||
{
|
||||
if (spr->mobj->colorized)
|
||||
skinnum = TC_RAINBOW;
|
||||
else if (spr->mobj->player && spr->mobj->player->dashmode >= DASHMODE_THRESHOLD
|
||||
&& (spr->mobj->player->charflags & SF_DASHMODE)
|
||||
&& ((leveltime/2) & 1))
|
||||
{
|
||||
if (spr->mobj->player->charflags & SF_MACHINE)
|
||||
skinnum = TC_DASHMODE;
|
||||
else
|
||||
skinnum = TC_RAINBOW;
|
||||
}
|
||||
else if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
|
||||
skinnum = (INT32)((skin_t*)spr->mobj->skin-skins);
|
||||
else
|
||||
skinnum = TC_DEFAULT;
|
||||
}
|
||||
INT32 skinnum = INT32_MAX;
|
||||
|
||||
// Translation or skin number found
|
||||
if (skinnum != INT32_MAX)
|
||||
HWR_GetBlendedTexture(gpatch, (GLPatch_t *)md2->blendgrpatch, skinnum, spr->colormap, (skincolors_t)spr->mobj->color);
|
||||
if ((spr->mobj->flags & (MF_ENEMY|MF_BOSS)) && (spr->mobj->flags2 & MF2_FRET) && !(spr->mobj->flags & MF_GRENADEBOUNCE) && (leveltime & 1)) // Bosses "flash"
|
||||
{
|
||||
if (spr->mobj->type == MT_CYBRAKDEMON || spr->mobj->colorized)
|
||||
skinnum = TC_ALLWHITE;
|
||||
else if (spr->mobj->type == MT_METALSONIC_BATTLE)
|
||||
skinnum = TC_METALSONIC;
|
||||
else
|
||||
skinnum = TC_BOSS;
|
||||
}
|
||||
else if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE)
|
||||
{
|
||||
if (spr->mobj->colorized)
|
||||
skinnum = TC_RAINBOW;
|
||||
else if (spr->mobj->player && spr->mobj->player->dashmode >= DASHMODE_THRESHOLD
|
||||
&& (spr->mobj->player->charflags & SF_DASHMODE)
|
||||
&& ((leveltime/2) & 1))
|
||||
{
|
||||
// Sorry nothing
|
||||
HWD.pfnSetTexture(gpatch->mipmap);
|
||||
if (spr->mobj->player->charflags & SF_MACHINE)
|
||||
skinnum = TC_DASHMODE;
|
||||
else
|
||||
skinnum = TC_RAINBOW;
|
||||
}
|
||||
else if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
|
||||
skinnum = (INT32)((skin_t*)spr->mobj->skin-skins);
|
||||
else
|
||||
skinnum = TC_DEFAULT;
|
||||
}
|
||||
|
||||
// Translation or skin number found
|
||||
if (skinnum != INT32_MAX)
|
||||
{
|
||||
HWR_GetBlendedTexture(gpatch, (GLPatch_t *)md2->blendgrpatch, skinnum, spr->colormap, (skincolors_t)spr->mobj->color);
|
||||
}
|
||||
else
|
||||
{
|
||||
// This is safe, since we know the texture has been downloaded
|
||||
// Sorry nothing
|
||||
HWD.pfnSetTexture(gpatch->mipmap);
|
||||
}
|
||||
}
|
||||
|
@ -1361,14 +1433,12 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
|
|||
|
||||
sprframe = &sprdef->spriteframes[spr->mobj->frame & FF_FRAMEMASK];
|
||||
|
||||
if (sprframe->rotate)
|
||||
if (sprframe->rotate || papersprite)
|
||||
{
|
||||
fixed_t anglef = AngleFixed(spr->mobj->angle);
|
||||
|
||||
if (spr->mobj->player)
|
||||
anglef = AngleFixed(spr->mobj->player->drawangle);
|
||||
else
|
||||
anglef = AngleFixed(spr->mobj->angle);
|
||||
|
||||
p.angley = FIXED_TO_FLOAT(anglef);
|
||||
}
|
||||
|
|
|
@ -2273,14 +2273,30 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
|
|||
|
||||
EXPORT INT32 HWRAPI(GetTextureUsed) (void)
|
||||
{
|
||||
FTextureInfo* tmp = gr_cachehead;
|
||||
INT32 res = 0;
|
||||
FTextureInfo *tmp = gr_cachehead;
|
||||
INT32 res = 0;
|
||||
|
||||
while (tmp)
|
||||
{
|
||||
res += tmp->height*tmp->width*(screen_depth/8);
|
||||
// Figure out the correct bytes-per-pixel for this texture
|
||||
// I don't know which one the game actually _uses_ but this
|
||||
// follows format2bpp in hw_cache.c
|
||||
int bpp = 1;
|
||||
int format = tmp->grInfo.format;
|
||||
if (format == GR_RGBA)
|
||||
bpp = 4;
|
||||
else if (format == GR_TEXFMT_RGB_565
|
||||
|| format == GR_TEXFMT_ARGB_1555
|
||||
|| format == GR_TEXFMT_ARGB_4444
|
||||
|| format == GR_TEXFMT_ALPHA_INTENSITY_88
|
||||
|| format == GR_TEXFMT_AP_88)
|
||||
bpp = 2;
|
||||
|
||||
// Add it up!
|
||||
res += tmp->height*tmp->width*bpp;
|
||||
tmp = tmp->nextmipmap;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
|
@ -1173,6 +1173,8 @@ void HU_clearChatChars(void)
|
|||
w_chat[i] = 0; // reset this.
|
||||
chat_on = false;
|
||||
c_input = 0;
|
||||
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
|
||||
#ifndef NONET
|
||||
|
@ -1323,6 +1325,7 @@ boolean HU_Responder(event_t *ev)
|
|||
chat_on = false;
|
||||
c_input = 0; // reset input cursor
|
||||
chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
else if (c == KEY_ESCAPE
|
||||
|| ((c == gamecontrol[gc_talkkey][0] || c == gamecontrol[gc_talkkey][1]
|
||||
|
@ -1331,6 +1334,7 @@ boolean HU_Responder(event_t *ev)
|
|||
{
|
||||
chat_on = false;
|
||||
c_input = 0; // reset input cursor
|
||||
I_UpdateMouseGrab();
|
||||
}
|
||||
else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0 && !OLDCHAT) // CHAT SCROLLING YAYS!
|
||||
{
|
||||
|
@ -2117,6 +2121,9 @@ static void HU_DrawDemoInfo(void)
|
|||
//
|
||||
void HU_Drawer(void)
|
||||
{
|
||||
if (needpatchrecache)
|
||||
R_ReloadHUDGraphics();
|
||||
|
||||
#ifndef NONET
|
||||
// draw chat string plus cursor
|
||||
if (chat_on)
|
||||
|
@ -2194,10 +2201,14 @@ void HU_Drawer(void)
|
|||
return;
|
||||
|
||||
// draw the crosshair, not when viewing demos nor with chasecam
|
||||
if (!automapactive && cv_crosshair.value && !demoplayback && !camera.chase && !players[displayplayer].spectator)
|
||||
if (!automapactive && cv_crosshair.value && !demoplayback &&
|
||||
(!camera.chase || ticcmd_ztargetfocus[0])
|
||||
&& !players[displayplayer].spectator)
|
||||
HU_DrawCrosshair();
|
||||
|
||||
if (!automapactive && cv_crosshair2.value && !demoplayback && !camera2.chase && !players[secondarydisplayplayer].spectator)
|
||||
if (!automapactive && cv_crosshair2.value && !demoplayback &&
|
||||
(!camera2.chase || ticcmd_ztargetfocus[1])
|
||||
&& !players[secondarydisplayplayer].spectator)
|
||||
HU_DrawCrosshair2();
|
||||
|
||||
// draw desynch text
|
||||
|
@ -2434,7 +2445,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
|
|||
}
|
||||
}
|
||||
|
||||
if (G_GametypeUsesLives() && !(gametyperankings[gametype] == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
|
||||
if (G_GametypeUsesLives() && !(G_GametypeUsesCoopLives() && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
|
||||
V_DrawRightAlignedString(x, y+4, V_ALLOWLOWERCASE|(greycheck ? V_60TRANS : 0), va("%dx", players[tab[i].num].lives));
|
||||
else if (G_TagGametype() && players[tab[i].num].pflags & PF_TAGIT)
|
||||
{
|
||||
|
@ -2743,7 +2754,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
|
|||
| (greycheck ? V_TRANSLUCENT : 0)
|
||||
| V_ALLOWLOWERCASE, name);
|
||||
|
||||
if (G_GametypeUsesLives() && !(gametyperankings[gametype] == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
|
||||
if (G_GametypeUsesLives() && !(G_GametypeUsesCoopLives() && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
|
||||
V_DrawRightAlignedString(x, y+4, V_ALLOWLOWERCASE, va("%dx", players[tab[i].num].lives));
|
||||
else if (G_TagGametype() && players[tab[i].num].pflags & PF_TAGIT)
|
||||
V_DrawSmallScaledPatch(x-28, y-4, 0, tagico);
|
||||
|
|
|
@ -288,6 +288,10 @@ void I_GetJoystick2Events(void);
|
|||
*/
|
||||
void I_GetMouseEvents(void);
|
||||
|
||||
/** \brief Checks if the mouse needs to be grabbed
|
||||
*/
|
||||
void I_UpdateMouseGrab(void);
|
||||
|
||||
char *I_GetEnv(const char *name);
|
||||
|
||||
INT32 I_PutEnv(char *variable);
|
||||
|
|
|
@ -44,6 +44,7 @@ extern boolean highcolor;
|
|||
/** \brief setup video mode
|
||||
*/
|
||||
void I_StartupGraphics(void);
|
||||
void I_StartupHardwareGraphics(void);
|
||||
|
||||
/** \brief restore old video mode
|
||||
*/
|
||||
|
@ -84,6 +85,7 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h);
|
|||
\return currect video mode
|
||||
*/
|
||||
INT32 VID_SetMode(INT32 modenum);
|
||||
void VID_CheckRenderer(void);
|
||||
|
||||
/** \brief The VID_GetModeName function
|
||||
|
||||
|
|
37
src/info.c
37
src/info.c
|
@ -3565,7 +3565,7 @@ state_t states[NUMSTATES] =
|
|||
{SPR_PUMA, FF_FULLBRIGHT|FF_TRANS60|8, 3, {NULL}, 0, 0, S_NULL}, // S_PUMATRAIL4
|
||||
|
||||
// Hammer
|
||||
{SPR_HAMM, FF_ANIMATE, -1, {NULL}, 4, 3, S_NULL}, // S_HAMMER
|
||||
{SPR_HAMM, FF_ANIMATE, -1, {NULL}, 3, 3, S_NULL}, // S_HAMMER
|
||||
|
||||
// Koopa
|
||||
{SPR_KOOP, 0, -1, {NULL}, 0, 0, S_NULL}, // S_KOOPA1
|
||||
|
@ -19760,14 +19760,14 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
|
|||
|
||||
{ // MT_FLINGNIGHTSCHIP
|
||||
-1, // doomednum
|
||||
S_NIGHTSCHIP, // spawnstate
|
||||
S_NIGHTSCHIP, // spawnstate
|
||||
1000, // spawnhealth
|
||||
S_NULL, // seestate
|
||||
sfx_None, // seesound
|
||||
MT_FLINGNIGHTSCHIP, // reactiontime
|
||||
MT_FLINGNIGHTSCHIP, // reactiontime
|
||||
sfx_None, // attacksound
|
||||
S_NULL, // painstate
|
||||
MT_NIGHTSCHIP, // painchance
|
||||
MT_NIGHTSCHIP, // painchance
|
||||
sfx_None, // painsound
|
||||
S_NULL, // meleestate
|
||||
S_NULL, // missilestate
|
||||
|
@ -19791,7 +19791,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
|
|||
1000, // spawnhealth
|
||||
S_NIGHTSSTARXMAS, // seestate
|
||||
sfx_None, // seesound
|
||||
8, // reactiontime
|
||||
MT_FLINGNIGHTSSTAR, // reactiontime
|
||||
sfx_None, // attacksound
|
||||
S_NULL, // painstate
|
||||
0, // painchance
|
||||
|
@ -19811,6 +19811,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
|
|||
MF_SLIDEME|MF_SPECIAL|MF_NOGRAVITY|MF_NOCLIPHEIGHT, // flags
|
||||
S_NULL // raisestate
|
||||
},
|
||||
|
||||
{ // MT_FLINGNIGHTSSTAR
|
||||
-1, // doomednum
|
||||
S_NIGHTSSTAR, // spawnstate
|
||||
1000, // spawnhealth
|
||||
S_NIGHTSSTARXMAS, // seestate
|
||||
sfx_None, // seesound
|
||||
MT_FLINGNIGHTSSTAR, // reactiontime
|
||||
sfx_None, // attacksound
|
||||
S_NULL, // painstate
|
||||
MT_NIGHTSSTAR, // painchance
|
||||
sfx_s3k33, // painsound
|
||||
S_RING, // meleestate
|
||||
S_NULL, // missilestate
|
||||
S_SPRK1, // deathstate
|
||||
S_NULL, // xdeathstate
|
||||
sfx_ncitem, // deathsound
|
||||
38*FRACUNIT, // speed
|
||||
16*FRACUNIT, // radius
|
||||
24*FRACUNIT, // height
|
||||
0, // display offset
|
||||
100, // mass
|
||||
0, // damage
|
||||
sfx_None, // activesound
|
||||
MF_SLIDEME|MF_SPECIAL, // flags
|
||||
S_NULL // raisestate
|
||||
},
|
||||
|
||||
{ // MT_NIGHTSSUPERLOOP
|
||||
1707, // doomednum
|
||||
|
|
|
@ -4702,6 +4702,7 @@ typedef enum mobj_type
|
|||
MT_NIGHTSCHIP, // NiGHTS Chip
|
||||
MT_FLINGNIGHTSCHIP, // Lost NiGHTS Chip
|
||||
MT_NIGHTSSTAR, // NiGHTS Star
|
||||
MT_FLINGNIGHTSSTAR, // Lost NiGHTS Star
|
||||
MT_NIGHTSSUPERLOOP,
|
||||
MT_NIGHTSDRILLREFILL,
|
||||
MT_NIGHTSHELPER,
|
||||
|
|
|
@ -2878,6 +2878,22 @@ static int lib_gGametypeUsesLives(lua_State *L)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int lib_gGametypeUsesCoopLives(lua_State *L)
|
||||
{
|
||||
//HUDSAFE
|
||||
INLEVEL
|
||||
lua_pushboolean(L, G_GametypeUsesCoopLives());
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int lib_gGametypeUsesCoopStarposts(lua_State *L)
|
||||
{
|
||||
//HUDSAFE
|
||||
INLEVEL
|
||||
lua_pushboolean(L, G_GametypeUsesCoopStarposts());
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int lib_gGametypeHasTeams(lua_State *L)
|
||||
{
|
||||
//HUDSAFE
|
||||
|
@ -2918,6 +2934,14 @@ static int lib_gTagGametype(lua_State *L)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int lib_gCompetitionGametype(lua_State *L)
|
||||
{
|
||||
//HUDSAFE
|
||||
INLEVEL
|
||||
lua_pushboolean(L, G_CompetitionGametype());
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int lib_gTicsToHours(lua_State *L)
|
||||
{
|
||||
tic_t rtic = luaL_checkinteger(L, 1);
|
||||
|
@ -3165,11 +3189,14 @@ static luaL_Reg lib[] = {
|
|||
{"G_ExitLevel",lib_gExitLevel},
|
||||
{"G_IsSpecialStage",lib_gIsSpecialStage},
|
||||
{"G_GametypeUsesLives",lib_gGametypeUsesLives},
|
||||
{"G_GametypeUsesCoopLives",lib_gGametypeUsesCoopLives},
|
||||
{"G_GametypeUsesCoopStarposts",lib_gGametypeUsesCoopStarposts},
|
||||
{"G_GametypeHasTeams",lib_gGametypeHasTeams},
|
||||
{"G_GametypeHasSpectators",lib_gGametypeHasSpectators},
|
||||
{"G_RingSlingerGametype",lib_gRingSlingerGametype},
|
||||
{"G_PlatformGametype",lib_gPlatformGametype},
|
||||
{"G_TagGametype",lib_gTagGametype},
|
||||
{"G_CompetitionGametype",lib_gCompetitionGametype},
|
||||
{"G_TicsToHours",lib_gTicsToHours},
|
||||
{"G_TicsToMinutes",lib_gTicsToMinutes},
|
||||
{"G_TicsToSeconds",lib_gTicsToSeconds},
|
||||
|
|
|
@ -118,12 +118,12 @@ void COM_Lua_f(void)
|
|||
|
||||
lua_rawgeti(gL, -1, 2); // push flags from command info table
|
||||
if (lua_isboolean(gL, -1))
|
||||
flags = (lua_toboolean(gL, -1) ? 1 : 0);
|
||||
flags = (lua_toboolean(gL, -1) ? COM_ADMIN : 0);
|
||||
else
|
||||
flags = (UINT8)lua_tointeger(gL, -1);
|
||||
lua_pop(gL, 1); // pop flags
|
||||
|
||||
if (flags & 2) // flag 2: splitscreen player command.
|
||||
if (flags & COM_SPLITSCREEN) // flag 2: splitscreen player command.
|
||||
{
|
||||
if (!splitscreen)
|
||||
{
|
||||
|
@ -133,12 +133,12 @@ void COM_Lua_f(void)
|
|||
playernum = secondarydisplayplayer;
|
||||
}
|
||||
|
||||
if (netgame)
|
||||
if (netgame && !( flags & COM_LOCAL ))/* don't send local commands */
|
||||
{ // Send the command through the network
|
||||
UINT8 argc;
|
||||
lua_pop(gL, 1); // pop command info table
|
||||
|
||||
if (flags & 1 && !server && !IsPlayerAdmin(playernum)) // flag 1: only server/admin can use this command.
|
||||
if (flags & COM_ADMIN && !server && !IsPlayerAdmin(playernum)) // flag 1: only server/admin can use this command.
|
||||
{
|
||||
CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
|
||||
return;
|
||||
|
@ -158,7 +158,7 @@ void COM_Lua_f(void)
|
|||
WRITEUINT8(p, argc);
|
||||
for (i = 0; i < argc; i++)
|
||||
WRITESTRINGN(p, COM_Argv(i), 255);
|
||||
if (flags & 2)
|
||||
if (flags & COM_SPLITSCREEN)
|
||||
SendNetXCmd2(XD_LUACMD, buf, p-buf);
|
||||
else
|
||||
SendNetXCmd(XD_LUACMD, buf, p-buf);
|
||||
|
@ -192,7 +192,15 @@ static int lib_comAddCommand(lua_State *L)
|
|||
if (lua_gettop(L) >= 3)
|
||||
{ // For the third argument, only take a boolean or a number.
|
||||
lua_settop(L, 3);
|
||||
if (lua_type(L, 3) != LUA_TBOOLEAN)
|
||||
if (lua_type(L, 3) == LUA_TBOOLEAN)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING,
|
||||
"Using a boolean for admin commands is "
|
||||
"deprecated and will be removed.\n"
|
||||
"Use \"COM_ADMIN\" instead.\n"
|
||||
);
|
||||
}
|
||||
else
|
||||
luaL_checktype(L, 3, LUA_TNUMBER);
|
||||
}
|
||||
else
|
||||
|
@ -245,7 +253,7 @@ static int lib_comBufAddText(lua_State *L)
|
|||
return LUA_ErrInvalid(L, "player_t");
|
||||
if (plr != &players[consoleplayer])
|
||||
return 0;
|
||||
COM_BufAddText(va("%s\n", luaL_checkstring(L, 2)));
|
||||
COM_BufAddTextEx(va("%s\n", luaL_checkstring(L, 2)), COM_SAFE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -262,7 +270,7 @@ static int lib_comBufInsertText(lua_State *L)
|
|||
return LUA_ErrInvalid(L, "player_t");
|
||||
if (plr != &players[consoleplayer])
|
||||
return 0;
|
||||
COM_BufInsertText(va("%s\n", luaL_checkstring(L, 2)));
|
||||
COM_BufInsertTextEx(va("%s\n", luaL_checkstring(L, 2)), COM_SAFE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -427,6 +435,26 @@ static int lib_cvRegisterVar(lua_State *L)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int lib_cvFindVar(lua_State *L)
|
||||
{
|
||||
consvar_t *cv;
|
||||
if (( cv = CV_FindVar(luaL_checkstring(L,1)) ))
|
||||
{
|
||||
lua_settop(L,1);/* We only want one argument in the stack. */
|
||||
lua_pushlightuserdata(L, cv);/* Now the second value on stack. */
|
||||
luaL_getmetatable(L, META_CVAR);
|
||||
/*
|
||||
The metatable is the last value on the stack, so this
|
||||
applies it to the second value, which is the cvar.
|
||||
*/
|
||||
lua_setmetatable(L,2);
|
||||
lua_pushvalue(L,2);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
// CONS_Printf for a single player
|
||||
// Use 'print' in baselib for a global message.
|
||||
static int lib_consPrintf(lua_State *L)
|
||||
|
@ -466,6 +494,7 @@ static luaL_Reg lib[] = {
|
|||
{"COM_BufAddText", lib_comBufAddText},
|
||||
{"COM_BufInsertText", lib_comBufInsertText},
|
||||
{"CV_RegisterVar", lib_cvRegisterVar},
|
||||
{"CV_FindVar", lib_cvFindVar},
|
||||
{"CONS_Printf", lib_consPrintf},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
|
|
@ -20,9 +20,12 @@ enum hook {
|
|||
hook_MapChange,
|
||||
hook_MapLoad,
|
||||
hook_PlayerJoin,
|
||||
hook_PreThinkFrame,
|
||||
hook_ThinkFrame,
|
||||
hook_PostThinkFrame,
|
||||
hook_MobjSpawn,
|
||||
hook_MobjCollide,
|
||||
hook_MobjLineCollide,
|
||||
hook_MobjMoveCollide,
|
||||
hook_TouchSpecial,
|
||||
hook_MobjFuse,
|
||||
|
@ -53,6 +56,8 @@ enum hook {
|
|||
hook_IntermissionThinker,
|
||||
hook_TeamSwitch,
|
||||
hook_ViewpointSwitch,
|
||||
hook_SeenPlayer,
|
||||
hook_PlayerThink,
|
||||
|
||||
hook_MAX // last hook
|
||||
};
|
||||
|
@ -61,12 +66,16 @@ extern const char *const hookNames[];
|
|||
void LUAh_MapChange(INT16 mapnumber); // Hook for map change (before load)
|
||||
void LUAh_MapLoad(void); // Hook for map load
|
||||
void LUAh_PlayerJoin(int playernum); // Hook for Got_AddPlayer
|
||||
void LUAh_PreThinkFrame(void); // Hook for frame (before mobj and player thinkers)
|
||||
void LUAh_ThinkFrame(void); // Hook for frame (after mobj and player thinkers)
|
||||
void LUAh_PostThinkFrame(void); // Hook for frame (at end of tick, ie after overlays, precipitation, specials)
|
||||
boolean LUAh_MobjHook(mobj_t *mo, enum hook which);
|
||||
boolean LUAh_PlayerHook(player_t *plr, enum hook which);
|
||||
#define LUAh_MobjSpawn(mo) LUAh_MobjHook(mo, hook_MobjSpawn) // Hook for P_SpawnMobj by mobj type
|
||||
UINT8 LUAh_MobjCollideHook(mobj_t *thing1, mobj_t *thing2, enum hook which);
|
||||
UINT8 LUAh_MobjLineCollideHook(mobj_t *thing, line_t *line, enum hook which);
|
||||
#define LUAh_MobjCollide(thing1, thing2) LUAh_MobjCollideHook(thing1, thing2, hook_MobjCollide) // Hook for PIT_CheckThing by (thing) mobj type
|
||||
#define LUAh_MobjLineCollide(thing, line) LUAh_MobjLineCollideHook(thing, line, hook_MobjLineCollide) // Hook for PIT_CheckThing by (thing) mobj type
|
||||
#define LUAh_MobjMoveCollide(thing1, thing2) LUAh_MobjCollideHook(thing1, thing2, hook_MobjMoveCollide) // Hook for PIT_CheckThing by (tmthing) mobj type
|
||||
boolean LUAh_TouchSpecial(mobj_t *special, mobj_t *toucher); // Hook for P_TouchSpecialThing by mobj type
|
||||
#define LUAh_MobjFuse(mo) LUAh_MobjHook(mo, hook_MobjFuse) // Hook for mobj->fuse == 0 by mobj type
|
||||
|
@ -97,5 +106,9 @@ void LUAh_PlayerQuit(player_t *plr, int reason); // Hook for player quitting
|
|||
void LUAh_IntermissionThinker(void); // Hook for Y_Ticker
|
||||
boolean LUAh_TeamSwitch(player_t *player, int newteam, boolean fromspectators, boolean tryingautobalance, boolean tryingscramble); // Hook for team switching in... uh....
|
||||
UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean forced); // Hook for spy mode
|
||||
#ifdef SEENAMES
|
||||
boolean LUAh_SeenPlayer(player_t *player, player_t *seenfriend); // Hook for MT_NAMECHECK
|
||||
#endif
|
||||
#define LUAh_PlayerThink(player) LUAh_PlayerHook(player, hook_PlayerThink) // Hook for P_PlayerThink
|
||||
|
||||
#endif
|
||||
|
|
|
@ -31,9 +31,12 @@ const char *const hookNames[hook_MAX+1] = {
|
|||
"MapChange",
|
||||
"MapLoad",
|
||||
"PlayerJoin",
|
||||
"PreThinkFrame",
|
||||
"ThinkFrame",
|
||||
"PostThinkFrame",
|
||||
"MobjSpawn",
|
||||
"MobjCollide",
|
||||
"MobjLineCollide",
|
||||
"MobjMoveCollide",
|
||||
"TouchSpecial",
|
||||
"MobjFuse",
|
||||
|
@ -64,6 +67,8 @@ const char *const hookNames[hook_MAX+1] = {
|
|||
"IntermissionThinker",
|
||||
"TeamSwitch",
|
||||
"ViewpointSwitch",
|
||||
"SeenPlayer",
|
||||
"PlayerThink",
|
||||
NULL
|
||||
};
|
||||
|
||||
|
@ -123,6 +128,7 @@ static int lib_addHook(lua_State *L)
|
|||
// Take a mobjtype enum which this hook is specifically for.
|
||||
case hook_MobjSpawn:
|
||||
case hook_MobjCollide:
|
||||
case hook_MobjLineCollide:
|
||||
case hook_MobjMoveCollide:
|
||||
case hook_TouchSpecial:
|
||||
case hook_MobjFuse:
|
||||
|
@ -182,6 +188,7 @@ static int lib_addHook(lua_State *L)
|
|||
lastp = &mobjthinkerhooks[hook.s.mt];
|
||||
break;
|
||||
case hook_MobjCollide:
|
||||
case hook_MobjLineCollide:
|
||||
case hook_MobjMoveCollide:
|
||||
lastp = &mobjcollidehooks[hook.s.mt];
|
||||
break;
|
||||
|
@ -207,8 +214,10 @@ static int lib_addHook(lua_State *L)
|
|||
case hook_PlayerCanDamage:
|
||||
case hook_TeamSwitch:
|
||||
case hook_ViewpointSwitch:
|
||||
case hook_SeenPlayer:
|
||||
case hook_ShieldSpawn:
|
||||
case hook_ShieldSpecial:
|
||||
case hook_PlayerThink:
|
||||
lastp = &playerhooks;
|
||||
break;
|
||||
case hook_LinedefExecute:
|
||||
|
@ -411,6 +420,29 @@ void LUAh_PlayerJoin(int playernum)
|
|||
lua_settop(gL, 0);
|
||||
}
|
||||
|
||||
// Hook for frame (before mobj and player thinkers)
|
||||
void LUAh_PreThinkFrame(void)
|
||||
{
|
||||
hook_p hookp;
|
||||
if (!gL || !(hooksAvailable[hook_PreThinkFrame/8] & (1<<(hook_PreThinkFrame%8))))
|
||||
return;
|
||||
|
||||
for (hookp = roothook; hookp; hookp = hookp->next)
|
||||
{
|
||||
if (hookp->type != hook_PreThinkFrame)
|
||||
continue;
|
||||
|
||||
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
|
||||
lua_gettable(gL, LUA_REGISTRYINDEX);
|
||||
if (lua_pcall(gL, 0, 0, 0)) {
|
||||
if (!hookp->error || cv_debug & DBG_LUA)
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
hookp->error = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Hook for frame (after mobj and player thinkers)
|
||||
void LUAh_ThinkFrame(void)
|
||||
{
|
||||
|
@ -434,6 +466,30 @@ void LUAh_ThinkFrame(void)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// Hook for frame (at end of tick, ie after overlays, precipitation, specials)
|
||||
void LUAh_PostThinkFrame(void)
|
||||
{
|
||||
hook_p hookp;
|
||||
if (!gL || !(hooksAvailable[hook_PostThinkFrame/8] & (1<<(hook_PostThinkFrame%8))))
|
||||
return;
|
||||
|
||||
for (hookp = roothook; hookp; hookp = hookp->next)
|
||||
{
|
||||
if (hookp->type != hook_PostThinkFrame)
|
||||
continue;
|
||||
|
||||
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
|
||||
lua_gettable(gL, LUA_REGISTRYINDEX);
|
||||
if (lua_pcall(gL, 0, 0, 0)) {
|
||||
if (!hookp->error || cv_debug & DBG_LUA)
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
hookp->error = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Hook for mobj collisions
|
||||
UINT8 LUAh_MobjCollideHook(mobj_t *thing1, mobj_t *thing2, enum hook which)
|
||||
{
|
||||
|
@ -513,6 +569,84 @@ UINT8 LUAh_MobjCollideHook(mobj_t *thing1, mobj_t *thing2, enum hook which)
|
|||
return shouldCollide;
|
||||
}
|
||||
|
||||
UINT8 LUAh_MobjLineCollideHook(mobj_t *thing, line_t *line, enum hook which)
|
||||
{
|
||||
hook_p hookp;
|
||||
UINT8 shouldCollide = 0; // 0 = default, 1 = force yes, 2 = force no.
|
||||
if (!gL || !(hooksAvailable[which/8] & (1<<(which%8))))
|
||||
return 0;
|
||||
|
||||
I_Assert(thing->type < NUMMOBJTYPES);
|
||||
|
||||
lua_settop(gL, 0);
|
||||
|
||||
// Look for all generic mobj collision hooks
|
||||
for (hookp = mobjcollidehooks[MT_NULL]; hookp; hookp = hookp->next)
|
||||
{
|
||||
if (hookp->type != which)
|
||||
continue;
|
||||
|
||||
if (lua_gettop(gL) == 0)
|
||||
{
|
||||
LUA_PushUserdata(gL, thing, META_MOBJ);
|
||||
LUA_PushUserdata(gL, line, META_LINE);
|
||||
}
|
||||
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
|
||||
lua_gettable(gL, LUA_REGISTRYINDEX);
|
||||
lua_pushvalue(gL, -3);
|
||||
lua_pushvalue(gL, -3);
|
||||
if (lua_pcall(gL, 2, 1, 0)) {
|
||||
if (!hookp->error || cv_debug & DBG_LUA)
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
hookp->error = true;
|
||||
continue;
|
||||
}
|
||||
if (!lua_isnil(gL, -1))
|
||||
{ // if nil, leave shouldCollide = 0.
|
||||
if (lua_toboolean(gL, -1))
|
||||
shouldCollide = 1; // Force yes
|
||||
else
|
||||
shouldCollide = 2; // Force no
|
||||
}
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
|
||||
for (hookp = mobjcollidehooks[thing->type]; hookp; hookp = hookp->next)
|
||||
{
|
||||
if (hookp->type != which)
|
||||
continue;
|
||||
|
||||
if (lua_gettop(gL) == 0)
|
||||
{
|
||||
LUA_PushUserdata(gL, thing, META_MOBJ);
|
||||
LUA_PushUserdata(gL, line, META_LINE);
|
||||
}
|
||||
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
|
||||
lua_gettable(gL, LUA_REGISTRYINDEX);
|
||||
lua_pushvalue(gL, -3);
|
||||
lua_pushvalue(gL, -3);
|
||||
if (lua_pcall(gL, 2, 1, 0)) {
|
||||
if (!hookp->error || cv_debug & DBG_LUA)
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
hookp->error = true;
|
||||
continue;
|
||||
}
|
||||
if (!lua_isnil(gL, -1))
|
||||
{ // if nil, leave shouldCollide = 0.
|
||||
if (lua_toboolean(gL, -1))
|
||||
shouldCollide = 1; // Force yes
|
||||
else
|
||||
shouldCollide = 2; // Force no
|
||||
}
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
|
||||
lua_settop(gL, 0);
|
||||
return shouldCollide;
|
||||
}
|
||||
|
||||
// Hook for mobj thinkers
|
||||
boolean LUAh_MobjThinker(mobj_t *mo)
|
||||
{
|
||||
|
@ -1412,7 +1546,7 @@ UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean
|
|||
return 0;
|
||||
|
||||
lua_settop(gL, 0);
|
||||
hud_running = true;
|
||||
hud_running = true; // local hook
|
||||
|
||||
for (hookp = playerhooks; hookp; hookp = hookp->next)
|
||||
{
|
||||
|
@ -1453,4 +1587,49 @@ UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean
|
|||
return canSwitchView;
|
||||
}
|
||||
|
||||
// Hook for MT_NAMECHECK
|
||||
#ifdef SEENAMES
|
||||
boolean LUAh_SeenPlayer(player_t *player, player_t *seenfriend)
|
||||
{
|
||||
hook_p hookp;
|
||||
boolean hasSeenPlayer = true;
|
||||
if (!gL || !(hooksAvailable[hook_SeenPlayer/8] & (1<<(hook_SeenPlayer%8))))
|
||||
return 0;
|
||||
|
||||
lua_settop(gL, 0);
|
||||
hud_running = true; // local hook
|
||||
|
||||
for (hookp = playerhooks; hookp; hookp = hookp->next)
|
||||
{
|
||||
if (hookp->type != hook_SeenPlayer)
|
||||
continue;
|
||||
|
||||
if (lua_gettop(gL) == 0)
|
||||
{
|
||||
LUA_PushUserdata(gL, player, META_PLAYER);
|
||||
LUA_PushUserdata(gL, seenfriend, META_PLAYER);
|
||||
}
|
||||
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
|
||||
lua_gettable(gL, LUA_REGISTRYINDEX);
|
||||
lua_pushvalue(gL, -3);
|
||||
lua_pushvalue(gL, -3);
|
||||
if (lua_pcall(gL, 2, 1, 0)) {
|
||||
if (!hookp->error || cv_debug & DBG_LUA)
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
hookp->error = true;
|
||||
continue;
|
||||
}
|
||||
if (!lua_isnil(gL, -1) && !lua_toboolean(gL, -1))
|
||||
hasSeenPlayer = false; // Hasn't seen player
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
|
||||
lua_settop(gL, 0);
|
||||
hud_running = false;
|
||||
|
||||
return hasSeenPlayer;
|
||||
}
|
||||
#endif // SEENAMES
|
||||
|
||||
#endif
|
||||
|
|
101
src/lua_hudlib.c
101
src/lua_hudlib.c
|
@ -36,6 +36,11 @@ static UINT8 hud_enabled[(hud_MAX/8)+1];
|
|||
|
||||
static UINT8 hudAvailable; // hud hooks field
|
||||
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
static patchinfo_t *patchinfo, *patchinfohead;
|
||||
static int numluapatches;
|
||||
#endif
|
||||
|
||||
// must match enum hud in lua_hud.h
|
||||
static const char *const hud_disable_options[] = {
|
||||
"stagetitle",
|
||||
|
@ -256,12 +261,17 @@ static int colormap_get(lua_State *L)
|
|||
|
||||
static int patch_get(lua_State *L)
|
||||
{
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
patch_t *patch = *((patch_t **)luaL_checkudata(L, 1, META_PATCH));
|
||||
#else
|
||||
patchinfo_t *patch = *((patchinfo_t **)luaL_checkudata(L, 1, META_PATCH));
|
||||
#endif
|
||||
enum patch field = luaL_checkoption(L, 2, NULL, patch_opt);
|
||||
|
||||
// patches are CURRENTLY always valid, expected to be cached with PU_STATIC
|
||||
// this may change in the future, so patch.valid still exists
|
||||
I_Assert(patch != NULL);
|
||||
if (!patch)
|
||||
return LUA_ErrInvalid(L, "patch_t");
|
||||
|
||||
switch (field)
|
||||
{
|
||||
|
@ -358,8 +368,59 @@ static int libd_patchExists(lua_State *L)
|
|||
|
||||
static int libd_cachePatch(lua_State *L)
|
||||
{
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
int i;
|
||||
lumpnum_t lumpnum;
|
||||
patchinfo_t *luapat;
|
||||
patch_t *realpatch;
|
||||
|
||||
HUDONLY
|
||||
LUA_PushUserdata(L, W_CachePatchName(luaL_checkstring(L, 1), PU_STATIC), META_PATCH);
|
||||
|
||||
luapat = patchinfohead;
|
||||
lumpnum = W_CheckNumForName(luaL_checkstring(L, 1));
|
||||
if (lumpnum == LUMPERROR)
|
||||
lumpnum = W_GetNumForName("MISSING");
|
||||
|
||||
for (i = 0; i < numluapatches; i++)
|
||||
{
|
||||
// check if already cached
|
||||
if (luapat->wadnum == WADFILENUM(lumpnum) && luapat->lumpnum == LUMPNUM(lumpnum))
|
||||
{
|
||||
LUA_PushUserdata(L, luapat, META_PATCH);
|
||||
return 1;
|
||||
}
|
||||
luapat = luapat->next;
|
||||
if (!luapat)
|
||||
break;
|
||||
}
|
||||
|
||||
if (numluapatches > 0)
|
||||
{
|
||||
patchinfo->next = Z_Malloc(sizeof(patchinfo_t), PU_STATIC, NULL);
|
||||
patchinfo = patchinfo->next;
|
||||
}
|
||||
else
|
||||
{
|
||||
patchinfo = Z_Malloc(sizeof(patchinfo_t), PU_STATIC, NULL);
|
||||
patchinfohead = patchinfo;
|
||||
}
|
||||
|
||||
realpatch = W_CachePatchNum(lumpnum, PU_PATCH);
|
||||
|
||||
patchinfo->width = realpatch->width;
|
||||
patchinfo->height = realpatch->height;
|
||||
patchinfo->leftoffset = realpatch->leftoffset;
|
||||
patchinfo->topoffset = realpatch->topoffset;
|
||||
|
||||
patchinfo->wadnum = WADFILENUM(lumpnum);
|
||||
patchinfo->lumpnum = LUMPNUM(lumpnum);
|
||||
|
||||
LUA_PushUserdata(L, patchinfo, META_PATCH);
|
||||
numluapatches++;
|
||||
#else
|
||||
HUDONLY
|
||||
LUA_PushUserdata(L, W_CachePatchName(luaL_checkstring(L, 1), PU_PATCH), META_PATCH);
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -407,15 +468,15 @@ static int libd_getSpritePatch(lua_State *L)
|
|||
|
||||
// convert WAD editor angle numbers (1-8) to internal angle numbers (0-7)
|
||||
// keep 0 the same since we'll make it default to angle 1 (which is internally 0)
|
||||
// in case somebody didn't know that angle 0 really just maps all 8 angles to the same patch
|
||||
// in case somebody didn't know that angle 0 really just maps all 8/16 angles to the same patch
|
||||
if (angle != 0)
|
||||
angle--;
|
||||
|
||||
if (angle >= 8) // out of range?
|
||||
if (angle >= ((sprframe->rotate & SRF_3DGE) ? 16 : 8)) // out of range?
|
||||
return 0;
|
||||
|
||||
// push both the patch and it's "flip" value
|
||||
LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_STATIC), META_PATCH);
|
||||
LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_PATCH), META_PATCH);
|
||||
lua_pushboolean(L, (sprframe->flip & (1<<angle)) != 0);
|
||||
return 2;
|
||||
}
|
||||
|
@ -502,15 +563,15 @@ static int libd_getSprite2Patch(lua_State *L)
|
|||
|
||||
// convert WAD editor angle numbers (1-8) to internal angle numbers (0-7)
|
||||
// keep 0 the same since we'll make it default to angle 1 (which is internally 0)
|
||||
// in case somebody didn't know that angle 0 really just maps all 8 angles to the same patch
|
||||
// in case somebody didn't know that angle 0 really just maps all 8/16 angles to the same patch
|
||||
if (angle != 0)
|
||||
angle--;
|
||||
|
||||
if (angle >= 8) // out of range?
|
||||
if (angle >= ((sprframe->rotate & SRF_3DGE) ? 16 : 8)) // out of range?
|
||||
return 0;
|
||||
|
||||
// push both the patch and it's "flip" value
|
||||
LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_STATIC), META_PATCH);
|
||||
LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_PATCH), META_PATCH);
|
||||
lua_pushboolean(L, (sprframe->flip & (1<<angle)) != 0);
|
||||
return 2;
|
||||
}
|
||||
|
@ -519,12 +580,22 @@ static int libd_draw(lua_State *L)
|
|||
{
|
||||
INT32 x, y, flags;
|
||||
patch_t *patch;
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
patchinfo_t *luapat;
|
||||
#endif
|
||||
const UINT8 *colormap = NULL;
|
||||
|
||||
HUDONLY
|
||||
x = luaL_checkinteger(L, 1);
|
||||
y = luaL_checkinteger(L, 2);
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
luapat = *((patchinfo_t **)luaL_checkudata(L, 3, META_PATCH));
|
||||
patch = W_CachePatchNum((luapat->wadnum<<16)+luapat->lumpnum, PU_PATCH);
|
||||
#else
|
||||
patch = *((patch_t **)luaL_checkudata(L, 3, META_PATCH));
|
||||
if (!patch)
|
||||
return LUA_ErrInvalid(L, "patch_t");
|
||||
#endif
|
||||
flags = luaL_optinteger(L, 4, 0);
|
||||
if (!lua_isnoneornil(L, 5))
|
||||
colormap = *((UINT8 **)luaL_checkudata(L, 5, META_COLORMAP));
|
||||
|
@ -540,6 +611,9 @@ static int libd_drawScaled(lua_State *L)
|
|||
fixed_t x, y, scale;
|
||||
INT32 flags;
|
||||
patch_t *patch;
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
patchinfo_t *luapat;
|
||||
#endif
|
||||
const UINT8 *colormap = NULL;
|
||||
|
||||
HUDONLY
|
||||
|
@ -548,7 +622,14 @@ static int libd_drawScaled(lua_State *L)
|
|||
scale = luaL_checkinteger(L, 3);
|
||||
if (scale < 0)
|
||||
return luaL_error(L, "negative scale");
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
luapat = *((patchinfo_t **)luaL_checkudata(L, 4, META_PATCH));
|
||||
patch = W_CachePatchNum((luapat->wadnum<<16)+luapat->lumpnum, PU_PATCH);
|
||||
#else
|
||||
patch = *((patch_t **)luaL_checkudata(L, 4, META_PATCH));
|
||||
if (!patch)
|
||||
return LUA_ErrInvalid(L, "patch_t");
|
||||
#endif
|
||||
flags = luaL_optinteger(L, 5, 0);
|
||||
if (!lua_isnoneornil(L, 6))
|
||||
colormap = *((UINT8 **)luaL_checkudata(L, 6, META_COLORMAP));
|
||||
|
@ -1047,6 +1128,10 @@ int LUA_HudLib(lua_State *L)
|
|||
{
|
||||
memset(hud_enabled, 0xff, (hud_MAX/8)+1);
|
||||
|
||||
#ifdef LUA_PATCH_SAFETY
|
||||
numluapatches = 0;
|
||||
#endif
|
||||
|
||||
lua_newtable(L); // HUD registry table
|
||||
lua_newtable(L);
|
||||
luaL_register(L, NULL, lib_draw);
|
||||
|
|
|
@ -157,15 +157,13 @@ static const char *const side_opt[] = {
|
|||
enum vertex_e {
|
||||
vertex_valid = 0,
|
||||
vertex_x,
|
||||
vertex_y,
|
||||
vertex_z
|
||||
vertex_y
|
||||
};
|
||||
|
||||
static const char *const vertex_opt[] = {
|
||||
"valid",
|
||||
"x",
|
||||
"y",
|
||||
"z",
|
||||
NULL};
|
||||
|
||||
enum ffloor_e {
|
||||
|
@ -970,9 +968,6 @@ static int vertex_get(lua_State *L)
|
|||
case vertex_y:
|
||||
lua_pushfixed(L, vertex->y);
|
||||
return 1;
|
||||
case vertex_z:
|
||||
lua_pushfixed(L, vertex->z);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -299,9 +299,7 @@ int LUA_PushGlobals(lua_State *L, const char *word)
|
|||
// See the above.
|
||||
int LUA_CheckGlobals(lua_State *L, const char *word)
|
||||
{
|
||||
if (fastcmp(word, "gametyperules"))
|
||||
gametyperules = (UINT32)luaL_checkinteger(L, 2);
|
||||
else if (fastcmp(word, "redscore"))
|
||||
if (fastcmp(word, "redscore"))
|
||||
redscore = (UINT32)luaL_checkinteger(L, 2);
|
||||
else if (fastcmp(word, "bluescore"))
|
||||
bluescore = (UINT32)luaL_checkinteger(L, 2);
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2013-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2013-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 2013 by "Ninji".
|
||||
// Copyright (C) 2013-2019 by Sonic Team Junior.
|
||||
//
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2013-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2013-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 2013-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
|
|
@ -1304,7 +1304,7 @@ void OP_ObjectplaceMovement(player_t *player)
|
|||
{
|
||||
ticcmd_t *cmd = &player->cmd;
|
||||
|
||||
if (!player->climbing && (netgame || !cv_analog.value || (player->pflags & PF_SPINNING)))
|
||||
if (!player->climbing && (netgame || !cv_analog[0].value || (player->pflags & PF_SPINNING)))
|
||||
player->drawangle = player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
|
||||
|
||||
ticruned++;
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2012-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2012-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 2012-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
|
16
src/m_cond.h
16
src/m_cond.h
|
@ -1,6 +1,6 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2012-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2012-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 2012-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
@ -97,12 +97,13 @@ typedef struct
|
|||
} emblem_t;
|
||||
typedef struct
|
||||
{
|
||||
char name[20]; ///< Name of the goal (used in the "emblem awarded" cecho)
|
||||
char description[40];///< Description of goal (used in statistics)
|
||||
UINT8 conditionset; ///< Condition set that awards this emblem.
|
||||
UINT8 sprite; ///< emblem sprite to use, 0 - 25
|
||||
UINT8 color; ///< skincolor to use
|
||||
UINT8 collected; ///< Do you have this emblem?
|
||||
char name[20]; ///< Name of the goal (used in the "emblem awarded" cecho)
|
||||
char description[40]; ///< Description of goal (used in statistics)
|
||||
UINT8 conditionset; ///< Condition set that awards this emblem.
|
||||
UINT8 showconditionset; ///< Condition set that shows this emblem.
|
||||
UINT8 sprite; ///< emblem sprite to use, 0 - 25
|
||||
UINT8 color; ///< skincolor to use
|
||||
UINT8 collected; ///< Do you have this emblem?
|
||||
} extraemblem_t;
|
||||
|
||||
// Unlockable information
|
||||
|
@ -112,6 +113,7 @@ typedef struct
|
|||
char objective[64];
|
||||
UINT16 height; // menu height
|
||||
UINT8 conditionset;
|
||||
UINT8 showconditionset;
|
||||
INT16 type;
|
||||
INT16 variable;
|
||||
UINT8 nocecho;
|
||||
|
|
1039
src/m_menu.c
1039
src/m_menu.c
File diff suppressed because it is too large
Load diff
|
@ -2,7 +2,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 2011-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2011-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 1999-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
@ -81,6 +81,8 @@ typedef enum
|
|||
MN_OP_P2JOYSTICK,
|
||||
MN_OP_P2CAMERA,
|
||||
|
||||
MN_OP_PLAYSTYLE,
|
||||
|
||||
MN_OP_VIDEO,
|
||||
MN_OP_VIDEOMODE,
|
||||
MN_OP_COLOR,
|
||||
|
@ -222,13 +224,14 @@ boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt);
|
|||
|
||||
// flags for items in the menu
|
||||
// menu handle (what we do when key is pressed
|
||||
#define IT_TYPE 14 // (2+4+8)
|
||||
#define IT_TYPE 15 // (1+2+4+8)
|
||||
#define IT_CALL 0 // call the function
|
||||
#define IT_SPACE 1 // no handling
|
||||
#define IT_ARROWS 2 // call function with 0 for left arrow and 1 for right arrow in param
|
||||
#define IT_KEYHANDLER 4 // call with the key in param
|
||||
#define IT_SUBMENU 6 // go to sub menu
|
||||
#define IT_CVAR 8 // handle as a cvar
|
||||
#define IT_SPACE 10 // no handling
|
||||
#define IT_PAIR 11 // no handling, define both sides of text
|
||||
#define IT_MSGHANDLER 12 // same as key but with event and sometime can handle y/n key (special for message)
|
||||
|
||||
#define IT_DISPLAY (48+64+128) // 16+32+64+128
|
||||
|
|
18
src/m_misc.c
18
src/m_misc.c
|
@ -600,12 +600,12 @@ void M_SaveConfig(const char *filename)
|
|||
CV_SetValue(&cv_usemouse, tutorialusemouse);
|
||||
CV_SetValue(&cv_alwaysfreelook, tutorialfreelook);
|
||||
CV_SetValue(&cv_mousemove, tutorialmousemove);
|
||||
CV_SetValue(&cv_analog, tutorialanalog);
|
||||
CV_SetValue(&cv_analog[0], tutorialanalog);
|
||||
CV_SaveVariables(f);
|
||||
CV_Set(&cv_usemouse, cv_usemouse.defaultvalue);
|
||||
CV_Set(&cv_alwaysfreelook, cv_alwaysfreelook.defaultvalue);
|
||||
CV_Set(&cv_mousemove, cv_mousemove.defaultvalue);
|
||||
CV_Set(&cv_analog, cv_analog.defaultvalue);
|
||||
CV_Set(&cv_analog[0], cv_analog[0].defaultvalue);
|
||||
}
|
||||
else
|
||||
CV_SaveVariables(f);
|
||||
|
@ -1908,6 +1908,20 @@ void M_UnGetToken(void)
|
|||
endPos = oldendPos;
|
||||
}
|
||||
|
||||
/** Returns the current token's position.
|
||||
*/
|
||||
UINT32 M_GetTokenPos(void)
|
||||
{
|
||||
return endPos;
|
||||
}
|
||||
|
||||
/** Sets the current token's position.
|
||||
*/
|
||||
void M_SetTokenPos(UINT32 newPos)
|
||||
{
|
||||
endPos = newPos;
|
||||
}
|
||||
|
||||
/** Count bits in a number.
|
||||
*/
|
||||
UINT8 M_CountBits(UINT32 num, UINT8 size)
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 2012-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2012-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 1999-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 2012-2016 by Matthew "Inuyasha" Walsh.
|
||||
// Copyright (C) 2012-2016 by Matthew "Kaito Sinclaire" Walsh.
|
||||
// Copyright (C) 1999-2019 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
|
|
|
@ -14225,7 +14225,7 @@ void A_SaloonDoorSpawn(mobj_t *actor)
|
|||
fixed_t c = FINECOSINE(fa)*locvar2;
|
||||
fixed_t s = FINESINE(fa)*locvar2;
|
||||
mobj_t *door;
|
||||
mobjflag2_t ambush = (actor->flags & MF2_AMBUSH);
|
||||
mobjflag2_t ambush = (actor->flags2 & MF2_AMBUSH);
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
if (LUA_CallAction("A_SaloonDoorSpawn", actor))
|
||||
|
@ -14603,12 +14603,9 @@ void A_RolloutRock(mobj_t *actor)
|
|||
if (!actor->tracer || P_MobjWasRemoved(actor->tracer) || !actor->tracer->health)
|
||||
actor->flags |= MF_PUSHABLE;
|
||||
|
||||
if (!(actor->flags & MF_PUSHABLE)) // if being ridden, don't disappear
|
||||
actor->fuse = 0;
|
||||
else if (!actor->fuse && actor->movecount == 1) // otherwise if rock has moved, set its fuse
|
||||
if (!(actor->flags & MF_PUSHABLE) || (actor->movecount != 1)) // if being ridden or haven't moved, don't disappear
|
||||
actor->fuse = actor->info->painchance;
|
||||
|
||||
if (actor->fuse && actor->fuse < 2*TICRATE)
|
||||
else if (actor->fuse < 2*TICRATE)
|
||||
actor->flags2 ^= MF2_DONTDRAW;
|
||||
|
||||
}
|
||||
|
|
|
@ -1451,7 +1451,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
|||
if (player->starpostnum >= special->health)
|
||||
return; // Already hit this post
|
||||
|
||||
if (cv_coopstarposts.value && gametype == GT_COOP && (netgame || multiplayer))
|
||||
if (cv_coopstarposts.value && G_GametypeUsesCoopStarposts() && (netgame || multiplayer))
|
||||
{
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
|
@ -1807,7 +1807,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
|||
return;
|
||||
|
||||
case MT_MINECARTSPAWNER:
|
||||
if (!player->bot && (special->fuse < TICRATE || player->powers[pw_carry] != CR_MINECART))
|
||||
if (!player->bot && special->fuse <= TICRATE && player->powers[pw_carry] != CR_MINECART)
|
||||
{
|
||||
mobj_t *mcart = P_SpawnMobj(special->x, special->y, special->z, MT_MINECART);
|
||||
P_SetTarget(&mcart->target, toucher);
|
||||
|
@ -2481,9 +2481,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
|
|||
|
||||
P_SetMobjState(scoremobj, scorestate);
|
||||
|
||||
// On ground? No chain starts.
|
||||
if (source->player->powers[pw_invulnerability] || !P_IsObjectOnGround(source))
|
||||
source->player->scoreadd = locscoreadd;
|
||||
source->player->scoreadd = locscoreadd;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2523,7 +2521,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
|
|||
target->colorized = false;
|
||||
G_GhostAddColor(GHC_NORMAL);
|
||||
|
||||
if ((target->player->lives <= 1) && (netgame || multiplayer) && (gametype == GT_COOP) && (cv_cooplives.value == 0))
|
||||
if ((target->player->lives <= 1) && (netgame || multiplayer) && G_GametypeUsesCoopLives() && (cv_cooplives.value == 0))
|
||||
;
|
||||
else if (!target->player->bot && !target->player->spectator && (target->player->lives != INFLIVES)
|
||||
&& G_GametypeUsesLives())
|
||||
|
@ -2533,7 +2531,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
|
|||
if (target->player->lives <= 0) // Tails 03-14-2000
|
||||
{
|
||||
boolean gameovermus = false;
|
||||
if ((netgame || multiplayer) && (gametype == GT_COOP) && (cv_cooplives.value != 1))
|
||||
if ((netgame || multiplayer) && G_GametypeUsesCoopLives() && (cv_cooplives.value != 1))
|
||||
{
|
||||
INT32 i;
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
|
@ -3201,10 +3199,12 @@ static void P_KillPlayer(player_t *player, mobj_t *source, INT32 damage)
|
|||
player->powers[pw_carry] = CR_NONE;
|
||||
|
||||
// Burst weapons and emeralds in Match/CTF only
|
||||
if (source && (gametype == GT_MATCH || gametype == GT_TEAMMATCH || gametype == GT_CTF))
|
||||
if (source)
|
||||
{
|
||||
P_PlayerRingBurst(player, player->rings);
|
||||
P_PlayerEmeraldBurst(player, false);
|
||||
if ((gametyperules & GTR_RINGSLINGER) && !(gametyperules & GTR_TAG))
|
||||
P_PlayerRingBurst(player, player->rings);
|
||||
if (gametyperules & GTR_POWERSTONES)
|
||||
P_PlayerEmeraldBurst(player, false);
|
||||
}
|
||||
|
||||
// Get rid of shield
|
||||
|
|
|
@ -120,6 +120,10 @@ extern consvar_t cv_cam_speed, cv_cam_rotate, cv_cam_rotspeed, cv_cam_turnmultip
|
|||
extern consvar_t cv_cam2_dist, cv_cam2_still, cv_cam2_height;
|
||||
extern consvar_t cv_cam2_speed, cv_cam2_rotate, cv_cam2_rotspeed, cv_cam2_turnmultiplier, cv_cam2_orbit, cv_cam2_adjust;
|
||||
|
||||
extern consvar_t cv_cam_savedist[2][2], cv_cam_saveheight[2][2];
|
||||
void CV_UpdateCamDist(void);
|
||||
void CV_UpdateCam2Dist(void);
|
||||
|
||||
extern fixed_t t_cam_dist, t_cam_height, t_cam_rotate;
|
||||
extern fixed_t t_cam2_dist, t_cam2_height, t_cam2_rotate;
|
||||
|
||||
|
@ -181,16 +185,14 @@ fixed_t P_ReturnThrustX(mobj_t *mo, angle_t angle, fixed_t move);
|
|||
fixed_t P_ReturnThrustY(mobj_t *mo, angle_t angle, fixed_t move);
|
||||
void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move);
|
||||
|
||||
mobj_t *P_LookForFocusTarget(player_t *player, mobj_t *exclude, SINT8 direction, UINT8 lockonflags);
|
||||
|
||||
mobj_t *P_LookForEnemies(player_t *player, boolean nonenemies, boolean bullet);
|
||||
void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
|
||||
boolean P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
|
||||
boolean P_SuperReady(player_t *player);
|
||||
void P_DoJump(player_t *player, boolean soundandstate);
|
||||
#if 0
|
||||
boolean P_AnalogMove(player_t *player);
|
||||
#else
|
||||
#define P_AnalogMove(player) (player->pflags & PF_ANALOGMODE)
|
||||
#endif
|
||||
#define P_AnalogMove(player) (P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
boolean P_TransferToNextMare(player_t *player);
|
||||
UINT8 P_FindLowestMare(void);
|
||||
void P_FindEmerald(void);
|
||||
|
|
73
src/p_map.c
73
src/p_map.c
|
@ -377,7 +377,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|
|||
{
|
||||
object->angle = object->player->drawangle = spring->angle;
|
||||
|
||||
if (!demoplayback || P_AnalogMove(object->player))
|
||||
if (!demoplayback || P_ControlStyle(object->player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (object->player == &players[consoleplayer])
|
||||
localangle = spring->angle;
|
||||
|
@ -426,7 +426,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|
|||
object->player->pflags |= pflags;
|
||||
object->player->secondjump = secondjump;
|
||||
}
|
||||
else if (object->player->dashmode >= 3*TICRATE)
|
||||
else if (object->player->dashmode >= DASHMODE_THRESHOLD)
|
||||
P_SetPlayerMobjState(object, S_PLAY_DASH);
|
||||
else if (P_IsObjectOnGround(object) && horizspeed >= FixedMul(object->player->runspeed, object->scale))
|
||||
P_SetPlayerMobjState(object, S_PLAY_RUN);
|
||||
|
@ -632,7 +632,7 @@ static void P_DoTailsCarry(player_t *sonic, player_t *tails)
|
|||
&& P_MobjFlip(tails->mo)*sonic->mo->momz <= 0)
|
||||
{
|
||||
if (sonic-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, false);
|
||||
CV_SetValue(&cv_analog[1], false);
|
||||
P_ResetPlayer(sonic);
|
||||
P_SetTarget(&sonic->mo->tracer, tails->mo);
|
||||
sonic->powers[pw_carry] = CR_PLAYER;
|
||||
|
@ -644,7 +644,7 @@ static void P_DoTailsCarry(player_t *sonic, player_t *tails)
|
|||
}
|
||||
else {
|
||||
if (sonic-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, true);
|
||||
CV_SetValue(&cv_analog[1], true);
|
||||
P_SetTarget(&sonic->mo->tracer, NULL);
|
||||
sonic->powers[pw_carry] = CR_NONE;
|
||||
}
|
||||
|
@ -745,9 +745,8 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
// So that NOTHING ELSE can see MT_NAMECHECK because it is client-side.
|
||||
if (tmthing->type == MT_NAMECHECK)
|
||||
{
|
||||
// Ignore things that aren't players, ignore spectators, ignore yourself.
|
||||
// (also don't bother to check that tmthing->target->player is non-NULL because we're not actually using it here.)
|
||||
if (!thing->player || thing->player->spectator || (tmthing->target && thing->player == tmthing->target->player))
|
||||
// Ignore things that aren't players, ignore spectators, ignore yourself.
|
||||
if (!thing->player || !(tmthing->target && tmthing->target->player) || thing->player->spectator || (tmthing->target && thing->player == tmthing->target->player))
|
||||
return true;
|
||||
|
||||
// Now check that you actually hit them.
|
||||
|
@ -760,6 +759,12 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
if (tmthing->z + tmthing->height < thing->z)
|
||||
return true; // underneath
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
// REX HAS SEEN YOU
|
||||
if (!LUAh_SeenPlayer(tmthing->target->player, thing->player))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
seenplayer = thing->player;
|
||||
return false;
|
||||
}
|
||||
|
@ -801,7 +806,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
|
||||
// SF_DASHMODE users destroy spikes and monitors, CA_TWINSPIN users and CA2_MELEE users destroy spikes.
|
||||
if ((tmthing->player)
|
||||
&& (((tmthing->player->charflags & SF_DASHMODE) && (tmthing->player->dashmode >= 3*TICRATE)
|
||||
&& ((((tmthing->player->charflags & (SF_DASHMODE|SF_MACHINE)) == (SF_DASHMODE|SF_MACHINE)) && (tmthing->player->dashmode >= DASHMODE_THRESHOLD)
|
||||
&& (thing->flags & (MF_MONITOR)
|
||||
|| (thing->type == MT_SPIKE
|
||||
|| thing->type == MT_WALLSPIKE)))
|
||||
|
@ -829,13 +834,13 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
for (iter = thing->subsector->sector->thinglist; iter; iter = iter->snext)
|
||||
if (iter->type == thing->type && iter->health > 0 && iter->flags & MF_SOLID && (iter == thing || P_AproxDistance(P_AproxDistance(thing->x - iter->x, thing->y - iter->y), thing->z - iter->z) < 56*thing->scale))//FixedMul(56*FRACUNIT, thing->scale))
|
||||
P_KillMobj(iter, tmthing, tmthing, 0);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
thing->health = 0;
|
||||
P_KillMobj(thing, tmthing, tmthing, 0);
|
||||
if (P_DamageMobj(thing, tmthing, tmthing, 1, 0))
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// vectorise metal - done in a special case as at this point neither has the right flags for touching
|
||||
|
@ -995,7 +1000,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
if (thing->type == MT_SALOONDOOR && tmthing->player)
|
||||
{
|
||||
mobj_t *ref = (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)) ? tmthing->tracer : tmthing;
|
||||
if ((thing->flags & MF2_AMBUSH) || ref != tmthing)
|
||||
if ((thing->flags2 & MF2_AMBUSH) || ref != tmthing)
|
||||
{
|
||||
fixed_t dm = min(FixedHypot(ref->momx, ref->momy), 16*FRACUNIT);
|
||||
angle_t ang = R_PointToAngle2(0, 0, ref->momx, ref->momy) - thing->angle;
|
||||
|
@ -1008,7 +1013,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
|
||||
if (thing->type == MT_SALOONDOORCENTER && tmthing->player)
|
||||
{
|
||||
if ((thing->flags & MF2_AMBUSH) || (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)))
|
||||
if ((thing->flags2 & MF2_AMBUSH) || (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)))
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -1322,7 +1327,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
|
||||
thing->angle = tmthing->angle;
|
||||
|
||||
if (!demoplayback || P_AnalogMove(thing->player))
|
||||
if (!demoplayback || P_ControlStyle(thing->player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (thing->player == &players[consoleplayer])
|
||||
localangle = thing->angle;
|
||||
|
@ -1621,7 +1626,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
|||
}
|
||||
else if (thing->player) {
|
||||
if (thing->player-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, true);
|
||||
CV_SetValue(&cv_analog[1], true);
|
||||
if (thing->player->powers[pw_carry] == CR_PLAYER)
|
||||
{
|
||||
P_SetTarget(&thing->tracer, NULL);
|
||||
|
@ -1943,6 +1948,19 @@ static boolean PIT_CheckLine(line_t *ld)
|
|||
|
||||
// this line is out of the if so upper and lower textures can be hit by a splat
|
||||
blockingline = ld;
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
{
|
||||
UINT8 shouldCollide = LUAh_MobjLineCollide(tmthing, blockingline); // checks hook for thing's type
|
||||
if (P_MobjWasRemoved(tmthing))
|
||||
return true; // one of them was removed???
|
||||
if (shouldCollide == 1)
|
||||
return false; // force collide
|
||||
else if (shouldCollide == 2)
|
||||
return true; // force no collide
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!ld->backsector) // one sided line
|
||||
{
|
||||
if (P_PointOnLineSide(tmthing->x, tmthing->y, ld))
|
||||
|
@ -3406,6 +3424,31 @@ boolean P_CheckMoveBlocked(line_t *li, mobj_t *mo)
|
|||
return true;
|
||||
}
|
||||
|
||||
if (!(mo->flags & MF_MISSILE))
|
||||
{
|
||||
if (li->flags & ML_IMPASSIBLE)
|
||||
return false;
|
||||
|
||||
if ((mo->flags & (MF_ENEMY|MF_BOSS)) && li->flags & ML_BLOCKMONSTERS)
|
||||
return false;
|
||||
}
|
||||
|
||||
// set openrange, opentop, openbottom
|
||||
P_LineOpening(li, mo);
|
||||
|
||||
if (openrange < mo->height)
|
||||
return false; // doesn't fit
|
||||
|
||||
if (opentop - mo->z < mo->height)
|
||||
return false; // mobj is too high
|
||||
|
||||
if (openbottom - mo->z > FixedMul(MAXSTEPMOVE, mo->scale))
|
||||
return false; // too big a step up
|
||||
|
||||
// this line doesn't block movement
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// PTR_SlideTraverse
|
||||
//
|
||||
|
|
|
@ -78,68 +78,37 @@ void P_ClosestPointOnLine(fixed_t x, fixed_t y, line_t *line, vertex_t *result)
|
|||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// P_ClosestPointOnLine3D
|
||||
// Finds the closest point on a given line to the supplied point IN 3D!!!
|
||||
//
|
||||
void P_ClosestPointOnLine3D(fixed_t x, fixed_t y, fixed_t z, line_t *line, vertex_t *result)
|
||||
/// Similar to FV3_ClosestPointOnLine() except it actually works.
|
||||
void P_ClosestPointOnLine3D(const vector3_t *p, const vector3_t *Line, vector3_t *result)
|
||||
{
|
||||
fixed_t startx = line->v1->x;
|
||||
fixed_t starty = line->v1->y;
|
||||
fixed_t startz = line->v1->z;
|
||||
fixed_t dx = line->dx;
|
||||
fixed_t dy = line->dy;
|
||||
fixed_t dz = line->v2->z - line->v1->z;
|
||||
const vector3_t* v1 = &Line[0];
|
||||
const vector3_t* v2 = &Line[1];
|
||||
vector3_t c, V, n;
|
||||
fixed_t t, d;
|
||||
FV3_SubEx(v2, v1, &V);
|
||||
FV3_SubEx(p, v1, &c);
|
||||
|
||||
// Determine t (the length of the vector from <20>Line[0]<5D> to <20>p<EFBFBD>)
|
||||
fixed_t cx, cy, cz;
|
||||
fixed_t vx, vy, vz;
|
||||
fixed_t magnitude;
|
||||
fixed_t t;
|
||||
d = R_PointToDist2(0, v2->z, R_PointToDist2(v2->x, v2->y, v1->x, v1->y), v1->z);
|
||||
FV3_Copy(&n, &V);
|
||||
FV3_Divide(&n, d);
|
||||
|
||||
//Sub (p, &Line[0], &c);
|
||||
cx = x - startx;
|
||||
cy = y - starty;
|
||||
cz = z - startz;
|
||||
|
||||
//Sub (&Line[1], &Line[0], &V);
|
||||
vx = dx;
|
||||
vy = dy;
|
||||
vz = dz;
|
||||
|
||||
//Normalize (&V, &V);
|
||||
magnitude = R_PointToDist2(0, line->v2->z, R_PointToDist2(line->v2->x, line->v2->y, startx, starty), startz);
|
||||
vx = FixedDiv(vx, magnitude);
|
||||
vy = FixedDiv(vy, magnitude);
|
||||
vz = FixedDiv(vz, magnitude);
|
||||
|
||||
t = (FixedMul(vx, cx) + FixedMul(vy, cy) + FixedMul(vz, cz));
|
||||
t = FV3_Dot(&n, &c);
|
||||
|
||||
// Set closest point to the end if it extends past -Red
|
||||
if (t <= 0)
|
||||
{
|
||||
result->x = line->v1->x;
|
||||
result->y = line->v1->y;
|
||||
result->z = line->v1->z;
|
||||
FV3_Copy(result, v1);
|
||||
return;
|
||||
}
|
||||
else if (t >= magnitude)
|
||||
else if (t >= d)
|
||||
{
|
||||
result->x = line->v2->x;
|
||||
result->y = line->v2->y;
|
||||
result->z = line->v2->z;
|
||||
FV3_Copy(result, v2);
|
||||
return;
|
||||
}
|
||||
|
||||
// Return the point between <20>Line[0]<5D> and <20>Line[1]<5D>
|
||||
vx = FixedMul(vx, t);
|
||||
vy = FixedMul(vy, t);
|
||||
vz = FixedMul(vz, t);
|
||||
FV3_Mul(&n, t);
|
||||
|
||||
//Add (&Line[0], &V, out);
|
||||
result->x = startx + vx;
|
||||
result->y = starty + vy;
|
||||
result->z = startz + vz;
|
||||
FV3_AddEx(v1, &n, result);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -43,7 +43,7 @@ boolean P_PathTraverse(fixed_t px1, fixed_t py1, fixed_t px2, fixed_t py2,
|
|||
|
||||
FUNCMATH fixed_t P_AproxDistance(fixed_t dx, fixed_t dy);
|
||||
void P_ClosestPointOnLine(fixed_t x, fixed_t y, line_t *line, vertex_t *result);
|
||||
void P_ClosestPointOnLine3D(fixed_t x, fixed_t y, fixed_t z, line_t *line, vertex_t *result);
|
||||
void P_ClosestPointOnLine3D(const vector3_t *p, const vector3_t *line, vector3_t *result);
|
||||
INT32 P_PointOnLineSide(fixed_t x, fixed_t y, line_t *line);
|
||||
void P_MakeDivline(line_t *li, divline_t *dl);
|
||||
void P_CameraLineOpening(line_t *plinedef);
|
||||
|
|
28
src/p_mobj.c
28
src/p_mobj.c
|
@ -1892,7 +1892,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
#endif
|
||||
|
||||
// Pushables can break some blocks
|
||||
if (CheckForBustableBlocks && mo->flags & MF_PUSHABLE)
|
||||
if (CheckForBustableBlocks && ((mo->flags & MF_PUSHABLE) || ((mo->info->flags & MF_PUSHABLE) && mo->fuse)))
|
||||
P_PushableCheckBustables(mo);
|
||||
|
||||
if (!P_TryMove(mo, mo->x + xmove, mo->y + ymove, true)
|
||||
|
@ -3127,7 +3127,7 @@ nightsdone:
|
|||
{
|
||||
// DO THE MARIO!
|
||||
if (rover->flags & FF_SHATTERBOTTOM) // Brick block!
|
||||
EV_CrumbleChain(NULL, rover); // node->m_sector
|
||||
EV_CrumbleChain(node->m_sector, rover);
|
||||
else // Question block!
|
||||
EV_MarioBlock(rover, node->m_sector, mo);
|
||||
}
|
||||
|
@ -3298,7 +3298,7 @@ boolean P_CanRunOnWater(player_t *player, ffloor_t *rover)
|
|||
*rover->topheight;
|
||||
|
||||
if (!player->powers[pw_carry] && !player->homing
|
||||
&& ((player->powers[pw_super] || player->charflags & SF_RUNONWATER || player->dashmode >= 3*TICRATE) && player->mo->ceilingz-topheight >= player->mo->height)
|
||||
&& ((player->powers[pw_super] || player->charflags & SF_RUNONWATER || player->dashmode >= DASHMODE_THRESHOLD) && player->mo->ceilingz-topheight >= player->mo->height)
|
||||
&& (rover->flags & FF_SWIMMABLE) && !(player->pflags & PF_SPINNING) && player->speed > FixedMul(player->runspeed, player->mo->scale)
|
||||
&& !(player->pflags & PF_SLIDING)
|
||||
&& abs(player->mo->z - topheight) < FixedMul(30*FRACUNIT, player->mo->scale))
|
||||
|
@ -7286,7 +7286,7 @@ static void P_FlameJetSceneryThink(mobj_t *mobj)
|
|||
if (!(mobj->flags2 & MF2_FIRING))
|
||||
return;
|
||||
|
||||
if ((leveltime & 3) == 0)
|
||||
if ((leveltime & 3) != 0)
|
||||
return;
|
||||
|
||||
// Wave the flames back and forth. Reactiontime determines which direction it's going.
|
||||
|
@ -7325,7 +7325,7 @@ static void P_VerticalFlameJetSceneryThink(mobj_t *mobj)
|
|||
if (!(mobj->flags2 & MF2_FIRING))
|
||||
return;
|
||||
|
||||
if ((leveltime & 3) == 0)
|
||||
if ((leveltime & 3) != 0)
|
||||
return;
|
||||
|
||||
// Wave the flames back and forth. Reactiontime determines which direction it's going.
|
||||
|
@ -7977,15 +7977,19 @@ static void P_MobjSceneryThink(mobj_t *mobj)
|
|||
mobj->x = mobj->extravalue1 + P_ReturnThrustX(mobj, mobj->movedir, mobj->cvmem*mobj->scale);
|
||||
mobj->y = mobj->extravalue2 + P_ReturnThrustY(mobj, mobj->movedir, mobj->cvmem*mobj->scale);
|
||||
P_SetThingPosition(mobj);
|
||||
if ((--mobj->fuse) < 6)
|
||||
|
||||
if (!mobj->fuse)
|
||||
{
|
||||
if (!mobj->fuse)
|
||||
{
|
||||
#ifdef HAVE_BLUA
|
||||
if (!LUAh_MobjFuse(mobj))
|
||||
#endif
|
||||
P_RemoveMobj(mobj);
|
||||
return;
|
||||
}
|
||||
mobj->frame = (mobj->frame & ~FF_TRANSMASK) | ((10 - (mobj->fuse*2)) << (FF_TRANSSHIFT));
|
||||
return;
|
||||
}
|
||||
if (mobj->fuse < 0)
|
||||
return;
|
||||
if ((--mobj->fuse) < 6)
|
||||
mobj->frame = (mobj->frame & ~FF_TRANSMASK) | ((10 - (mobj->fuse*2)) << (FF_TRANSSHIFT));
|
||||
}
|
||||
break;
|
||||
case MT_VWREF:
|
||||
|
@ -11823,7 +11827,7 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
|
|||
if (!cv_powerstones.value)
|
||||
return false;
|
||||
|
||||
if (!(gametyperules & GTR_MATCHEMERALDS))
|
||||
if (!(gametyperules & GTR_POWERSTONES))
|
||||
return false;
|
||||
|
||||
runemeraldmanager = true;
|
||||
|
|
|
@ -1351,9 +1351,9 @@ static void Polyobj_rotateThings(polyobj_t *po, vertex_t origin, angle_t delta,
|
|||
if (turnthings == 2 || (turnthings == 1 && !mo->player)) {
|
||||
mo->angle += delta;
|
||||
if (mo->player == &players[consoleplayer])
|
||||
localangle = mo->angle;
|
||||
localangle += delta;
|
||||
else if (mo->player == &players[secondarydisplayplayer])
|
||||
localangle2 = mo->angle;
|
||||
localangle2 += delta;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1825,6 +1825,7 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
|||
if (po->thinker == NULL)
|
||||
po->thinker = &th->thinker;
|
||||
|
||||
/*
|
||||
// Find out target first.
|
||||
// We redo this each tic to make savegame compatibility easier.
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
|
@ -1843,6 +1844,9 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
|||
break;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
target = th->target;
|
||||
|
||||
if (!target)
|
||||
{
|
||||
|
@ -2025,6 +2029,8 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
|||
|
||||
target = waypoint;
|
||||
th->pointnum = target->health;
|
||||
// Set the mobj as your target! -- Monster Iestyn 27/12/19
|
||||
P_SetTarget(&th->target, target);
|
||||
|
||||
// calculate MOMX/MOMY/MOMZ for next waypoint
|
||||
// change slope
|
||||
|
@ -2651,6 +2657,9 @@ INT32 EV_DoPolyObjWaypoint(polywaypointdata_t *pwdata)
|
|||
|
||||
// Set pointnum
|
||||
th->pointnum = target->health;
|
||||
th->target = NULL; // set to NULL first so the below doesn't go wrong
|
||||
// Set the mobj as your target! -- Monster Iestyn 27/12/19
|
||||
P_SetTarget(&th->target, target);
|
||||
|
||||
// We don't deal with the mirror crap here, we'll
|
||||
// handle that in the T_Thinker function.
|
||||
|
|
|
@ -161,6 +161,8 @@ typedef struct polywaypoint_s
|
|||
fixed_t diffx;
|
||||
fixed_t diffy;
|
||||
fixed_t diffz;
|
||||
|
||||
mobj_t *target; // next waypoint mobj
|
||||
} polywaypoint_t;
|
||||
|
||||
typedef struct polyslidedoor_s
|
||||
|
|
|
@ -2055,6 +2055,7 @@ static void SavePolywaypointThinker(const thinker_t *th, UINT8 type)
|
|||
WRITEFIXED(save_p, ht->diffx);
|
||||
WRITEFIXED(save_p, ht->diffy);
|
||||
WRITEFIXED(save_p, ht->diffz);
|
||||
WRITEUINT32(save_p, SaveMobjnum(ht->target));
|
||||
}
|
||||
|
||||
//
|
||||
|
@ -3244,6 +3245,7 @@ static inline thinker_t* LoadPolywaypointThinker(actionf_p1 thinker)
|
|||
ht->diffx = READFIXED(save_p);
|
||||
ht->diffy = READFIXED(save_p);
|
||||
ht->diffz = READFIXED(save_p);
|
||||
ht->target = LoadMobj(READUINT32(save_p));
|
||||
return &ht->thinker;
|
||||
}
|
||||
|
||||
|
@ -3538,6 +3540,7 @@ static void P_NetUnArchiveThinkers(void)
|
|||
|
||||
case tc_polywaypoint:
|
||||
th = LoadPolywaypointThinker((actionf_p1)T_PolyObjWaypoint);
|
||||
restoreNum = true;
|
||||
break;
|
||||
|
||||
case tc_polyslidedoor:
|
||||
|
@ -3599,9 +3602,9 @@ static void P_NetUnArchiveThinkers(void)
|
|||
if (restoreNum)
|
||||
{
|
||||
executor_t *delay = NULL;
|
||||
polywaypoint_t *polywp = NULL;
|
||||
UINT32 mobjnum;
|
||||
for (currentthinker = thlist[THINK_MAIN].next; currentthinker != &thlist[THINK_MAIN];
|
||||
currentthinker = currentthinker->next)
|
||||
for (currentthinker = thlist[THINK_MAIN].next; currentthinker != &thlist[THINK_MAIN]; currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 != (actionf_p1)T_ExecutorDelay)
|
||||
continue;
|
||||
|
@ -3610,6 +3613,15 @@ static void P_NetUnArchiveThinkers(void)
|
|||
continue;
|
||||
delay->caller = P_FindNewPosition(mobjnum);
|
||||
}
|
||||
for (currentthinker = thlist[THINK_POLYOBJ].next; currentthinker != &thlist[THINK_POLYOBJ]; currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 != (actionf_p1)T_PolyObjWaypoint)
|
||||
continue;
|
||||
polywp = (void *)currentthinker;
|
||||
if (!(mobjnum = (UINT32)(size_t)polywp->target))
|
||||
continue;
|
||||
polywp->target = P_FindNewPosition(mobjnum);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
845
src/p_setup.c
845
src/p_setup.c
File diff suppressed because it is too large
Load diff
|
@ -98,6 +98,9 @@ void P_ScanThings(INT16 mapnum, INT16 wadnum, INT16 lumpnum);
|
|||
#endif
|
||||
void P_RespawnThings(void);
|
||||
boolean P_LoadLevel(boolean fromnetsave);
|
||||
#ifdef HWRENDER
|
||||
void HWR_SetupLevel(void);
|
||||
#endif
|
||||
boolean P_AddWadFile(const char *wadfilename);
|
||||
boolean P_RunSOC(const char *socfilename);
|
||||
void P_LoadSoundsRange(UINT16 wadnum, UINT16 first, UINT16 num);
|
||||
|
|
|
@ -222,6 +222,9 @@ static boolean P_CrossSubsector(size_t num, register los_t *los)
|
|||
fixed_t fracx, fracy;
|
||||
#endif
|
||||
|
||||
if (seg->glseg)
|
||||
continue;
|
||||
|
||||
// already checked other side?
|
||||
if (line->validcount == validcount)
|
||||
continue;
|
||||
|
|
|
@ -50,10 +50,10 @@ static void ReconfigureViaVertexes (pslope_t *slope, const vector3_t v1, const v
|
|||
// Set some defaults for a non-sloped "slope"
|
||||
if (vec1.z == 0 && vec2.z == 0)
|
||||
{
|
||||
/// \todo Fix fully flat cases.
|
||||
|
||||
slope->zangle = slope->xydirection = 0;
|
||||
slope->zdelta = slope->d.x = slope->d.y = 0;
|
||||
slope->normal.x = slope->normal.y = 0;
|
||||
slope->normal.z = FRACUNIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -653,7 +653,9 @@ void P_ReverseQuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope)
|
|||
// Handles slope ejection for objects
|
||||
void P_SlopeLaunch(mobj_t *mo)
|
||||
{
|
||||
if (!(mo->standingslope->flags & SL_NOPHYSICS)) // If there's physics, time for launching.
|
||||
if (!(mo->standingslope->flags & SL_NOPHYSICS) // If there's physics, time for launching.
|
||||
&& (mo->standingslope->normal.x != 0
|
||||
|| mo->standingslope->normal.y != 0))
|
||||
{
|
||||
// Double the pre-rotation Z, then halve the post-rotation Z. This reduces the
|
||||
// vertical launch given from slopes while increasing the horizontal launch
|
||||
|
@ -710,8 +712,7 @@ fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope)
|
|||
void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope)
|
||||
{
|
||||
vector3_t mom; // Ditto.
|
||||
|
||||
if (slope->flags & SL_NOPHYSICS) { // No physics, no need to make anything complicated.
|
||||
if (slope->flags & SL_NOPHYSICS || (slope->normal.x == 0 && slope->normal.y == 0)) { // No physics, no need to make anything complicated.
|
||||
if (P_MobjFlip(thing)*(thing->momz) < 0) // falling, land on slope
|
||||
{
|
||||
thing->standingslope = slope;
|
||||
|
|
55
src/p_spec.c
55
src/p_spec.c
|
@ -52,9 +52,6 @@ mobj_t *skyboxcenterpnts[16]; // array of MT_SKYBOX centerpoint mobjs
|
|||
// Amount (dx, dy) vector linedef is shifted right to get scroll amount
|
||||
#define SCROLL_SHIFT 5
|
||||
|
||||
// This must be updated whenever we up the max flat size - quicker to assume rather than figuring out the sqrt of the specific flat's filesize.
|
||||
#define MAXFLATSIZE (2048<<FRACBITS)
|
||||
|
||||
/** Animated texture descriptor
|
||||
* This keeps track of an animated texture or an animated flat.
|
||||
* \sa P_UpdateSpecials, P_InitPicAnims, animdef_t
|
||||
|
@ -1890,7 +1887,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
|
|||
while (node)
|
||||
{
|
||||
mo = node->m_thing;
|
||||
if (mo->flags & MF_PUSHABLE)
|
||||
if ((mo->flags & MF_PUSHABLE) || ((mo->info->flags & MF_PUSHABLE) && mo->fuse))
|
||||
numpush++;
|
||||
node = node->m_thinglist_next;
|
||||
}
|
||||
|
@ -4617,7 +4614,7 @@ DoneSection2:
|
|||
|
||||
player->mo->angle = player->drawangle = lineangle;
|
||||
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle;
|
||||
|
@ -5041,8 +5038,7 @@ DoneSection2:
|
|||
mobj_t *waypointlow = NULL;
|
||||
mobj_t *mo2;
|
||||
mobj_t *closest = NULL;
|
||||
line_t junk;
|
||||
vertex_t v1, v2, resulthigh, resultlow;
|
||||
vector3_t p, line[2], resulthigh, resultlow;
|
||||
mobj_t *highest = NULL;
|
||||
|
||||
if (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT && player->powers[pw_carry] == CR_ROPEHANG)
|
||||
|
@ -5189,38 +5185,34 @@ DoneSection2:
|
|||
// Next, we need to find the closest point on the line between each set, and determine which one we're
|
||||
// closest to.
|
||||
|
||||
p.x = player->mo->x;
|
||||
p.y = player->mo->y;
|
||||
p.z = player->mo->z;
|
||||
|
||||
// Waypointmid and Waypointlow:
|
||||
if (waypointlow)
|
||||
{
|
||||
v1.x = waypointmid->x;
|
||||
v1.y = waypointmid->y;
|
||||
v1.z = waypointmid->z;
|
||||
v2.x = waypointlow->x;
|
||||
v2.y = waypointlow->y;
|
||||
v2.z = waypointlow->z;
|
||||
junk.v1 = &v1;
|
||||
junk.v2 = &v2;
|
||||
junk.dx = v2.x - v1.x;
|
||||
junk.dy = v2.y - v1.y;
|
||||
line[0].x = waypointmid->x;
|
||||
line[0].y = waypointmid->y;
|
||||
line[0].z = waypointmid->z;
|
||||
line[1].x = waypointlow->x;
|
||||
line[1].y = waypointlow->y;
|
||||
line[1].z = waypointlow->z;
|
||||
|
||||
P_ClosestPointOnLine3D(player->mo->x, player->mo->y, player->mo->z, &junk, &resultlow);
|
||||
P_ClosestPointOnLine3D(&p, line, &resultlow);
|
||||
}
|
||||
|
||||
// Waypointmid and Waypointhigh:
|
||||
if (waypointhigh)
|
||||
{
|
||||
v1.x = waypointmid->x;
|
||||
v1.y = waypointmid->y;
|
||||
v1.z = waypointmid->z;
|
||||
v2.x = waypointhigh->x;
|
||||
v2.y = waypointhigh->y;
|
||||
v2.z = waypointhigh->z;
|
||||
junk.v1 = &v1;
|
||||
junk.v2 = &v2;
|
||||
junk.dx = v2.x - v1.x;
|
||||
junk.dy = v2.y - v1.y;
|
||||
line[0].x = waypointmid->x;
|
||||
line[0].y = waypointmid->y;
|
||||
line[0].z = waypointmid->z;
|
||||
line[1].x = waypointhigh->x;
|
||||
line[1].y = waypointhigh->y;
|
||||
line[1].z = waypointhigh->z;
|
||||
|
||||
P_ClosestPointOnLine3D(player->mo->x, player->mo->y, player->mo->z, &junk, &resulthigh);
|
||||
P_ClosestPointOnLine3D(&p, line, &resulthigh);
|
||||
}
|
||||
|
||||
// 3D support now available. Disregard the previous notice here. -Red
|
||||
|
@ -8982,7 +8974,8 @@ void T_Pusher(pusher_t *p)
|
|||
|| thing->type == MT_EXTRALARGEBUBBLE))
|
||||
continue;
|
||||
|
||||
if (!(thing->flags & MF_PUSHABLE) && !(thing->type == MT_PLAYER
|
||||
if (!((thing->flags & MF_PUSHABLE) || ((thing->info->flags & MF_PUSHABLE) && thing->fuse))
|
||||
&& !(thing->type == MT_PLAYER
|
||||
|| thing->type == MT_SMALLBUBBLE
|
||||
|| thing->type == MT_MEDIUMBUBBLE
|
||||
|| thing->type == MT_EXTRALARGEBUBBLE
|
||||
|
@ -9135,7 +9128,7 @@ void T_Pusher(pusher_t *p)
|
|||
thing->player->pflags |= PF_SLIDING;
|
||||
thing->angle = R_PointToAngle2 (0, 0, xspeed<<(FRACBITS-PUSH_FACTOR), yspeed<<(FRACBITS-PUSH_FACTOR));
|
||||
|
||||
if (!demoplayback || P_AnalogMove(thing->player))
|
||||
if (!demoplayback || P_ControlStyle(thing->player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (thing->player == &players[consoleplayer])
|
||||
{
|
||||
|
|
|
@ -27,6 +27,9 @@ extern mobj_t *skyboxcenterpnts[16]; // array of MT_SKYBOX centerpoint mobjs
|
|||
//
|
||||
#define GETSECSPECIAL(i,j) ((i >> ((j-1)*4))&15)
|
||||
|
||||
// This must be updated whenever we up the max flat size - quicker to assume rather than figuring out the sqrt of the specific flat's filesize.
|
||||
#define MAXFLATSIZE (2048<<FRACBITS)
|
||||
|
||||
// at game start
|
||||
void P_InitPicAnims(void);
|
||||
|
||||
|
|
15
src/p_tick.c
15
src/p_tick.c
|
@ -629,6 +629,10 @@ void P_Ticker(boolean run)
|
|||
if (demoplayback)
|
||||
G_ReadDemoTiccmd(&players[consoleplayer].cmd, 0);
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PreThinkFrame();
|
||||
#endif
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
if (playeringame[i] && players[i].mo && !P_MobjWasRemoved(players[i].mo))
|
||||
P_PlayerThink(&players[i]);
|
||||
|
@ -726,6 +730,10 @@ void P_Ticker(boolean run)
|
|||
G_ConsGhostTic();
|
||||
if (modeattacking)
|
||||
G_GhostTicker();
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PostThinkFrame();
|
||||
#endif
|
||||
}
|
||||
|
||||
P_MapEnd();
|
||||
|
@ -745,6 +753,9 @@ void P_PreTicker(INT32 frames)
|
|||
{
|
||||
P_MapStart();
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PreThinkFrame();
|
||||
#endif
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
if (playeringame[i] && players[i].mo && !P_MobjWasRemoved(players[i].mo))
|
||||
{
|
||||
|
@ -779,6 +790,10 @@ void P_PreTicker(INT32 frames)
|
|||
P_UpdateSpecials();
|
||||
P_RespawnSpecials();
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PostThinkFrame();
|
||||
#endif
|
||||
|
||||
P_MapEnd();
|
||||
}
|
||||
}
|
||||
|
|
416
src/p_user.c
416
src/p_user.c
|
@ -42,6 +42,8 @@
|
|||
#include "b_bot.h"
|
||||
// Objectplace
|
||||
#include "m_cheat.h"
|
||||
// Thok camera snap (ctrl-f "chalupa")
|
||||
#include "g_input.h"
|
||||
|
||||
#ifdef HW3SOUND
|
||||
#include "hardware/hw3sound.h"
|
||||
|
@ -347,6 +349,11 @@ void P_GiveEmerald(boolean spawnObj)
|
|||
continue;
|
||||
P_SetTarget(&emmo->target, players[i].mo);
|
||||
P_SetMobjState(emmo, mobjinfo[MT_GOTEMERALD].meleestate + em);
|
||||
|
||||
// Make sure we're not being carried before our tracer is changed
|
||||
if (players[i].powers[pw_carry] != CR_NIGHTSMODE)
|
||||
players[i].powers[pw_carry] = CR_NONE;
|
||||
|
||||
P_SetTarget(&players[i].mo->tracer, emmo);
|
||||
|
||||
if (pnum == 255)
|
||||
|
@ -1058,7 +1065,7 @@ void P_ResetPlayer(player_t *player)
|
|||
player->onconveyor = 0;
|
||||
player->skidtime = 0;
|
||||
if (player-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, true);
|
||||
CV_SetValue(&cv_analog[1], true);
|
||||
}
|
||||
|
||||
// P_PlayerCanDamage
|
||||
|
@ -1230,13 +1237,13 @@ void P_GivePlayerLives(player_t *player, INT32 numlives)
|
|||
|
||||
if (gamestate == GS_LEVEL)
|
||||
{
|
||||
if (player->lives == INFLIVES || (gametype != GT_COOP && gametype != GT_COMPETITION))
|
||||
if (player->lives == INFLIVES || !(gametyperules & GTR_LIVES))
|
||||
{
|
||||
P_GivePlayerRings(player, 100*numlives);
|
||||
return;
|
||||
}
|
||||
|
||||
if ((netgame || multiplayer) && gametype == GT_COOP && cv_cooplives.value == 0)
|
||||
if ((netgame || multiplayer) && G_GametypeUsesCoopLives() && cv_cooplives.value == 0)
|
||||
{
|
||||
P_GivePlayerRings(player, 100*numlives);
|
||||
if (player->lives - prevlives >= numlives)
|
||||
|
@ -1267,7 +1274,7 @@ docooprespawn:
|
|||
|
||||
void P_GiveCoopLives(player_t *player, INT32 numlives, boolean sound)
|
||||
{
|
||||
if (!((netgame || multiplayer) && gametype == GT_COOP))
|
||||
if (!((netgame || multiplayer) && G_GametypeUsesCoopLives()))
|
||||
{
|
||||
P_GivePlayerLives(player, numlives);
|
||||
if (sound)
|
||||
|
@ -1395,7 +1402,7 @@ void P_AddPlayerScore(player_t *player, UINT32 amount)
|
|||
player->score = MAXSCORE;
|
||||
|
||||
// check for extra lives every 50000 pts
|
||||
if (!ultimatemode && !modeattacking && player->score > oldscore && player->score % 50000 < amount && (gametype == GT_COMPETITION || gametype == GT_COOP))
|
||||
if (!ultimatemode && !modeattacking && player->score > oldscore && player->score % 50000 < amount && (gametyperules & GTR_LIVES))
|
||||
{
|
||||
P_GivePlayerLives(player, (player->score/50000) - (oldscore/50000));
|
||||
P_PlayLivesJingle(player);
|
||||
|
@ -3573,7 +3580,7 @@ static void P_DoClimbing(player_t *player)
|
|||
}
|
||||
|
||||
#define CLIMBCONEMAX FixedAngle(90*FRACUNIT)
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
{
|
||||
|
@ -4388,7 +4395,7 @@ void P_DoJump(player_t *player, boolean soundandstate)
|
|||
|
||||
player->drawangle = player->mo->angle = player->mo->angle - ANGLE_180; // Turn around from the wall you were climbing.
|
||||
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle; // Adjust the local control angle.
|
||||
|
@ -4432,7 +4439,7 @@ void P_DoJump(player_t *player, boolean soundandstate)
|
|||
player->powers[pw_carry] = CR_NONE;
|
||||
P_SetTarget(&player->mo->tracer, NULL);
|
||||
if (player-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, true);
|
||||
CV_SetValue(&cv_analog[1], true);
|
||||
}
|
||||
else if (player->powers[pw_carry] == CR_GENERIC)
|
||||
{
|
||||
|
@ -4631,6 +4638,12 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
|
|||
S_StartSound(player->mo, sfx_spin);
|
||||
break;
|
||||
}
|
||||
if (player->dashspeed < player->mindash)
|
||||
player->dashspeed = player->mindash;
|
||||
|
||||
if (player->dashspeed > player->maxdash)
|
||||
player->dashspeed = player->maxdash;
|
||||
|
||||
if (player->dashspeed < player->maxdash && player->mindash != player->maxdash)
|
||||
{
|
||||
#define chargecalculation (6*(player->dashspeed - player->mindash))/(player->maxdash - player->mindash)
|
||||
|
@ -4713,7 +4726,7 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
|
|||
{
|
||||
player->mo->angle = R_PointToAngle2(player->mo->x, player->mo->y, lockon->x, lockon->y);
|
||||
bullet = P_SpawnPointMissile(player->mo, lockon->x, lockon->y, zpos(lockon), player->revitem, player->mo->x, player->mo->y, zpos(player->mo));
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle;
|
||||
|
@ -5342,6 +5355,16 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
|
|||
|
||||
player->pflags &= ~(PF_SPINNING|PF_STARTDASH);
|
||||
player->pflags |= PF_THOKKED;
|
||||
|
||||
// Change localangle to match for simple controls? (P.S. chalupa)
|
||||
// disabled because it seemed to disorient people and Z-targeting exists now
|
||||
/*if (!demoplayback)
|
||||
{
|
||||
if (player == &players[consoleplayer] && cv_cam_turnfacingability[0].value > 0 && !(PLAYER1INPUTDOWN(gc_turnleft) || PLAYER1INPUTDOWN(gc_turnright)))
|
||||
localangle = player->mo->angle;
|
||||
else if (player == &players[secondarydisplayplayer] && cv_cam_turnfacingability[1].value > 0 && !(PLAYER2INPUTDOWN(gc_turnleft) || PLAYER2INPUTDOWN(gc_turnright)))
|
||||
localangle2 = player->mo->angle;
|
||||
}*/
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -5596,13 +5619,6 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
|
|||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
boolean P_AnalogMove(player_t *player)
|
||||
{
|
||||
return player->pflags & PF_ANALOGMODE;
|
||||
}
|
||||
#endif
|
||||
|
||||
//
|
||||
// P_GetPlayerControlDirection
|
||||
//
|
||||
|
@ -5641,7 +5657,7 @@ INT32 P_GetPlayerControlDirection(player_t *player)
|
|||
origtempangle = tempangle = 0; // relative to the axis rather than the player!
|
||||
controlplayerdirection = R_PointToAngle2(0, 0, player->mo->momx, player->mo->momy);
|
||||
}
|
||||
else if (P_AnalogMove(player) && thiscam->chase)
|
||||
else if ((P_ControlStyle(player) & CS_LMAOGALOG) && thiscam->chase)
|
||||
{
|
||||
if (player->awayviewtics)
|
||||
origtempangle = tempangle = player->awayviewmobj->angle;
|
||||
|
@ -5867,7 +5883,7 @@ static void P_3dMovement(player_t *player)
|
|||
INT32 mforward = 0, mbackward = 0;
|
||||
angle_t dangle; // replaces old quadrants bits
|
||||
fixed_t normalspd = FixedMul(player->normalspeed, player->mo->scale);
|
||||
boolean analogmove = false;
|
||||
controlstyle_e controlstyle;
|
||||
boolean spin = ((onground = P_IsObjectOnGround(player->mo)) && (player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING && (player->rmomx || player->rmomy) && !(player->pflags & PF_STARTDASH));
|
||||
fixed_t oldMagnitude, newMagnitude;
|
||||
#ifdef ESLOPE
|
||||
|
@ -5880,7 +5896,7 @@ static void P_3dMovement(player_t *player)
|
|||
// Get the old momentum; this will be needed at the end of the function! -SH
|
||||
oldMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
|
||||
|
||||
analogmove = P_AnalogMove(player);
|
||||
controlstyle = P_ControlStyle(player);
|
||||
|
||||
cmd = &player->cmd;
|
||||
|
||||
|
@ -5907,7 +5923,7 @@ static void P_3dMovement(player_t *player)
|
|||
}
|
||||
}
|
||||
|
||||
if (analogmove)
|
||||
if (controlstyle & CS_LMAOGALOG)
|
||||
{
|
||||
movepushangle = (cmd->angleturn<<16 /* not FRACBITS */);
|
||||
}
|
||||
|
@ -6053,7 +6069,7 @@ static void P_3dMovement(player_t *player)
|
|||
P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 15*FRACUNIT>>1), false);
|
||||
}
|
||||
}
|
||||
else if (!analogmove
|
||||
else if (!(controlstyle == CS_LMAOGALOG)
|
||||
&& cmd->forwardmove != 0 && !(player->pflags & PF_GLIDING || player->exiting
|
||||
|| (P_PlayerInPain(player) && !onground)))
|
||||
{
|
||||
|
@ -6092,7 +6108,7 @@ static void P_3dMovement(player_t *player)
|
|||
P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedDiv(cmd->sidemove*player->mo->scale, 15*FRACUNIT>>1));
|
||||
}
|
||||
// Analog movement control
|
||||
else if (analogmove)
|
||||
else if (controlstyle == CS_LMAOGALOG)
|
||||
{
|
||||
if (!(player->pflags & PF_GLIDING || player->exiting || P_PlayerInPain(player)))
|
||||
{
|
||||
|
@ -7780,6 +7796,7 @@ void P_ElementalFire(player_t *player, boolean cropcircle)
|
|||
flame->fuse = TICRATE*7; // takes about an extra second to hit the ground
|
||||
flame->destscale = player->mo->scale;
|
||||
P_SetScale(flame, player->mo->scale);
|
||||
flame->flags2 = (flame->flags2 & ~MF2_OBJECTFLIP)|(player->mo->flags2 & MF2_OBJECTFLIP);
|
||||
flame->eflags = (flame->eflags & ~MFE_VERTICALFLIP)|(player->mo->eflags & MFE_VERTICALFLIP);
|
||||
P_InstaThrust(flame, flame->angle, FixedMul(3*FRACUNIT, flame->scale));
|
||||
P_SetObjectMomZ(flame, 3*FRACUNIT, false);
|
||||
|
@ -8102,8 +8119,33 @@ static void P_MovePlayer(player_t *player)
|
|||
P_2dMovement(player);
|
||||
else
|
||||
{
|
||||
if (!player->climbing && (!P_AnalogMove(player)))
|
||||
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
|
||||
if (!player->climbing)
|
||||
{
|
||||
switch (P_ControlStyle(player))
|
||||
{
|
||||
case CS_LEGACY:
|
||||
case CS_STANDARD:
|
||||
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
|
||||
break;
|
||||
|
||||
case CS_LMAOGALOG:
|
||||
break; // handled elsewhere
|
||||
|
||||
case CS_SIMPLE:
|
||||
if (cmd->forwardmove || cmd->sidemove)
|
||||
{
|
||||
angle_t controlangle = R_PointToAngle2(0, 0, cmd->forwardmove << FRACBITS, -cmd->sidemove << FRACBITS);
|
||||
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */) + controlangle;
|
||||
}
|
||||
else
|
||||
{
|
||||
angle_t drawangleoffset = (player->powers[pw_carry] == CR_ROLLOUT) ? ANGLE_180 : 0;
|
||||
player->mo->angle = player->drawangle + drawangleoffset;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ticruned++;
|
||||
if ((cmd->angleturn & TICCMD_RECEIVED) == 0)
|
||||
|
@ -8229,7 +8271,7 @@ static void P_MovePlayer(player_t *player)
|
|||
if (player->pflags & PF_GLIDING)
|
||||
{
|
||||
mobj_t *mo = player->mo; // seriously why isn't this at the top of the function hngngngng
|
||||
fixed_t leeway = !P_AnalogMove(player) ? FixedAngle(cmd->sidemove*(FRACUNIT)) : 0;
|
||||
fixed_t leeway = (P_ControlStyle(player) != CS_LMAOGALOG) ? FixedAngle(cmd->sidemove*(FRACUNIT)) : 0;
|
||||
fixed_t glidespeed = player->actionspd;
|
||||
fixed_t momx = mo->momx - player->cmomx, momy = mo->momy - player->cmomy;
|
||||
angle_t angle, moveangle = R_PointToAngle2(0, 0, momx, momy);
|
||||
|
@ -8501,7 +8543,7 @@ static void P_MovePlayer(player_t *player)
|
|||
//////////////////
|
||||
|
||||
// This really looks like it should be moved to P_3dMovement. -Red
|
||||
if (P_AnalogMove(player)
|
||||
if (P_ControlStyle(player) == CS_LMAOGALOG
|
||||
&& (cmd->forwardmove != 0 || cmd->sidemove != 0) && !player->climbing && !twodlevel && !(player->mo->flags2 & MF2_TWOD))
|
||||
{
|
||||
// If travelling slow enough, face the way the controls
|
||||
|
@ -9105,6 +9147,132 @@ void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius)
|
|||
}
|
||||
}
|
||||
|
||||
//
|
||||
// P_LookForFocusTarget
|
||||
// Looks for a target for a player to focus on, for Z-targeting etc.
|
||||
// exclude would be the current focus target, to ignore.
|
||||
// direction, if set, requires the target to be to the left (1) or right (-1) of the angle
|
||||
// mobjflags can be used to limit the flags of objects that can be focused
|
||||
//
|
||||
mobj_t *P_LookForFocusTarget(player_t *player, mobj_t *exclude, SINT8 direction, UINT8 lockonflags)
|
||||
{
|
||||
mobj_t *mo;
|
||||
thinker_t *think;
|
||||
mobj_t *closestmo = NULL;
|
||||
const fixed_t maxdist = 2560*player->mo->scale;
|
||||
const angle_t span = ANGLE_45;
|
||||
fixed_t dist, closestdist = 0;
|
||||
angle_t dangle, closestdangle = 0;
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (mo->flags & MF_NOCLIPTHING)
|
||||
continue;
|
||||
|
||||
if (mo == player->mo || mo == exclude)
|
||||
continue;
|
||||
|
||||
if (mo->health <= 0) // dead
|
||||
continue;
|
||||
|
||||
switch (mo->type)
|
||||
{
|
||||
case MT_TNTBARREL:
|
||||
if (lockonflags & LOCK_INTERESTS)
|
||||
break;
|
||||
/*fallthru*/
|
||||
case MT_PLAYER: // Don't chase other players!
|
||||
case MT_DETON:
|
||||
continue; // Don't be STUPID, Sonic!
|
||||
|
||||
case MT_FAKEMOBILE:
|
||||
if (!(lockonflags & LOCK_BOSS))
|
||||
continue;
|
||||
break;
|
||||
|
||||
case MT_EGGSHIELD:
|
||||
if (!(lockonflags & LOCK_ENEMY))
|
||||
continue;
|
||||
break;
|
||||
|
||||
case MT_EGGSTATUE:
|
||||
if (tutorialmode)
|
||||
break; // Always focus egg statue in the tutorial
|
||||
/*fallthru*/
|
||||
default:
|
||||
|
||||
if ((lockonflags & LOCK_BOSS) && ((mo->flags & (MF_BOSS|MF_SHOOTABLE)) == (MF_BOSS|MF_SHOOTABLE))) // allows if it has the flags desired XOR it has the invert aimable flag
|
||||
{
|
||||
if (mo->flags2 & MF2_FRET)
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((lockonflags & LOCK_ENEMY) && (!((mo->flags & (MF_ENEMY|MF_SHOOTABLE)) == (MF_ENEMY|MF_SHOOTABLE)) != !(mo->flags2 & MF2_INVERTAIMABLE))) // allows if it has the flags desired XOR it has the invert aimable flag
|
||||
break;
|
||||
|
||||
if ((lockonflags & LOCK_INTERESTS) && (mo->flags & (MF_PUSHABLE|MF_MONITOR))) // allows if it has the flags desired XOR it has the invert aimable flag
|
||||
break;
|
||||
|
||||
continue; // not a valid object
|
||||
}
|
||||
|
||||
{
|
||||
fixed_t zdist = (player->mo->z + player->mo->height/2) - (mo->z + mo->height/2);
|
||||
dist = P_AproxDistance(player->mo->x-mo->x, player->mo->y-mo->y);
|
||||
|
||||
if (abs(zdist) > dist)
|
||||
continue; // Don't home outside of desired angle!
|
||||
|
||||
dist = P_AproxDistance(dist, zdist);
|
||||
if (dist > maxdist)
|
||||
continue; // out of range
|
||||
}
|
||||
|
||||
if ((twodlevel || player->mo->flags2 & MF2_TWOD)
|
||||
&& abs(player->mo->y-mo->y) > player->mo->radius)
|
||||
continue; // not in your 2d plane
|
||||
|
||||
dangle = R_PointToAngle2(player->mo->x, player->mo->y, mo->x, mo->y) - (
|
||||
!exclude ? player->mo->angle : R_PointToAngle2(player->mo->x, player->mo->y, exclude->x, exclude->y)
|
||||
);
|
||||
|
||||
if (direction)
|
||||
{
|
||||
if (direction == 1 && dangle > ANGLE_180)
|
||||
continue; // To the right of the player
|
||||
if (direction == -1 && dangle < ANGLE_180)
|
||||
continue; // To the left of the player
|
||||
}
|
||||
|
||||
if (dangle > ANGLE_180)
|
||||
dangle = InvAngle(dangle);
|
||||
|
||||
if (dangle > span)
|
||||
continue; // behind back
|
||||
|
||||
// Inflate dist by angle difference to bias toward objects at a closer angle
|
||||
dist = FixedDiv(dist, FINECOSINE(dangle>>ANGLETOFINESHIFT)*3);
|
||||
|
||||
if (closestmo && (exclude ? (dangle > closestdangle) : (dist > closestdist)))
|
||||
continue;
|
||||
|
||||
if (!P_CheckSight(player->mo, mo))
|
||||
continue; // out of sight
|
||||
|
||||
closestmo = mo;
|
||||
closestdist = dist;
|
||||
closestdangle = dangle;
|
||||
}
|
||||
|
||||
return closestmo;
|
||||
}
|
||||
|
||||
//
|
||||
// P_LookForEnemies
|
||||
// Looks for something you can hit - Used for homing attack
|
||||
|
@ -9220,7 +9388,7 @@ boolean P_HomingAttack(mobj_t *source, mobj_t *enemy) // Home in on your target
|
|||
if (source->player)
|
||||
{
|
||||
source->player->drawangle = source->angle;
|
||||
if (!demoplayback || P_AnalogMove(source->player))
|
||||
if (!demoplayback || P_ControlStyle(source->player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (source->player == &players[consoleplayer])
|
||||
localangle = source->angle;
|
||||
|
@ -9298,7 +9466,7 @@ boolean P_GetLives(player_t *player)
|
|||
{
|
||||
INT32 i, maxlivesplayer = -1, livescheck = 1;
|
||||
if (!(netgame || multiplayer)
|
||||
|| (gametype != GT_COOP)
|
||||
|| !G_GametypeUsesCoopLives()
|
||||
|| (player->lives == INFLIVES))
|
||||
return true;
|
||||
|
||||
|
@ -9447,7 +9615,7 @@ static void P_DeathThink(player_t *player)
|
|||
player->playerstate = PST_REBORN;
|
||||
else if ((player->lives > 0 || j != MAXPLAYERS) && !(!(netgame || multiplayer) && G_IsSpecialStage(gamemap))) // Don't allow "click to respawn" in special stages!
|
||||
{
|
||||
if (gametype == GT_COOP && (netgame || multiplayer) && cv_coopstarposts.value == 2)
|
||||
if (G_GametypeUsesCoopStarposts() && (netgame || multiplayer) && cv_coopstarposts.value == 2)
|
||||
{
|
||||
P_ConsiderAllGone();
|
||||
if ((player->deadtimer > TICRATE<<1) || ((cmd->buttons & BT_JUMP) && (player->deadtimer > TICRATE)))
|
||||
|
@ -9462,19 +9630,22 @@ static void P_DeathThink(player_t *player)
|
|||
// Respawn with jump button, force respawn time (3 second default, cheat protected) in shooter modes.
|
||||
if (cmd->buttons & BT_JUMP)
|
||||
{
|
||||
if (gametype != GT_COOP && player->spectator)
|
||||
// You're a spectator, so respawn right away.
|
||||
if ((gametyperules & GTR_SPECTATORS) && player->spectator)
|
||||
player->playerstate = PST_REBORN;
|
||||
else switch(gametype) {
|
||||
case GT_COOP:
|
||||
case GT_COMPETITION:
|
||||
case GT_RACE:
|
||||
if (player->deadtimer > TICRATE)
|
||||
player->playerstate = PST_REBORN;
|
||||
break;
|
||||
default:
|
||||
if (player->deadtimer > cv_respawntime.value*TICRATE)
|
||||
player->playerstate = PST_REBORN;
|
||||
break;
|
||||
else
|
||||
{
|
||||
// Give me one second.
|
||||
INT32 respawndelay = TICRATE;
|
||||
|
||||
// Non-platform gametypes
|
||||
if (gametyperules & GTR_RESPAWNDELAY)
|
||||
respawndelay = (cv_respawntime.value*TICRATE);
|
||||
|
||||
// You've been dead for enough time.
|
||||
// You may now respawn.
|
||||
if (player->deadtimer > respawndelay)
|
||||
player->playerstate = PST_REBORN;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -9488,7 +9659,7 @@ static void P_DeathThink(player_t *player)
|
|||
INT32 i, deadtimercheck = INT32_MAX;
|
||||
|
||||
// In a net/multiplayer game, and out of lives
|
||||
if (gametype == GT_COMPETITION)
|
||||
if (G_CompetitionGametype())
|
||||
{
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
|
@ -9569,12 +9740,12 @@ static void CV_CamRotate2_OnChange(void)
|
|||
}
|
||||
|
||||
static CV_PossibleValue_t CV_CamSpeed[] = {{0, "MIN"}, {1*FRACUNIT, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t rotation_cons_t[] = {{1, "MIN"}, {45, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t rotation_cons_t[] = {{1, "MIN"}, {25, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t CV_CamRotate[] = {{-720, "MIN"}, {720, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t multiplier_cons_t[] = {{0, "MIN"}, {3*FRACUNIT, "MAX"}, {0, NULL}};
|
||||
|
||||
consvar_t cv_cam_dist = {"cam_dist", "160", CV_FLOAT|CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_height = {"cam_height", "25", CV_FLOAT|CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_dist = {"cam_curdist", "160", CV_FLOAT, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_height = {"cam_curheight", "25", CV_FLOAT, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_still = {"cam_still", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_speed = {"cam_speed", "0.3", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_rotate = {"cam_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
@ -9582,8 +9753,8 @@ consvar_t cv_cam_rotspeed = {"cam_rotspeed", "10", CV_SAVE, rotation_cons_t, NUL
|
|||
consvar_t cv_cam_turnmultiplier = {"cam_turnmultiplier", "1.0", CV_FLOAT|CV_SAVE, multiplier_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_orbit = {"cam_orbit", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam_adjust = {"cam_adjust", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_dist = {"cam2_dist", "160", CV_FLOAT|CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_height = {"cam2_height", "25", CV_FLOAT|CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_dist = {"cam2_curdist", "160", CV_FLOAT, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_height = {"cam2_curheight", "25", CV_FLOAT, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_still = {"cam2_still", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_speed = {"cam2_speed", "0.3", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_rotate = {"cam2_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate2_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
@ -9592,6 +9763,42 @@ consvar_t cv_cam2_turnmultiplier = {"cam2_turnmultiplier", "1.0", CV_FLOAT|CV_SA
|
|||
consvar_t cv_cam2_orbit = {"cam2_orbit", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_cam2_adjust = {"cam2_adjust", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// [standard vs simple][p1 or p2]
|
||||
consvar_t cv_cam_savedist[2][2] = {
|
||||
{ // standard
|
||||
{"cam_dist", "160", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCamDist, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"cam2_dist", "160", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCam2Dist, 0, NULL, NULL, 0, 0, NULL}
|
||||
},
|
||||
{ // simple
|
||||
{"cam_simpledist", "224", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCamDist, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"cam2_simpledist", "224", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCam2Dist, 0, NULL, NULL, 0, 0, NULL}
|
||||
|
||||
}
|
||||
};
|
||||
consvar_t cv_cam_saveheight[2][2] = {
|
||||
{ // standard
|
||||
{"cam_height", "25", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCamDist, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"cam2_height", "25", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCam2Dist, 0, NULL, NULL, 0, 0, NULL}
|
||||
},
|
||||
{ // simple
|
||||
{"cam_simpleheight", "48", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCamDist, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"cam2_simpleheight", "48", CV_FLOAT|CV_SAVE|CV_CALL, NULL, CV_UpdateCam2Dist, 0, NULL, NULL, 0, 0, NULL}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
void CV_UpdateCamDist(void)
|
||||
{
|
||||
CV_Set(&cv_cam_dist, va("%f", FIXED_TO_FLOAT(cv_cam_savedist[cv_useranalog[0].value][0].value)));
|
||||
CV_Set(&cv_cam_height, va("%f", FIXED_TO_FLOAT(cv_cam_saveheight[cv_useranalog[0].value][0].value)));
|
||||
}
|
||||
|
||||
void CV_UpdateCam2Dist(void)
|
||||
{
|
||||
CV_Set(&cv_cam2_dist, va("%f", FIXED_TO_FLOAT(cv_cam_savedist[cv_useranalog[1].value][1].value)));
|
||||
CV_Set(&cv_cam2_height, va("%f", FIXED_TO_FLOAT(cv_cam_saveheight[cv_useranalog[1].value][1].value)));
|
||||
}
|
||||
|
||||
fixed_t t_cam_dist = -42;
|
||||
fixed_t t_cam_height = -42;
|
||||
fixed_t t_cam_rotate = -42;
|
||||
|
@ -9625,8 +9832,14 @@ void P_ResetCamera(player_t *player, camera_t *thiscam)
|
|||
thiscam->y = y;
|
||||
thiscam->z = z;
|
||||
|
||||
if (!(thiscam == &camera && (cv_cam_still.value || cv_analog.value))
|
||||
&& !(thiscam == &camera2 && (cv_cam2_still.value || cv_analog2.value)))
|
||||
if ((thiscam == &camera && G_ControlStyle(1) == CS_SIMPLE)
|
||||
|| (thiscam == &camera2 && G_ControlStyle(2) == CS_SIMPLE))
|
||||
{
|
||||
thiscam->angle = (thiscam == &camera) ? localangle : localangle2;
|
||||
thiscam->aiming = (thiscam == &camera) ? localaiming : localaiming2;
|
||||
}
|
||||
else if (!(thiscam == &camera && (cv_cam_still.value || cv_analog[0].value))
|
||||
&& !(thiscam == &camera2 && (cv_cam2_still.value || cv_analog[1].value)))
|
||||
{
|
||||
thiscam->angle = player->mo->angle;
|
||||
thiscam->aiming = 0;
|
||||
|
@ -9651,6 +9864,9 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
subsector_t *newsubsec;
|
||||
fixed_t f1, f2;
|
||||
|
||||
static fixed_t camsideshift[2] = {0, 0};
|
||||
fixed_t shiftx = 0, shifty = 0;
|
||||
|
||||
// We probably shouldn't move the camera if there is no player or player mobj somehow
|
||||
if (!player || !player->mo)
|
||||
return true;
|
||||
|
@ -9741,7 +9957,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
}
|
||||
else
|
||||
{
|
||||
focusangle = mo->angle;
|
||||
focusangle = player->cmd.angleturn << 16;
|
||||
focusaiming = player->aiming;
|
||||
}
|
||||
|
||||
|
@ -9781,7 +9997,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
camheight = FixedMul(camheight, player->camerascale);
|
||||
|
||||
#ifdef REDSANALOG
|
||||
if (P_AnalogMove(player) && (player->cmd.buttons & (BT_CAMLEFT|BT_CAMRIGHT)) == (BT_CAMLEFT|BT_CAMRIGHT)) {
|
||||
if (P_ControlStyle(player) == CS_LMAOGALOG && (player->cmd.buttons & (BT_CAMLEFT|BT_CAMRIGHT)) == (BT_CAMLEFT|BT_CAMRIGHT)) {
|
||||
camstill = true;
|
||||
|
||||
if (camspeed < 4*FRACUNIT/5)
|
||||
|
@ -9811,7 +10027,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
angle = R_PointToAngle2(mo->x, mo->y, mo->target->x, mo->target->y);
|
||||
}
|
||||
}
|
||||
else if (P_AnalogMove(player) && !sign) // Analog
|
||||
else if (P_ControlStyle(player) == CS_LMAOGALOG && !sign) // Analog
|
||||
angle = R_PointToAngle2(thiscam->x, thiscam->y, mo->x, mo->y);
|
||||
else if (demoplayback)
|
||||
{
|
||||
|
@ -9828,14 +10044,14 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
else
|
||||
angle = focusangle + FixedAngle(camrotate*FRACUNIT);
|
||||
|
||||
if (!resetcalled && (cv_analog.value || demoplayback) && ((thiscam == &camera && t_cam_rotate != -42) || (thiscam == &camera2
|
||||
if (!resetcalled && (cv_analog[0].value || demoplayback) && ((thiscam == &camera && t_cam_rotate != -42) || (thiscam == &camera2
|
||||
&& t_cam2_rotate != -42)))
|
||||
{
|
||||
angle = FixedAngle(camrotate*FRACUNIT);
|
||||
thiscam->angle = angle;
|
||||
}
|
||||
|
||||
if ((((thiscam == &camera) && cv_analog.value) || ((thiscam != &camera) && cv_analog2.value) || demoplayback) && !sign && !objectplacing && !(twodlevel || (mo->flags2 & MF2_TWOD)) && (player->powers[pw_carry] != CR_NIGHTSMODE) && displayplayer == consoleplayer)
|
||||
if ((((thiscam == &camera) && cv_analog[0].value) || ((thiscam != &camera) && cv_analog[1].value) || demoplayback) && !sign && !objectplacing && !(twodlevel || (mo->flags2 & MF2_TWOD)) && (player->powers[pw_carry] != CR_NIGHTSMODE) && displayplayer == consoleplayer)
|
||||
{
|
||||
#ifdef REDSANALOG
|
||||
if ((player->cmd.buttons & (BT_CAMLEFT|BT_CAMRIGHT)) == (BT_CAMLEFT|BT_CAMRIGHT)); else
|
||||
|
@ -9856,6 +10072,29 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
}
|
||||
}
|
||||
|
||||
if (G_ControlStyle((thiscam == &camera) ? 1 : 2) == CS_SIMPLE && !sign)
|
||||
{
|
||||
// Shift the camera slightly to the sides depending on the player facing direction
|
||||
UINT8 forplayer = (thiscam == &camera) ? 0 : 1;
|
||||
fixed_t shift = FixedMul(FINESINE((player->mo->angle - angle) >> ANGLETOFINESHIFT), cv_cam_shiftfacing[forplayer].value);
|
||||
|
||||
if (player->powers[pw_carry] == CR_NIGHTSMODE)
|
||||
{
|
||||
fixed_t cos = FINECOSINE((angle_t) (player->flyangle * ANG1)>>ANGLETOFINESHIFT);
|
||||
shift = FixedMul(shift, min(FRACUNIT, player->speed*abs(cos)/6000));
|
||||
shift += FixedMul(camsideshift[forplayer] - shift, FRACUNIT-(camspeed>>2));
|
||||
}
|
||||
else if (ticcmd_centerviewdown[(thiscam == &camera) ? 0 : 1])
|
||||
shift = FixedMul(camsideshift[forplayer], FRACUNIT-camspeed);
|
||||
else
|
||||
shift += FixedMul(camsideshift[forplayer] - shift, FRACUNIT-(camspeed>>3));
|
||||
camsideshift[forplayer] = shift;
|
||||
|
||||
shift = FixedMul(shift, camdist);
|
||||
shiftx = -FixedMul(FINESINE(angle>>ANGLETOFINESHIFT), shift);
|
||||
shifty = FixedMul(FINECOSINE(angle>>ANGLETOFINESHIFT), shift);
|
||||
}
|
||||
|
||||
// sets ideal cam pos
|
||||
if (twodlevel || (mo->flags2 & MF2_TWOD))
|
||||
dist = 480<<FRACBITS;
|
||||
|
@ -9878,7 +10117,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
camheight = mo->scale << 7;
|
||||
camspeed = FRACUNIT/12;
|
||||
}
|
||||
else if (P_AnalogMove(player)) // x1.2 dist for analog
|
||||
else if (P_ControlStyle(player) == CS_LMAOGALOG) // x1.2 dist for analog
|
||||
{
|
||||
dist = FixedMul(dist, 6*FRACUNIT/5);
|
||||
camheight = FixedMul(camheight, 6*FRACUNIT/5);
|
||||
|
@ -10202,8 +10441,8 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
}
|
||||
else
|
||||
{
|
||||
viewpointx = mo->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
|
||||
viewpointy = mo->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
|
||||
viewpointx = mo->x + shiftx + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
|
||||
viewpointy = mo->y + shifty + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
|
||||
}
|
||||
|
||||
if (!camstill && !resetcalled && !paused)
|
||||
|
@ -10244,6 +10483,9 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
|||
}
|
||||
else
|
||||
thiscam->momz = FixedMul(z - thiscam->z, camspeed);
|
||||
|
||||
thiscam->momx += FixedMul(shiftx, camspeed);
|
||||
thiscam->momy += FixedMul(shifty, camspeed);
|
||||
}
|
||||
|
||||
// compute aming to look the viewed point
|
||||
|
@ -10791,7 +11033,7 @@ static void P_MinecartThink(player_t *player)
|
|||
else if (angdiff > ANGLE_180 && angdiff < InvAngle(MINECARTCONEMAX))
|
||||
player->mo->angle = minecart->angle - MINECARTCONEMAX;
|
||||
|
||||
if (angdiff + minecart->angle != player->mo->angle && (!demoplayback || P_AnalogMove(player)))
|
||||
if (angdiff + minecart->angle != player->mo->angle && (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG))
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle;
|
||||
|
@ -10870,7 +11112,7 @@ static void P_MinecartThink(player_t *player)
|
|||
else
|
||||
minecart->angle = targetangle + ANGLE_180;
|
||||
angdiff = (minecart->angle - prevangle);
|
||||
if (angdiff && (!demoplayback || P_AnalogMove(player))) // maintain relative angle on turns
|
||||
if (angdiff && (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)) // maintain relative angle on turns
|
||||
{
|
||||
player->mo->angle += angdiff;
|
||||
if (player == &players[consoleplayer])
|
||||
|
@ -11244,7 +11486,10 @@ static void P_DoMetalJetFume(player_t *player, mobj_t *fume)
|
|||
if (panim == PA_WALK)
|
||||
{
|
||||
if (stat != fume->info->spawnstate)
|
||||
{
|
||||
fume->threshold = 0;
|
||||
P_SetMobjState(fume, fume->info->spawnstate);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -11275,6 +11520,12 @@ static void P_DoMetalJetFume(player_t *player, mobj_t *fume)
|
|||
if (underwater)
|
||||
{
|
||||
fume->frame = (fume->frame & FF_FRAMEMASK) | FF_ANIMATE | (P_RandomRange(0, 9) * FF_TRANS10);
|
||||
fume->threshold = 1;
|
||||
}
|
||||
else if (fume->threshold)
|
||||
{
|
||||
fume->frame = (fume->frame & FF_FRAMEMASK) | fume->state->frame;
|
||||
fume->threshold = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -11321,7 +11572,12 @@ void P_PlayerThink(player_t *player)
|
|||
player->playerstate = PST_REBORN;
|
||||
}
|
||||
if (player->playerstate == PST_REBORN)
|
||||
{
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef SEENAMES
|
||||
|
@ -11422,7 +11678,12 @@ void P_PlayerThink(player_t *player)
|
|||
player->lives = 0;
|
||||
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -11534,14 +11795,16 @@ void P_PlayerThink(player_t *player)
|
|||
#else
|
||||
if (player->spectator &&
|
||||
#endif
|
||||
gametype == GT_COOP && (netgame || multiplayer) && cv_coopstarposts.value == 2)
|
||||
G_GametypeUsesCoopStarposts() && (netgame || multiplayer) && cv_coopstarposts.value == 2)
|
||||
P_ConsiderAllGone();
|
||||
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
player->mo->flags2 &= ~MF2_SHADOW;
|
||||
P_DeathThink(player);
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -11582,7 +11845,12 @@ void P_PlayerThink(player_t *player)
|
|||
if (player->spectator && cmd->buttons & BT_ATTACK && !player->powers[pw_flashing] && G_GametypeHasSpectators())
|
||||
{
|
||||
if (P_SpectatorJoinGame(player))
|
||||
{
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
return; // player->mo was removed.
|
||||
}
|
||||
}
|
||||
|
||||
// Even if not NiGHTS, pull in nearby objects when walking around as John Q. Elliot.
|
||||
|
@ -11636,7 +11904,7 @@ void P_PlayerThink(player_t *player)
|
|||
player->mo->reactiontime--;
|
||||
else if (player->powers[pw_carry] == CR_MINECART)
|
||||
{
|
||||
if (!P_AnalogMove(player))
|
||||
if (P_ControlStyle(player) != CS_LMAOGALOG)
|
||||
player->mo->angle = (cmd->angleturn << 16 /* not FRACBITS */);
|
||||
|
||||
ticruned++;
|
||||
|
@ -11649,7 +11917,7 @@ void P_PlayerThink(player_t *player)
|
|||
{
|
||||
if (player->powers[pw_carry] == CR_ROPEHANG)
|
||||
{
|
||||
if (!P_AnalogMove(player))
|
||||
if (P_ControlStyle(player) != CS_LMAOGALOG)
|
||||
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
|
||||
|
||||
ticruned++;
|
||||
|
@ -11684,7 +11952,12 @@ void P_PlayerThink(player_t *player)
|
|||
}
|
||||
|
||||
if (!player->mo)
|
||||
{
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
return; // P_MovePlayer removed player->mo.
|
||||
}
|
||||
|
||||
// deez New User eXperiences.
|
||||
{
|
||||
|
@ -11697,7 +11970,7 @@ void P_PlayerThink(player_t *player)
|
|||
;
|
||||
else if (!(player->pflags & PF_DIRECTIONCHAR)
|
||||
|| (player->climbing) // stuff where the direction is forced at all times
|
||||
|| (P_AnalogMove(player) || twodlevel || player->mo->flags2 & MF2_TWOD) // keep things synchronised up there, since the camera IS seperate from player motion when that happens
|
||||
|| (twodlevel || player->mo->flags2 & MF2_TWOD) // keep things synchronised up there, since the camera IS seperate from player motion when that happens
|
||||
|| G_RingSlingerGametype()) // no firing rings in directions your player isn't aiming
|
||||
player->drawangle = player->mo->angle;
|
||||
else if (P_PlayerInPain(player))
|
||||
|
@ -11728,7 +12001,7 @@ void P_PlayerThink(player_t *player)
|
|||
case CR_ROLLOUT:
|
||||
if (cmd->forwardmove || cmd->sidemove) // only when you're pressing movement keys
|
||||
{ // inverse direction!
|
||||
diff = ((player->mo->angle + R_PointToAngle2(0, 0, -cmd->forwardmove<<FRACBITS, cmd->sidemove<<FRACBITS)) - player->drawangle);
|
||||
diff = (((player->cmd.angleturn<<16) + R_PointToAngle2(0, 0, -cmd->forwardmove<<FRACBITS, cmd->sidemove<<FRACBITS)) - player->drawangle);
|
||||
factor = 4;
|
||||
}
|
||||
break;
|
||||
|
@ -11785,7 +12058,7 @@ void P_PlayerThink(player_t *player)
|
|||
}
|
||||
else if (cmd->forwardmove || cmd->sidemove) // only when you're pressing movement keys
|
||||
{
|
||||
diff = ((player->mo->angle + R_PointToAngle2(0, 0, cmd->forwardmove<<FRACBITS, -cmd->sidemove<<FRACBITS)) - player->drawangle);
|
||||
diff = ((player->mo->angle + ((player->pflags & PF_ANALOGMODE) ? 0 : R_PointToAngle2(0, 0, cmd->forwardmove<<FRACBITS, -cmd->sidemove<<FRACBITS))) - player->drawangle);
|
||||
factor = 4;
|
||||
}
|
||||
else if (player->rmomx || player->rmomy)
|
||||
|
@ -12116,6 +12389,11 @@ void P_PlayerThink(player_t *player)
|
|||
dashmode = 0;
|
||||
}
|
||||
#undef dashmode
|
||||
|
||||
#ifdef HAVE_BLUA
|
||||
LUAh_PlayerThink(player);
|
||||
#endif
|
||||
|
||||
/*
|
||||
// Colormap verification
|
||||
{
|
||||
|
@ -12398,7 +12676,7 @@ void P_PlayerAfterThink(player_t *player)
|
|||
{
|
||||
player->mo->angle = tails->angle;
|
||||
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle;
|
||||
|
@ -12421,7 +12699,7 @@ void P_PlayerAfterThink(player_t *player)
|
|||
P_SetTarget(&player->mo->tracer, NULL);
|
||||
|
||||
if (player-players == consoleplayer && botingame)
|
||||
CV_SetValue(&cv_analog2, (player->powers[pw_carry] != CR_PLAYER));
|
||||
CV_SetValue(&cv_analog[1], (player->powers[pw_carry] != CR_PLAYER));
|
||||
break;
|
||||
}
|
||||
case CR_GENERIC: // being carried by some generic item
|
||||
|
@ -12487,7 +12765,7 @@ void P_PlayerAfterThink(player_t *player)
|
|||
macecenter->angle += cmd->sidemove<<ANGLETOFINESHIFT;
|
||||
player->mo->angle += cmd->sidemove<<ANGLETOFINESHIFT; // 2048 --> ANGLE_MAX
|
||||
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
if (!demoplayback || P_ControlStyle(player) == CS_LMAOGALOG)
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle; // Adjust the local control angle.
|
||||
|
|
36
src/r_data.c
36
src/r_data.c
|
@ -324,8 +324,8 @@ UINT8 ASTBlendPixel_8bpp(UINT8 background, UINT8 foreground, int style, UINT8 al
|
|||
else if (style != AST_TRANSLUCENT)
|
||||
{
|
||||
RGBA_t texel;
|
||||
RGBA_t bg = V_GetColor(background);
|
||||
RGBA_t fg = V_GetColor(foreground);
|
||||
RGBA_t bg = V_GetMasterColor(background);
|
||||
RGBA_t fg = V_GetMasterColor(foreground);
|
||||
texel.rgba = ASTBlendPixel(bg, fg, style, alpha);
|
||||
return NearestColor(texel.s.red, texel.s.green, texel.s.blue);
|
||||
}
|
||||
|
@ -571,7 +571,7 @@ static UINT8 *R_GenerateTexture(size_t texnum)
|
|||
|
||||
#ifndef NO_PNG_LUMPS
|
||||
if (R_IsLumpPNG((UINT8 *)realpatch, lumplength))
|
||||
realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL, false);
|
||||
realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL);
|
||||
else
|
||||
#endif
|
||||
#ifdef WALLFLATS
|
||||
|
@ -1664,7 +1664,7 @@ static void R_CreateFadeColormaps(void)
|
|||
#define GETCOLOR \
|
||||
px = colormaps[i%256]; \
|
||||
fade = (i/256) * (256 / FADECOLORMAPROWS); \
|
||||
rgba = V_GetColor(px);
|
||||
rgba = V_GetMasterColor(px);
|
||||
|
||||
// to black
|
||||
makeblack:
|
||||
|
@ -2095,7 +2095,6 @@ lighttable_t *R_CreateLightTable(extracolormap_t *extra_colormap)
|
|||
/////////////////////
|
||||
// This code creates the colormap array used by software renderer
|
||||
/////////////////////
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
double r, g, b, cbrightness;
|
||||
int p;
|
||||
|
@ -2711,14 +2710,29 @@ void R_PrecacheLevel(void)
|
|||
for (j = 0; j < sprites[i].numframes; j++)
|
||||
{
|
||||
sf = &sprites[i].spriteframes[j];
|
||||
for (k = 0; k < 8; k++)
|
||||
#define cacheang(a) {\
|
||||
lump = sf->lumppat[a];\
|
||||
if (devparm)\
|
||||
spritememory += W_LumpLength(lump);\
|
||||
W_CachePatchNum(lump, PU_PATCH);\
|
||||
}
|
||||
// see R_InitSprites for more about lumppat,lumpid
|
||||
switch (sf->rotate)
|
||||
{
|
||||
// see R_InitSprites for more about lumppat,lumpid
|
||||
lump = sf->lumppat[k];
|
||||
if (devparm)
|
||||
spritememory += W_LumpLength(lump);
|
||||
W_CachePatchNum(lump, PU_CACHE);
|
||||
case SRF_SINGLE:
|
||||
cacheang(0);
|
||||
break;
|
||||
case SRF_2D:
|
||||
cacheang(2);
|
||||
cacheang(6);
|
||||
break;
|
||||
default:
|
||||
k = (sf->rotate & SRF_3DGE ? 16 : 8);
|
||||
while (k--)
|
||||
cacheang(k);
|
||||
break;
|
||||
}
|
||||
#undef cacheang
|
||||
}
|
||||
}
|
||||
free(spritepresent);
|
||||
|
|
49
src/r_defs.h
49
src/r_defs.h
|
@ -83,7 +83,7 @@ typedef struct extracolormap_s
|
|||
*/
|
||||
typedef struct
|
||||
{
|
||||
fixed_t x, y, z;
|
||||
fixed_t x, y;
|
||||
} vertex_t;
|
||||
|
||||
// Forward of linedefs, for sectors.
|
||||
|
@ -727,29 +727,46 @@ typedef struct
|
|||
#ifdef ROTSPRITE
|
||||
typedef struct
|
||||
{
|
||||
patch_t *patch[8][ROTANGLES];
|
||||
boolean cached[8];
|
||||
#ifdef HWRENDER
|
||||
aatree_t *hardware_patch[8];
|
||||
#endif
|
||||
patch_t *patch[16][ROTANGLES];
|
||||
UINT16 cached;
|
||||
} rotsprite_t;
|
||||
#endif
|
||||
#endif/*ROTSPRITE*/
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SRF_SINGLE = 0, // 0-angle for all rotations
|
||||
SRF_3D = 1, // Angles 1-8
|
||||
SRF_LEFT = 2, // Left side uses single patch
|
||||
SRF_RIGHT = 4, // Right side uses single patch
|
||||
SRF_2D = SRF_LEFT|SRF_RIGHT, // 6
|
||||
SRF_3DGE = 2, // 3DGE, ZDoom and Doom Legacy all have 16-angle support. Why not us?
|
||||
SRF_3DMASK = SRF_3D|SRF_3DGE, // 3
|
||||
SRF_LEFT = 4, // Left side uses single patch
|
||||
SRF_RIGHT = 8, // Right side uses single patch
|
||||
SRF_2D = SRF_LEFT|SRF_RIGHT, // 12
|
||||
SRF_NONE = 0xff // Initial value
|
||||
} spriterotateflags_t; // SRF's up!
|
||||
|
||||
// Same as a patch_t, except just the header
|
||||
// and the wadnum/lumpnum combination that points
|
||||
// to wherever the patch is in memory.
|
||||
struct patchinfo_s
|
||||
{
|
||||
INT16 width; // bounding box size
|
||||
INT16 height;
|
||||
INT16 leftoffset; // pixels to the left of origin
|
||||
INT16 topoffset; // pixels below the origin
|
||||
|
||||
UINT16 wadnum; // the software patch lump num for when the patch
|
||||
UINT16 lumpnum; // was flushed, and we need to re-create it
|
||||
|
||||
// next patchinfo_t in memory
|
||||
struct patchinfo_s *next;
|
||||
};
|
||||
typedef struct patchinfo_s patchinfo_t;
|
||||
|
||||
//
|
||||
// Sprites are patches with a special naming convention so they can be
|
||||
// recognized by R_InitSprites.
|
||||
// The base name is NNNNFx or NNNNFxFx, with x indicating the rotation,
|
||||
// x = 0, 1-8, L/R
|
||||
// x = 0, 1-8, 9+A-G, L/R
|
||||
// The sprite and frame specified by a thing_t is range checked at run time.
|
||||
// A sprite is a patch_t that is assumed to represent a three dimensional
|
||||
// object and may have multiple rotations predrawn.
|
||||
|
@ -766,12 +783,12 @@ typedef struct
|
|||
// name eight times.
|
||||
UINT8 rotate; // see spriterotateflags_t above
|
||||
|
||||
// Lump to use for view angles 0-7.
|
||||
lumpnum_t lumppat[8]; // lump number 16 : 16 wad : lump
|
||||
size_t lumpid[8]; // id in the spriteoffset, spritewidth, etc. tables
|
||||
// Lump to use for view angles 0-7/15.
|
||||
lumpnum_t lumppat[16]; // lump number 16 : 16 wad : lump
|
||||
size_t lumpid[16]; // id in the spriteoffset, spritewidth, etc. tables
|
||||
|
||||
// Flip bits (1 = flip) to use for view angles 0-7.
|
||||
UINT8 flip;
|
||||
// Flip bits (1 = flip) to use for view angles 0-7/15.
|
||||
UINT16 flip;
|
||||
|
||||
#ifdef ROTSPRITE
|
||||
rotsprite_t rotsprite;
|
||||
|
|
56
src/r_main.c
56
src/r_main.c
|
@ -19,6 +19,7 @@
|
|||
#include "r_local.h"
|
||||
#include "r_splats.h" // faB(21jan): testing
|
||||
#include "r_sky.h"
|
||||
#include "hu_stuff.h"
|
||||
#include "st_stuff.h"
|
||||
#include "p_local.h"
|
||||
#include "keys.h"
|
||||
|
@ -28,6 +29,7 @@
|
|||
#include "d_main.h"
|
||||
#include "v_video.h"
|
||||
#include "p_spec.h" // skyboxmo
|
||||
#include "p_setup.h"
|
||||
#include "z_zone.h"
|
||||
#include "m_random.h" // quake camera shake
|
||||
#include "r_portal.h"
|
||||
|
@ -185,20 +187,20 @@ void SplitScreen_OnChange(void)
|
|||
|
||||
static void ChaseCam_OnChange(void)
|
||||
{
|
||||
if (!cv_chasecam.value || !cv_useranalog.value)
|
||||
CV_SetValue(&cv_analog, 0);
|
||||
if (!cv_chasecam.value || !cv_useranalog[0].value)
|
||||
CV_SetValue(&cv_analog[0], 0);
|
||||
else
|
||||
CV_SetValue(&cv_analog, 1);
|
||||
CV_SetValue(&cv_analog[0], 1);
|
||||
}
|
||||
|
||||
static void ChaseCam2_OnChange(void)
|
||||
{
|
||||
if (botingame)
|
||||
return;
|
||||
if (!cv_chasecam2.value || !cv_useranalog2.value)
|
||||
CV_SetValue(&cv_analog2, 0);
|
||||
if (!cv_chasecam2.value || !cv_useranalog[1].value)
|
||||
CV_SetValue(&cv_analog[1], 0);
|
||||
else
|
||||
CV_SetValue(&cv_analog2, 1);
|
||||
CV_SetValue(&cv_analog[1], 1);
|
||||
}
|
||||
|
||||
static void FlipCam_OnChange(void)
|
||||
|
@ -696,6 +698,7 @@ subsector_t *R_IsPointInSubsector(fixed_t x, fixed_t y)
|
|||
INT32 side, i;
|
||||
size_t nodenum;
|
||||
subsector_t *ret;
|
||||
seg_t *seg;
|
||||
|
||||
// single subsector is a special case
|
||||
if (numnodes == 0)
|
||||
|
@ -711,10 +714,15 @@ subsector_t *R_IsPointInSubsector(fixed_t x, fixed_t y)
|
|||
}
|
||||
|
||||
ret = &subsectors[nodenum & ~NF_SUBSECTOR];
|
||||
for (i = 0; i < ret->numlines; i++)
|
||||
//if (R_PointOnSegSide(x, y, &segs[ret->firstline + i])) -- breaks in ogl because polyvertex_t cast over vertex pointers
|
||||
if (P_PointOnLineSide(x, y, segs[ret->firstline + i].linedef) != segs[ret->firstline + i].side)
|
||||
for (i = 0, seg = &segs[ret->firstline]; i < ret->numlines; i++, seg++)
|
||||
{
|
||||
if (seg->glseg)
|
||||
continue;
|
||||
|
||||
//if (R_PointOnSegSide(x, y, seg)) -- breaks in ogl because polyvertex_t cast over vertex pointers
|
||||
if (P_PointOnLineSide(x, y, seg->linedef) != seg->side)
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1154,6 +1162,26 @@ void R_RenderPlayerView(player_t *player)
|
|||
free(masks);
|
||||
}
|
||||
|
||||
// Lactozilla: Renderer switching
|
||||
#ifdef HWRENDER
|
||||
void R_InitHardwareMode(void)
|
||||
{
|
||||
HWR_AddSessionCommands();
|
||||
HWR_Switch();
|
||||
HWR_LoadTextures(numtextures);
|
||||
if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction))
|
||||
HWR_SetupLevel();
|
||||
}
|
||||
#endif
|
||||
|
||||
void R_ReloadHUDGraphics(void)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "R_ReloadHUDGraphics()...\n");
|
||||
ST_LoadGraphics();
|
||||
HU_LoadGraphics();
|
||||
ST_ReloadSkinFaceGraphics();
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// ENGINE COMMANDS & VARS
|
||||
// =========================================================================
|
||||
|
@ -1206,6 +1234,16 @@ void R_RegisterEngineStuff(void)
|
|||
CV_RegisterVar(&cv_cam2_orbit);
|
||||
CV_RegisterVar(&cv_cam2_adjust);
|
||||
|
||||
CV_RegisterVar(&cv_cam_savedist[0][0]);
|
||||
CV_RegisterVar(&cv_cam_savedist[0][1]);
|
||||
CV_RegisterVar(&cv_cam_savedist[1][0]);
|
||||
CV_RegisterVar(&cv_cam_savedist[1][1]);
|
||||
|
||||
CV_RegisterVar(&cv_cam_saveheight[0][0]);
|
||||
CV_RegisterVar(&cv_cam_saveheight[0][1]);
|
||||
CV_RegisterVar(&cv_cam_saveheight[1][0]);
|
||||
CV_RegisterVar(&cv_cam_saveheight[1][1]);
|
||||
|
||||
CV_RegisterVar(&cv_showhud);
|
||||
CV_RegisterVar(&cv_translucenthud);
|
||||
|
||||
|
|
|
@ -89,6 +89,10 @@ extern consvar_t cv_tailspickup;
|
|||
|
||||
// Called by startup code.
|
||||
void R_Init(void);
|
||||
#ifdef HWRENDER
|
||||
void R_InitHardwareMode(void);
|
||||
#endif
|
||||
void R_ReloadHUDGraphics(void);
|
||||
|
||||
// just sets setsizeneeded true
|
||||
extern boolean setsizeneeded;
|
||||
|
|
126
src/r_patch.c
126
src/r_patch.c
|
@ -2,8 +2,8 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 2005-2009 by Andrey "entryway" Budko.
|
||||
// Copyright (C) 2018-2019 by Jaime "Lactozilla" Passos.
|
||||
// Copyright (C) 2019 by Sonic Team Junior.
|
||||
// Copyright (C) 2018-2020 by Jaime "Lactozilla" Passos.
|
||||
// Copyright (C) 2019-2020 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
|
@ -199,11 +199,15 @@ void R_PatchToFlat(patch_t *patch, UINT8 *flat)
|
|||
}
|
||||
|
||||
//
|
||||
// R_PatchToFlat_16bpp
|
||||
// R_PatchToMaskedFlat
|
||||
//
|
||||
// Convert a patch to a 16-bit flat.
|
||||
// Convert a patch to a masked flat.
|
||||
// Now, what is a "masked" flat anyway?
|
||||
// It means the flat uses two bytes to store image data.
|
||||
// The upper byte is used to store the transparent pixel,
|
||||
// and the lower byte stores a palette index.
|
||||
//
|
||||
void R_PatchToFlat_16bpp(patch_t *patch, UINT16 *raw, boolean flip)
|
||||
void R_PatchToMaskedFlat(patch_t *patch, UINT16 *raw, boolean flip)
|
||||
{
|
||||
fixed_t col, ofs;
|
||||
column_t *column;
|
||||
|
@ -248,6 +252,9 @@ patch_t *R_FlatToPatch(UINT8 *raw, UINT16 width, UINT16 height, UINT16 leftoffse
|
|||
UINT8 *colpointers, *startofspan;
|
||||
size_t size = 0;
|
||||
|
||||
if (!raw)
|
||||
return NULL;
|
||||
|
||||
// Write image size and offset
|
||||
WRITEINT16(imgptr, width);
|
||||
WRITEINT16(imgptr, height);
|
||||
|
@ -347,16 +354,18 @@ patch_t *R_FlatToPatch(UINT8 *raw, UINT16 width, UINT16 height, UINT16 leftoffse
|
|||
}
|
||||
|
||||
//
|
||||
// R_FlatToPatch_16bpp
|
||||
// R_MaskedFlatToPatch
|
||||
//
|
||||
// Convert a 16-bit flat to a patch.
|
||||
// Convert a masked flat to a patch.
|
||||
// Explanation of "masked" flats in R_PatchToMaskedFlat.
|
||||
//
|
||||
patch_t *R_FlatToPatch_16bpp(UINT16 *raw, UINT16 width, UINT16 height, size_t *size)
|
||||
patch_t *R_MaskedFlatToPatch(UINT16 *raw, UINT16 width, UINT16 height, UINT16 leftoffset, UINT16 topoffset, size_t *destsize)
|
||||
{
|
||||
UINT32 x, y;
|
||||
UINT8 *img;
|
||||
UINT8 *imgptr = imgbuf;
|
||||
UINT8 *colpointers, *startofspan;
|
||||
size_t size = 0;
|
||||
|
||||
if (!raw)
|
||||
return NULL;
|
||||
|
@ -364,9 +373,8 @@ patch_t *R_FlatToPatch_16bpp(UINT16 *raw, UINT16 width, UINT16 height, size_t *s
|
|||
// Write image size and offset
|
||||
WRITEINT16(imgptr, width);
|
||||
WRITEINT16(imgptr, height);
|
||||
// no offsets
|
||||
WRITEINT16(imgptr, 0);
|
||||
WRITEINT16(imgptr, 0);
|
||||
WRITEINT16(imgptr, leftoffset);
|
||||
WRITEINT16(imgptr, topoffset);
|
||||
|
||||
// Leave placeholder to column pointers
|
||||
colpointers = imgptr;
|
||||
|
@ -450,9 +458,12 @@ patch_t *R_FlatToPatch_16bpp(UINT16 *raw, UINT16 width, UINT16 height, size_t *s
|
|||
WRITEUINT8(imgptr, 0xFF);
|
||||
}
|
||||
|
||||
*size = imgptr-imgbuf;
|
||||
img = Z_Malloc(*size, PU_STATIC, NULL);
|
||||
memcpy(img, imgbuf, *size);
|
||||
size = imgptr-imgbuf;
|
||||
img = Z_Malloc(size, PU_STATIC, NULL);
|
||||
memcpy(img, imgbuf, size);
|
||||
|
||||
if (destsize != NULL)
|
||||
*destsize = size;
|
||||
return (patch_t *)img;
|
||||
}
|
||||
|
||||
|
@ -675,6 +686,41 @@ static UINT8 *PNG_RawConvert(const UINT8 *png, UINT16 *w, UINT16 *h, INT16 *topo
|
|||
return flat;
|
||||
}
|
||||
|
||||
// Convert a PNG with transparency to a raw image.
|
||||
static UINT16 *PNG_MaskedRawConvert(const UINT8 *png, UINT16 *w, UINT16 *h, INT16 *topoffset, INT16 *leftoffset, size_t size)
|
||||
{
|
||||
UINT16 *flat;
|
||||
png_uint_32 x, y;
|
||||
png_bytep *row_pointers = PNG_Read(png, w, h, topoffset, leftoffset, size);
|
||||
png_uint_32 width = *w, height = *h;
|
||||
size_t flatsize, i;
|
||||
|
||||
if (!row_pointers)
|
||||
I_Error("PNG_MaskedRawConvert: conversion failed");
|
||||
|
||||
// Convert the image to 16bpp
|
||||
flatsize = (width * height);
|
||||
flat = Z_Malloc(flatsize * sizeof(UINT16), PU_LEVEL, NULL);
|
||||
|
||||
// can't memset here
|
||||
for (i = 0; i < flatsize; i++)
|
||||
flat[i] = 0xFF00;
|
||||
|
||||
for (y = 0; y < height; y++)
|
||||
{
|
||||
png_bytep row = row_pointers[y];
|
||||
for (x = 0; x < width; x++)
|
||||
{
|
||||
png_bytep px = &(row[x * 4]);
|
||||
if ((UINT8)px[3])
|
||||
flat[((y * width) + x)] = NearestColor((UINT8)px[0], (UINT8)px[1], (UINT8)px[2]);
|
||||
}
|
||||
}
|
||||
free(row_pointers);
|
||||
|
||||
return flat;
|
||||
}
|
||||
|
||||
//
|
||||
// R_PNGToFlat
|
||||
//
|
||||
|
@ -690,16 +736,16 @@ UINT8 *R_PNGToFlat(UINT16 *width, UINT16 *height, UINT8 *png, size_t size)
|
|||
//
|
||||
// Convert a PNG to a patch.
|
||||
//
|
||||
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize, boolean transparency)
|
||||
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize)
|
||||
{
|
||||
UINT16 width, height;
|
||||
INT16 topoffset = 0, leftoffset = 0;
|
||||
UINT8 *raw = PNG_RawConvert(png, &width, &height, &topoffset, &leftoffset, size);
|
||||
UINT16 *raw = PNG_MaskedRawConvert(png, &width, &height, &topoffset, &leftoffset, size);
|
||||
|
||||
if (!raw)
|
||||
I_Error("R_PNGToPatch: conversion failed");
|
||||
|
||||
return R_FlatToPatch(raw, width, height, leftoffset, topoffset, destsize, transparency);
|
||||
return R_MaskedFlatToPatch(raw, width, height, leftoffset, topoffset, destsize);
|
||||
}
|
||||
|
||||
//
|
||||
|
@ -1150,7 +1196,7 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
INT32 angle;
|
||||
patch_t *patch;
|
||||
patch_t *newpatch;
|
||||
UINT16 *rawdst;
|
||||
UINT16 *rawsrc, *rawdst;
|
||||
size_t size;
|
||||
INT32 bflip = (flip != 0x00);
|
||||
|
||||
|
@ -1159,7 +1205,7 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
#define ROTSPRITE_XCENTER (newwidth / 2)
|
||||
#define ROTSPRITE_YCENTER (newheight / 2)
|
||||
|
||||
if (!sprframe->rotsprite.cached[rot])
|
||||
if (!(sprframe->rotsprite.cached & (1<<rot)))
|
||||
{
|
||||
INT32 dx, dy;
|
||||
INT32 px, py;
|
||||
|
@ -1196,6 +1242,17 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
leftoffset = width - leftoffset;
|
||||
}
|
||||
|
||||
// Draw the sprite to a temporary buffer.
|
||||
size = (width*height);
|
||||
rawsrc = Z_Malloc(size * sizeof(UINT16), PU_STATIC, NULL);
|
||||
|
||||
// can't memset here
|
||||
for (i = 0; i < size; i++)
|
||||
rawsrc[i] = 0xFF00;
|
||||
|
||||
R_PatchToMaskedFlat(patch, rawsrc, bflip);
|
||||
|
||||
// Don't cache angle = 0
|
||||
for (angle = 1; angle < ROTANGLES; angle++)
|
||||
{
|
||||
INT32 newwidth, newheight;
|
||||
|
@ -1287,7 +1344,7 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
}
|
||||
|
||||
// make patch
|
||||
newpatch = R_FlatToPatch_16bpp(rawdst, newwidth, newheight, &size);
|
||||
newpatch = R_MaskedFlatToPatch(rawdst, newwidth, newheight, 0, 0, &size);
|
||||
{
|
||||
newpatch->leftoffset = (newpatch->width / 2) + (leftoffset - px);
|
||||
newpatch->topoffset = (newpatch->height / 2) + (patch->topoffset - py);
|
||||
|
@ -1303,9 +1360,11 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
GLPatch_t *grPatch = HWR_GetCachedGLRotSprite(sprframe->rotsprite.hardware_patch[rot], angle, newpatch);
|
||||
HWR_MakePatch(newpatch, grPatch, grPatch->mipmap, false);
|
||||
GLPatch_t *grPatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
grPatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
grPatch->rawpatch = newpatch;
|
||||
sprframe->rotsprite.patch[rot][angle] = (patch_t *)grPatch;
|
||||
HWR_MakePatch(newpatch, grPatch, grPatch->mipmap, false);
|
||||
}
|
||||
else
|
||||
#endif // HWRENDER
|
||||
|
@ -1316,7 +1375,7 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
|
|||
}
|
||||
|
||||
// This rotation is cached now
|
||||
sprframe->rotsprite.cached[rot] = true;
|
||||
sprframe->rotsprite.cached |= (1<<rot);
|
||||
|
||||
// free image data
|
||||
Z_Free(patch);
|
||||
|
@ -1340,9 +1399,9 @@ void R_FreeSingleRotSprite(spritedef_t *spritedef)
|
|||
for (frame = 0; frame < spritedef->numframes; frame++)
|
||||
{
|
||||
spriteframe_t *sprframe = &spritedef->spriteframes[frame];
|
||||
for (rot = 0; rot < 8; rot++)
|
||||
for (rot = 0; rot < 16; rot++)
|
||||
{
|
||||
if (sprframe->rotsprite.cached[rot])
|
||||
if (sprframe->rotsprite.cached & (1<<rot))
|
||||
{
|
||||
for (ang = 0; ang < ROTANGLES; ang++)
|
||||
{
|
||||
|
@ -1373,7 +1432,7 @@ void R_FreeSingleRotSprite(spritedef_t *spritedef)
|
|||
Z_Free(rotsprite);
|
||||
}
|
||||
}
|
||||
sprframe->rotsprite.cached[rot] = false;
|
||||
sprframe->rotsprite.cached &= ~(1<<rot);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1396,4 +1455,19 @@ void R_FreeSkinRotSprite(size_t skinnum)
|
|||
skinsprites++;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// R_FreeAllRotSprite
|
||||
//
|
||||
// Free ALL sprite rotation data from memory.
|
||||
//
|
||||
void R_FreeAllRotSprite(void)
|
||||
{
|
||||
INT32 i;
|
||||
size_t s;
|
||||
for (s = 0; s < numsprites; s++)
|
||||
R_FreeSingleRotSprite(&sprites[s]);
|
||||
for (i = 0; i < numskins; ++i)
|
||||
R_FreeSkinRotSprite(i);
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -41,9 +41,9 @@ typedef struct
|
|||
boolean R_CheckIfPatch(lumpnum_t lump);
|
||||
void R_TextureToFlat(size_t tex, UINT8 *flat);
|
||||
void R_PatchToFlat(patch_t *patch, UINT8 *flat);
|
||||
void R_PatchToFlat_16bpp(patch_t *patch, UINT16 *raw, boolean flip);
|
||||
void R_PatchToMaskedFlat(patch_t *patch, UINT16 *raw, boolean flip);
|
||||
patch_t *R_FlatToPatch(UINT8 *raw, UINT16 width, UINT16 height, UINT16 leftoffset, UINT16 topoffset, size_t *destsize, boolean transparency);
|
||||
patch_t *R_FlatToPatch_16bpp(UINT16 *raw, UINT16 width, UINT16 height, size_t *size);
|
||||
patch_t *R_MaskedFlatToPatch(UINT16 *raw, UINT16 width, UINT16 height, UINT16 leftoffset, UINT16 topoffset, size_t *destsize);
|
||||
|
||||
// Portable Network Graphics
|
||||
boolean R_IsLumpPNG(const UINT8 *d, size_t s);
|
||||
|
@ -51,7 +51,7 @@ boolean R_IsLumpPNG(const UINT8 *d, size_t s);
|
|||
|
||||
#ifndef NO_PNG_LUMPS
|
||||
UINT8 *R_PNGToFlat(UINT16 *width, UINT16 *height, UINT8 *png, size_t size);
|
||||
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize, boolean transparency);
|
||||
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize);
|
||||
boolean R_PNGDimensions(UINT8 *png, INT16 *width, INT16 *height, size_t size);
|
||||
#endif
|
||||
|
||||
|
@ -68,6 +68,7 @@ void R_FreeSingleRotSprite(spritedef_t *spritedef);
|
|||
void R_FreeSkinRotSprite(size_t skinnum);
|
||||
extern fixed_t rollcosang[ROTANGLES];
|
||||
extern fixed_t rollsinang[ROTANGLES];
|
||||
void R_FreeAllRotSprite(void);
|
||||
#endif
|
||||
|
||||
#endif // __R_PATCH__
|
||||
|
|
|
@ -165,7 +165,7 @@ static void R_DrawWallSplats(void)
|
|||
mfloorclip = floorclip;
|
||||
mceilingclip = ceilingclip;
|
||||
|
||||
patch = W_CachePatchNum(splat->patch, PU_CACHE);
|
||||
patch = W_CachePatchNum(splat->patch, PU_PATCH);
|
||||
|
||||
dc_texturemid = splat->top + (SHORT(patch->height)<<(FRACBITS-1)) - viewz;
|
||||
if (splat->yoffset)
|
||||
|
@ -309,9 +309,6 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
|||
// OPTIMIZE: get rid of LIGHTSEGSHIFT globally
|
||||
curline = ds->curline;
|
||||
|
||||
if (curline->glseg)
|
||||
return;
|
||||
|
||||
frontsector = curline->frontsector;
|
||||
backsector = curline->backsector;
|
||||
texnum = R_GetTextureNum(curline->sidedef->midtexture);
|
||||
|
|
|
@ -147,7 +147,7 @@ void R_AddWallSplat(line_t *wallline, INT16 sectorside, const char *patchname, f
|
|||
splat->flags = flags;
|
||||
|
||||
// bad.. but will be needed for drawing anyway..
|
||||
patch = W_CachePatchNum(splat->patch, PU_CACHE);
|
||||
patch = W_CachePatchNum(splat->patch, PU_PATCH);
|
||||
|
||||
// offset needed by draw code for texture mapping
|
||||
linelength = P_SegLength((seg_t *)wallline);
|
||||
|
|
114
src/r_things.c
114
src/r_things.c
|
@ -105,48 +105,41 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
|
|||
UINT8 rotation,
|
||||
UINT8 flipped)
|
||||
{
|
||||
char cn = R_Frame2Char(frame); // for debugging
|
||||
char cn = R_Frame2Char(frame), cr = R_Rotation2Char(rotation); // for debugging
|
||||
|
||||
INT32 r, ang;
|
||||
lumpnum_t lumppat = wad;
|
||||
lumppat <<= 16;
|
||||
lumppat += lump;
|
||||
|
||||
if (frame >= 64 || !(R_ValidSpriteAngle(rotation)))
|
||||
I_Error("R_InstallSpriteLump: Bad frame characters in lump %s", W_CheckNameForNum(lumppat));
|
||||
|
||||
if (maxframe ==(size_t)-1 || frame > maxframe)
|
||||
maxframe = frame;
|
||||
|
||||
// rotsprite
|
||||
#ifdef ROTSPRITE
|
||||
for (r = 0; r < 8; r++)
|
||||
sprtemp[frame].rotsprite.cached = 0;
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
sprtemp[frame].rotsprite.cached[r] = false;
|
||||
for (ang = 0; ang < ROTANGLES; ang++)
|
||||
sprtemp[frame].rotsprite.patch[r][ang] = NULL;
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
sprtemp[frame].rotsprite.hardware_patch[r] = M_AATreeAlloc(AATREE_ZUSER);
|
||||
#endif // HWRENDER
|
||||
}
|
||||
#endif
|
||||
#endif/*ROTSPRITE*/
|
||||
|
||||
if (rotation == 0)
|
||||
{
|
||||
// the lump should be used for all rotations
|
||||
if (sprtemp[frame].rotate == SRF_SINGLE)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple rot = 0 lump\n", spritename, cn);
|
||||
else if (sprtemp[frame].rotate != SRF_NONE) // Let's bundle 1-8 and L/R rotations into one debug message.
|
||||
else if (sprtemp[frame].rotate != SRF_NONE) // Let's bundle 1-8/16 and L/R rotations into one debug message.
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has rotations and a rot = 0 lump\n", spritename, cn);
|
||||
|
||||
sprtemp[frame].rotate = SRF_SINGLE;
|
||||
for (r = 0; r < 8; r++)
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
sprtemp[frame].lumppat[r] = lumppat;
|
||||
sprtemp[frame].lumpid[r] = lumpid;
|
||||
}
|
||||
sprtemp[frame].flip = flipped ? 0xFF : 0; // 11111111 in binary
|
||||
sprtemp[frame].flip = flipped ? 0xFFFF : 0; // 1111111111111111 in binary
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -155,54 +148,67 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
|
|||
UINT8 rightfactor = ((rotation == ROT_R) ? 4 : 0);
|
||||
|
||||
// the lump should be used for half of all rotations
|
||||
if (sprtemp[frame].rotate == SRF_SINGLE)
|
||||
if (sprtemp[frame].rotate == SRF_NONE)
|
||||
sprtemp[frame].rotate = SRF_SINGLE;
|
||||
else if (sprtemp[frame].rotate == SRF_SINGLE)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has L/R rotations and a rot = 0 lump\n", spritename, cn);
|
||||
else if (sprtemp[frame].rotate == SRF_3D)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-8 rotations\n", spritename, cn);
|
||||
else if (sprtemp[frame].rotate == SRF_3DGE)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-G rotations\n", spritename, cn);
|
||||
else if ((sprtemp[frame].rotate & SRF_LEFT) && (rotation == ROT_L))
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple L rotations\n", spritename, cn);
|
||||
else if ((sprtemp[frame].rotate & SRF_RIGHT) && (rotation == ROT_R))
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple R rotations\n", spritename, cn);
|
||||
|
||||
if (sprtemp[frame].rotate == SRF_NONE)
|
||||
sprtemp[frame].rotate = SRF_SINGLE;
|
||||
|
||||
sprtemp[frame].rotate |= ((rotation == ROT_R) ? SRF_RIGHT : SRF_LEFT);
|
||||
if (sprtemp[frame].rotate == (SRF_3D|SRF_2D))
|
||||
sprtemp[frame].rotate = SRF_2D; // SRF_3D|SRF_2D being enabled at the same time doesn't HURT in the current sprite angle implementation, but it DOES mean more to check in some of the helper functions. Let's not allow this scenario to happen.
|
||||
if ((sprtemp[frame].rotate & SRF_2D) == SRF_2D)
|
||||
sprtemp[frame].rotate &= ~SRF_3DMASK; // SRF_3D|SRF_2D being enabled at the same time doesn't HURT in the current sprite angle implementation, but it DOES mean more to check in some of the helper functions. Let's not allow this scenario to happen.
|
||||
|
||||
for (r = 0; r < 4; r++) // Thanks to R_PrecacheLevel, we can't leave sprtemp[*].lumppat[*] == LUMPERROR... so we load into the front/back angle too.
|
||||
// load into every relevant angle, including the front one
|
||||
for (r = 0; r < 4; r++)
|
||||
{
|
||||
sprtemp[frame].lumppat[r + rightfactor] = lumppat;
|
||||
sprtemp[frame].lumpid[r + rightfactor] = lumpid;
|
||||
sprtemp[frame].lumppat[r + rightfactor + 8] = lumppat;
|
||||
sprtemp[frame].lumpid[r + rightfactor + 8] = lumpid;
|
||||
|
||||
}
|
||||
|
||||
if (flipped)
|
||||
sprtemp[frame].flip |= (0x0F<<rightfactor); // 00001111 or 11110000 in binary, depending on rotation being ROT_L or ROT_R
|
||||
sprtemp[frame].flip |= (0x0F0F<<rightfactor); // 0000111100001111 or 1111000011110000 in binary, depending on rotation being ROT_L or ROT_R
|
||||
else
|
||||
sprtemp[frame].flip &= ~(0x0F<<rightfactor); // ditto
|
||||
sprtemp[frame].flip &= ~(0x0F0F<<rightfactor); // ditto
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// the lump is only used for one rotation
|
||||
if (sprtemp[frame].rotate == SRF_SINGLE)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has 1-8 rotations and a rot = 0 lump\n", spritename, cn);
|
||||
else if ((sprtemp[frame].rotate != SRF_3D) && (sprtemp[frame].rotate != SRF_NONE))
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-8 rotations\n", spritename, cn);
|
||||
if (sprtemp[frame].rotate == SRF_NONE)
|
||||
sprtemp[frame].rotate = SRF_SINGLE;
|
||||
else if (sprtemp[frame].rotate == SRF_SINGLE)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has 1-8/G rotations and a rot = 0 lump\n", spritename, cn);
|
||||
else if (sprtemp[frame].rotate & SRF_2D)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-8/G rotations\n", spritename, cn);
|
||||
|
||||
// make 0 based
|
||||
rotation--;
|
||||
|
||||
if (rotation == 0 || rotation == 4) // Front or back...
|
||||
sprtemp[frame].rotate = SRF_3D; // Prevent L and R changeover
|
||||
else if (rotation > 3) // Right side
|
||||
sprtemp[frame].rotate = (SRF_3D | (sprtemp[frame].rotate & SRF_LEFT)); // Continue allowing L frame changeover
|
||||
else // if (rotation <= 3) // Left side
|
||||
sprtemp[frame].rotate = (SRF_3D | (sprtemp[frame].rotate & SRF_RIGHT)); // Continue allowing R frame changeover
|
||||
{
|
||||
// SRF_3D|SRF_3DGE being enabled at the same time doesn't HURT in the current sprite angle implementation, but it DOES mean more to check in some of the helper functions. Let's not allow this scenario to happen.
|
||||
UINT8 threedrot = (rotation > 7) ? SRF_3DGE : (sprtemp[frame].rotate & SRF_3DMASK);
|
||||
if (!threedrot)
|
||||
threedrot = SRF_3D;
|
||||
|
||||
if (rotation == 0 || rotation == 4) // Front or back...
|
||||
sprtemp[frame].rotate = threedrot; // Prevent L and R changeover
|
||||
else if ((rotation & 7) > 3) // Right side
|
||||
sprtemp[frame].rotate = (threedrot | (sprtemp[frame].rotate & SRF_LEFT)); // Continue allowing L frame changeover
|
||||
else // if ((rotation & 7) <= 3) // Left side
|
||||
sprtemp[frame].rotate = (threedrot | (sprtemp[frame].rotate & SRF_RIGHT)); // Continue allowing R frame changeover
|
||||
}
|
||||
|
||||
if (sprtemp[frame].lumppat[rotation] != LUMPERROR)
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s: %c%c has two lumps mapped to it\n", spritename, cn, '1'+rotation);
|
||||
CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s: %c%c has two lumps mapped to it\n", spritename, cn, cr);
|
||||
|
||||
// lumppat & lumpid are the same for original Doom, but different
|
||||
// when using sprites in pwad : the lumppat points the new graphics
|
||||
|
@ -263,9 +269,9 @@ static boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef,
|
|||
if (memcmp(lumpinfo[l].name,sprname,4)==0)
|
||||
{
|
||||
frame = R_Char2Frame(lumpinfo[l].name[4]);
|
||||
rotation = (UINT8)(lumpinfo[l].name[5] - '0');
|
||||
rotation = R_Char2Rotation(lumpinfo[l].name[5]);
|
||||
|
||||
if (frame >= 64 || !(R_ValidSpriteAngle(rotation))) // Give an actual NAME error -_-...
|
||||
if (frame >= 64 || rotation == 255) // Give an actual NAME error -_-...
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum,l));
|
||||
continue;
|
||||
|
@ -285,7 +291,7 @@ static boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef,
|
|||
// lump is a png so convert it
|
||||
if (R_IsLumpPNG((UINT8 *)png, len))
|
||||
{
|
||||
png = R_PNGToPatch((UINT8 *)png, len, NULL, true);
|
||||
png = R_PNGToPatch((UINT8 *)png, len, NULL);
|
||||
M_Memcpy(&patch, png, sizeof(INT16)*4);
|
||||
}
|
||||
Z_Free(png);
|
||||
|
@ -312,7 +318,13 @@ static boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef,
|
|||
if (lumpinfo[l].name[6])
|
||||
{
|
||||
frame = R_Char2Frame(lumpinfo[l].name[6]);
|
||||
rotation = (UINT8)(lumpinfo[l].name[7] - '0');
|
||||
rotation = R_Char2Rotation(lumpinfo[l].name[7]);
|
||||
|
||||
if (frame >= 64 || rotation == 255) // Give an actual NAME error -_-...
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum,l));
|
||||
continue;
|
||||
}
|
||||
R_InstallSpriteLump(wadnum, l, numspritelumps, frame, rotation, 1);
|
||||
}
|
||||
|
||||
|
@ -373,18 +385,19 @@ static boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef,
|
|||
case SRF_2D: // both Left and Right rotations
|
||||
// we test to see whether the left and right slots are present
|
||||
if ((sprtemp[frame].lumppat[2] == LUMPERROR) || (sprtemp[frame].lumppat[6] == LUMPERROR))
|
||||
I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations",
|
||||
I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations (L-R mode)",
|
||||
sprname, R_Frame2Char(frame));
|
||||
break;
|
||||
|
||||
default:
|
||||
// must have all 8 frames
|
||||
for (rotation = 0; rotation < 8; rotation++)
|
||||
// must have all 8/16 frames
|
||||
rotation = ((sprtemp[frame].rotate & SRF_3DGE) ? 16 : 8);
|
||||
while (rotation--)
|
||||
// we test the patch lump, or the id lump whatever
|
||||
// if it was not loaded the two are LUMPERROR
|
||||
if (sprtemp[frame].lumppat[rotation] == LUMPERROR)
|
||||
I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations",
|
||||
sprname, R_Frame2Char(frame));
|
||||
I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations (1-%c mode)",
|
||||
sprname, R_Frame2Char(frame), ((sprtemp[frame].rotate & SRF_3DGE) ? 'G' : '8'));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -988,7 +1001,7 @@ static void R_DrawPrecipitationVisSprite(vissprite_t *vis)
|
|||
|
||||
//
|
||||
// R_SplitSprite
|
||||
// runs through a sector's lightlist and
|
||||
// runs through a sector's lightlist and Knuckles
|
||||
static void R_SplitSprite(vissprite_t *sprite)
|
||||
{
|
||||
INT32 i, lightnum, lindex;
|
||||
|
@ -1098,7 +1111,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
|||
size_t lump;
|
||||
|
||||
size_t rot;
|
||||
UINT8 flip;
|
||||
UINT16 flip;
|
||||
boolean vflip = (!(thing->eflags & MFE_VERTICALFLIP) != !(thing->frame & FF_VERTICALFLIP));
|
||||
|
||||
INT32 lindex;
|
||||
|
@ -1228,7 +1241,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
|||
// use single rotation for all views
|
||||
rot = 0; //Fab: for vis->patch below
|
||||
lump = sprframe->lumpid[0]; //Fab: see note above
|
||||
flip = sprframe->flip; // Will only be 0x00 or 0xFF
|
||||
flip = sprframe->flip; // Will only be 0 or 0xFFFF
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1239,6 +1252,11 @@ static void R_ProjectSprite(mobj_t *thing)
|
|||
rot = 6; // F7 slot
|
||||
else if ((sprframe->rotate & SRF_LEFT) && (ang >= ANGLE_180)) // See from left
|
||||
rot = 2; // F3 slot
|
||||
else if (sprframe->rotate & SRF_3DGE) // 16-angle mode
|
||||
{
|
||||
rot = (ang+ANGLE_180+ANGLE_11hh)>>28;
|
||||
rot = ((rot & 1)<<3)|(rot>>1);
|
||||
}
|
||||
else // Normal behaviour
|
||||
rot = (ang+ANGLE_202h)>>29;
|
||||
|
||||
|
@ -1261,7 +1279,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
|||
if (thing->rollangle)
|
||||
{
|
||||
rollangle = R_GetRollAngle(thing->rollangle);
|
||||
if (!sprframe->rotsprite.cached[rot])
|
||||
if (!(sprframe->rotsprite.cached & (1<<rot)))
|
||||
R_CacheRotSprite(thing->sprite, (thing->frame & FF_FRAMEMASK), sprinfo, sprframe, rot, flip);
|
||||
rotsprite = sprframe->rotsprite.patch[rot][rollangle];
|
||||
if (rotsprite != NULL)
|
||||
|
|
|
@ -20,10 +20,6 @@
|
|||
#include "r_portal.h"
|
||||
#include "r_defs.h"
|
||||
|
||||
// "Left" and "Right" character symbols for additional rotation functionality
|
||||
#define ROT_L ('L' - '0')
|
||||
#define ROT_R ('R' - '0')
|
||||
|
||||
// number of sprite lumps for spritewidth,offset,topoffset lookup tables
|
||||
// Fab: this is a hack : should allocate the lookup tables per sprite
|
||||
#define MAXVISSPRITES 2048 // added 2-2-98 was 128
|
||||
|
@ -270,7 +266,7 @@ FUNCMATH FUNCINLINE static ATTRINLINE UINT8 R_Char2Frame(char cn)
|
|||
if (cn == '+') return '\\' - 'A'; // PK3 can't use backslash, so use + instead
|
||||
return cn - 'A';
|
||||
#else
|
||||
if (cn >= 'A' && cn <= 'Z') return cn - 'A';
|
||||
if (cn >= 'A' && cn <= 'Z') return (cn - 'A');
|
||||
if (cn >= '0' && cn <= '9') return (cn - '0') + 26;
|
||||
if (cn >= 'a' && cn <= 'z') return (cn - 'a') + 36;
|
||||
if (cn == '!') return 62;
|
||||
|
@ -279,9 +275,26 @@ FUNCMATH FUNCINLINE static ATTRINLINE UINT8 R_Char2Frame(char cn)
|
|||
#endif
|
||||
}
|
||||
|
||||
FUNCMATH FUNCINLINE static ATTRINLINE boolean R_ValidSpriteAngle(UINT8 rotation)
|
||||
// "Left" and "Right" character symbols for additional rotation functionality
|
||||
#define ROT_L 17
|
||||
#define ROT_R 18
|
||||
|
||||
FUNCMATH FUNCINLINE static ATTRINLINE char R_Rotation2Char(UINT8 rot)
|
||||
{
|
||||
return ((rotation <= 8) || (rotation == ROT_L) || (rotation == ROT_R));
|
||||
if (rot <= 9) return '0' + rot;
|
||||
if (rot <= 16) return 'A' + (rot - 10);
|
||||
if (rot == ROT_L) return 'L';
|
||||
if (rot == ROT_R) return 'R';
|
||||
return '\xFF';
|
||||
}
|
||||
|
||||
FUNCMATH FUNCINLINE static ATTRINLINE UINT8 R_Char2Rotation(char cn)
|
||||
{
|
||||
if (cn >= '0' && cn <= '9') return (cn - '0');
|
||||
if (cn >= 'A' && cn <= 'G') return (cn - 'A') + 10;
|
||||
if (cn == 'L') return ROT_L;
|
||||
if (cn == 'R') return ROT_R;
|
||||
return 255;
|
||||
}
|
||||
|
||||
#endif //__R_THINGS__
|
||||
|
|
|
@ -61,7 +61,9 @@ static void GameMIDIMusic_OnChange(void);
|
|||
static void GameSounds_OnChange(void);
|
||||
static void GameDigiMusic_OnChange(void);
|
||||
|
||||
#ifdef HAVE_OPENMPT
|
||||
static void ModFilter_OnChange(void);
|
||||
#endif
|
||||
|
||||
static lumpnum_t S_GetMusicLumpNum(const char *mname);
|
||||
|
||||
|
|
105
src/screen.c
105
src/screen.c
|
@ -53,6 +53,7 @@ void (*spanfuncs_npo2[SPANDRAWFUNC_MAX])(void);
|
|||
// ------------------
|
||||
viddef_t vid;
|
||||
INT32 setmodeneeded; //video mode change needed if > 0 (the mode number to set + 1)
|
||||
UINT8 setrenderneeded = 0;
|
||||
|
||||
static CV_PossibleValue_t scr_depth_cons_t[] = {{8, "8 bits"}, {16, "16 bits"}, {24, "24 bits"}, {32, "32 bits"}, {0, NULL}};
|
||||
|
||||
|
@ -62,7 +63,17 @@ consvar_t cv_scr_height = {"scr_height", "800", CV_SAVE, CV_Unsigned, NULL, 0, N
|
|||
consvar_t cv_scr_depth = {"scr_depth", "16 bits", CV_SAVE, scr_depth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_renderview = {"renderview", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static void SCR_ChangeFullscreen (void);
|
||||
static void SCR_ActuallyChangeRenderer(void);
|
||||
CV_PossibleValue_t cv_renderer_t[] = {
|
||||
{1, "Software"},
|
||||
#ifdef HWRENDER
|
||||
{2, "OpenGL"},
|
||||
#endif
|
||||
{0, NULL}
|
||||
};
|
||||
consvar_t cv_renderer = {"renderer", "Software", CV_SAVE|CV_NOLUA|CV_CALL, cv_renderer_t, SCR_ChangeRenderer, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static void SCR_ChangeFullscreen(void);
|
||||
|
||||
consvar_t cv_fullscreen = {"fullscreen", "Yes", CV_SAVE|CV_CALL, CV_YesNo, SCR_ChangeFullscreen, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
|
@ -87,19 +98,8 @@ boolean R_3DNow = false;
|
|||
boolean R_MMXExt = false;
|
||||
boolean R_SSE2 = false;
|
||||
|
||||
|
||||
void SCR_SetMode(void)
|
||||
void SCR_SetDrawFuncs(void)
|
||||
{
|
||||
if (dedicated)
|
||||
return;
|
||||
|
||||
if (!setmodeneeded || WipeInAction)
|
||||
return; // should never happen and don't change it during a wipe, BAD!
|
||||
|
||||
VID_SetMode(--setmodeneeded);
|
||||
|
||||
V_SetPalette(0);
|
||||
|
||||
//
|
||||
// setup the right draw routines for either 8bpp or 16bpp
|
||||
//
|
||||
|
@ -193,9 +193,37 @@ void SCR_SetMode(void)
|
|||
if (SCR_IsAspectCorrect(vid.width, vid.height))
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Resolution is not aspect-correct!\nUse a multiple of %dx%d\n"), BASEVIDWIDTH, BASEVIDHEIGHT);
|
||||
*/
|
||||
}
|
||||
|
||||
void SCR_SetMode(void)
|
||||
{
|
||||
if (dedicated)
|
||||
return;
|
||||
|
||||
if (!(setmodeneeded || setrenderneeded) || WipeInAction)
|
||||
return; // should never happen and don't change it during a wipe, BAD!
|
||||
|
||||
// Lactozilla: Renderer switching
|
||||
if (setrenderneeded)
|
||||
{
|
||||
Z_PreparePatchFlush();
|
||||
needpatchflush = true;
|
||||
needpatchrecache = true;
|
||||
VID_CheckRenderer();
|
||||
if (!setmodeneeded)
|
||||
VID_SetMode(vid.modenum);
|
||||
}
|
||||
|
||||
if (setmodeneeded)
|
||||
VID_SetMode(--setmodeneeded);
|
||||
|
||||
V_SetPalette(0);
|
||||
|
||||
SCR_SetDrawFuncs();
|
||||
|
||||
// set the apprpriate drawer for the sky (tall or INT16)
|
||||
setmodeneeded = 0;
|
||||
setrenderneeded = 0;
|
||||
}
|
||||
|
||||
// do some initial settings for the game loading screen
|
||||
|
@ -383,6 +411,8 @@ void SCR_CheckDefaultMode(void)
|
|||
// see note above
|
||||
setmodeneeded = VID_GetModeForSize(cv_scr_width.value, cv_scr_height.value) + 1;
|
||||
}
|
||||
|
||||
SCR_ActuallyChangeRenderer();
|
||||
}
|
||||
|
||||
// sets the modenum as the new default video mode to be saved in the config file
|
||||
|
@ -412,6 +442,55 @@ void SCR_ChangeFullscreen(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
static int target_renderer = 0;
|
||||
|
||||
void SCR_ActuallyChangeRenderer(void)
|
||||
{
|
||||
setrenderneeded = target_renderer;
|
||||
// setting the same renderer twice WILL crash your game, so let's not, please
|
||||
if (rendermode == setrenderneeded)
|
||||
setrenderneeded = 0;
|
||||
}
|
||||
|
||||
// Lactozilla: Renderer switching
|
||||
void SCR_ChangeRenderer(void)
|
||||
{
|
||||
setrenderneeded = 0;
|
||||
|
||||
if (con_startup)
|
||||
{
|
||||
target_renderer = cv_renderer.value;
|
||||
#ifdef HWRENDER
|
||||
if (M_CheckParm("-opengl"))
|
||||
target_renderer = rendermode = render_opengl;
|
||||
else
|
||||
#endif
|
||||
if (M_CheckParm("-software"))
|
||||
target_renderer = rendermode = render_soft;
|
||||
// set cv_renderer back
|
||||
SCR_ChangeRendererCVars(rendermode);
|
||||
return;
|
||||
}
|
||||
|
||||
if (cv_renderer.value == 1)
|
||||
target_renderer = render_soft;
|
||||
else if (cv_renderer.value == 2)
|
||||
target_renderer = render_opengl;
|
||||
SCR_ActuallyChangeRenderer();
|
||||
}
|
||||
|
||||
void SCR_ChangeRendererCVars(INT32 mode)
|
||||
{
|
||||
// set cv_renderer back
|
||||
if (mode == render_soft)
|
||||
CV_StealthSetValue(&cv_renderer, 1);
|
||||
else if (mode == render_opengl)
|
||||
CV_StealthSetValue(&cv_renderer, 2);
|
||||
#ifdef HWRENDER
|
||||
CV_StealthSetValue(&cv_newrenderer, cv_renderer.value);
|
||||
#endif
|
||||
}
|
||||
|
||||
boolean SCR_IsAspectCorrect(INT32 width, INT32 height)
|
||||
{
|
||||
return
|
||||
|
|
13
src/screen.h
13
src/screen.h
|
@ -170,18 +170,29 @@ extern boolean R_SSE2;
|
|||
// ----------------
|
||||
// screen variables
|
||||
// ----------------
|
||||
|
||||
extern viddef_t vid;
|
||||
extern INT32 setmodeneeded; // mode number to set if needed, or 0
|
||||
|
||||
void SCR_ChangeRenderer(void);
|
||||
void SCR_ChangeRendererCVars(INT32 mode);
|
||||
extern UINT8 setrenderneeded;
|
||||
|
||||
extern INT32 scr_bpp;
|
||||
extern UINT8 *scr_borderpatch; // patch used to fill the view borders
|
||||
|
||||
extern consvar_t cv_scr_width, cv_scr_height, cv_scr_depth, cv_renderview, cv_fullscreen;
|
||||
extern CV_PossibleValue_t cv_renderer_t[];
|
||||
|
||||
extern consvar_t cv_scr_width, cv_scr_height, cv_scr_depth, cv_renderview, cv_renderer, cv_fullscreen;
|
||||
#ifdef HWRENDER
|
||||
extern consvar_t cv_newrenderer;
|
||||
#endif
|
||||
// wait for page flipping to end or not
|
||||
extern consvar_t cv_vidwait;
|
||||
|
||||
// Change video mode, only at the start of a refresh.
|
||||
void SCR_SetMode(void);
|
||||
void SCR_SetDrawFuncs(void);
|
||||
// Recalc screen size dependent stuff
|
||||
void SCR_Recalc(void);
|
||||
// Check parms once at startup
|
||||
|
|
|
@ -67,10 +67,12 @@
|
|||
#include "../s_sound.h"
|
||||
#include "../i_joy.h"
|
||||
#include "../st_stuff.h"
|
||||
#include "../hu_stuff.h"
|
||||
#include "../g_game.h"
|
||||
#include "../i_video.h"
|
||||
#include "../console.h"
|
||||
#include "../command.h"
|
||||
#include "../r_main.h"
|
||||
#include "sdlmain.h"
|
||||
#ifdef HWRENDER
|
||||
#include "../hardware/hw_main.h"
|
||||
|
@ -98,6 +100,7 @@ boolean highcolor = false;
|
|||
// synchronize page flipping with screen refresh
|
||||
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static consvar_t cv_alwaysgrabmouse = {"alwaysgrabmouse", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
UINT8 graphics_started = 0; // Is used in console.c and screen.c
|
||||
|
||||
|
@ -107,6 +110,7 @@ static SDL_bool disable_fullscreen = SDL_FALSE;
|
|||
#define USE_FULLSCREEN (disable_fullscreen||!allow_fullscreen)?0:cv_fullscreen.value
|
||||
static SDL_bool disable_mouse = SDL_FALSE;
|
||||
#define USE_MOUSEINPUT (!disable_mouse && cv_usemouse.value && havefocus)
|
||||
#define IGNORE_MOUSE (!cv_alwaysgrabmouse.value && (menuactive || paused || con_destlines || chat_on || gamestate != GS_LEVEL))
|
||||
#define MOUSE_MENU false //(!disable_mouse && cv_usemouse.value && menuactive && !USE_FULLSCREEN)
|
||||
#define MOUSEBUTTONS_MAX MOUSEBUTTONS
|
||||
|
||||
|
@ -377,12 +381,15 @@ static void SDLdoUngrabMouse(void)
|
|||
void SDLforceUngrabMouse(void)
|
||||
{
|
||||
if (SDL_WasInit(SDL_INIT_VIDEO)==SDL_INIT_VIDEO && window != NULL)
|
||||
{
|
||||
SDL_ShowCursor(SDL_ENABLE);
|
||||
SDL_SetWindowGrab(window, SDL_FALSE);
|
||||
wrapmouseok = SDL_FALSE;
|
||||
SDL_SetRelativeMouseMode(SDL_FALSE);
|
||||
}
|
||||
SDLdoUngrabMouse();
|
||||
}
|
||||
|
||||
void I_UpdateMouseGrab(void)
|
||||
{
|
||||
if (SDL_WasInit(SDL_INIT_VIDEO) == SDL_INIT_VIDEO && window != NULL
|
||||
&& SDL_GetMouseFocus() == window && SDL_GetKeyboardFocus() == window
|
||||
&& USE_MOUSEINPUT && !IGNORE_MOUSE)
|
||||
SDLdoGrabMouse();
|
||||
}
|
||||
|
||||
static void VID_Command_NumModes_f (void)
|
||||
|
@ -589,7 +596,7 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
|
|||
}
|
||||
//else firsttimeonmouse = SDL_FALSE;
|
||||
|
||||
if (USE_MOUSEINPUT)
|
||||
if (USE_MOUSEINPUT && !IGNORE_MOUSE)
|
||||
SDLdoGrabMouse();
|
||||
}
|
||||
else if (!mousefocus && !kbfocus)
|
||||
|
@ -636,11 +643,14 @@ static void Impl_HandleKeyboardEvent(SDL_KeyboardEvent evt, Uint32 type)
|
|||
|
||||
static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
|
||||
{
|
||||
static boolean firstmove = true;
|
||||
|
||||
if (USE_MOUSEINPUT)
|
||||
{
|
||||
if ((SDL_GetMouseFocus() != window && SDL_GetKeyboardFocus() != window))
|
||||
if ((SDL_GetMouseFocus() != window && SDL_GetKeyboardFocus() != window) || (IGNORE_MOUSE && !firstmove))
|
||||
{
|
||||
SDLdoUngrabMouse();
|
||||
firstmove = false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -654,6 +664,7 @@ static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
|
|||
mousemovey += -evt.yrel;
|
||||
SDL_SetWindowGrab(window, SDL_TRUE);
|
||||
}
|
||||
firstmove = false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -661,6 +672,7 @@ static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
|
|||
// of the screen then ignore it.
|
||||
if ((evt.x == realwidth/2) && (evt.y == realheight/2))
|
||||
{
|
||||
firstmove = false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -673,6 +685,8 @@ static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
|
|||
SDLdoGrabMouse();
|
||||
}
|
||||
}
|
||||
|
||||
firstmove = false;
|
||||
}
|
||||
|
||||
static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
|
||||
|
@ -686,7 +700,7 @@ static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
|
|||
// this apparently makes a mouse button down event but not a mouse button up event,
|
||||
// resulting in whatever key was pressed down getting "stuck" if we don't ignore it.
|
||||
// -- Monster Iestyn (28/05/18)
|
||||
if (SDL_GetMouseFocus() != window)
|
||||
if (SDL_GetMouseFocus() != window || IGNORE_MOUSE)
|
||||
return;
|
||||
|
||||
/// \todo inputEvent.button.which
|
||||
|
@ -1068,7 +1082,7 @@ void I_StartupMouse(void)
|
|||
}
|
||||
else
|
||||
firsttimeonmouse = SDL_FALSE;
|
||||
if (cv_usemouse.value)
|
||||
if (cv_usemouse.value && !IGNORE_MOUSE)
|
||||
SDLdoGrabMouse();
|
||||
else
|
||||
SDLdoUngrabMouse();
|
||||
|
@ -1208,7 +1222,6 @@ void I_FinishUpdate(void)
|
|||
SDL_RenderCopy(renderer, texture, NULL, NULL);
|
||||
SDL_RenderPresent(renderer);
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
else if (rendermode == render_opengl)
|
||||
{
|
||||
|
@ -1408,37 +1421,53 @@ void VID_PrepareModeList(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
INT32 VID_SetMode(INT32 modeNum)
|
||||
static SDL_bool Impl_CreateContext(void)
|
||||
{
|
||||
SDLdoUngrabMouse();
|
||||
|
||||
vid.recalc = 1;
|
||||
vid.bpp = 1;
|
||||
|
||||
if (modeNum >= 0 && modeNum < MAXWINMODES)
|
||||
// Renderer-specific stuff
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
vid.width = windowedModes[modeNum][0];
|
||||
vid.height = windowedModes[modeNum][1];
|
||||
vid.modenum = modeNum;
|
||||
if (!sdlglcontext)
|
||||
sdlglcontext = SDL_GL_CreateContext(window);
|
||||
if (sdlglcontext == NULL)
|
||||
{
|
||||
SDL_DestroyWindow(window);
|
||||
I_Error("Failed to create a GL context: %s\n", SDL_GetError());
|
||||
}
|
||||
SDL_GL_MakeCurrent(window, sdlglcontext);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
// just set the desktop resolution as a fallback
|
||||
SDL_DisplayMode mode;
|
||||
SDL_GetWindowDisplayMode(window, &mode);
|
||||
if (mode.w >= 2048)
|
||||
int flags = 0; // Use this to set SDL_RENDERER_* flags now
|
||||
if (usesdl2soft)
|
||||
flags |= SDL_RENDERER_SOFTWARE;
|
||||
else if (cv_vidwait.value)
|
||||
flags |= SDL_RENDERER_PRESENTVSYNC;
|
||||
|
||||
if (!renderer)
|
||||
renderer = SDL_CreateRenderer(window, -1, flags);
|
||||
if (renderer == NULL)
|
||||
{
|
||||
vid.width = 1920;
|
||||
vid.height = 1200;
|
||||
CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
|
||||
return SDL_FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
vid.width = mode.w;
|
||||
vid.height = mode.h;
|
||||
}
|
||||
vid.modenum = -1;
|
||||
SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
|
||||
}
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void)
|
||||
{
|
||||
if (dedicated)
|
||||
return;
|
||||
|
||||
if (setrenderneeded)
|
||||
{
|
||||
rendermode = setrenderneeded;
|
||||
Impl_CreateContext();
|
||||
}
|
||||
//Impl_SetWindowName("SRB2 "VERSIONSTRING);
|
||||
|
||||
SDLSetMode(vid.width, vid.height, USE_FULLSCREEN);
|
||||
Impl_VideoSetupBuffer();
|
||||
|
@ -1450,8 +1479,39 @@ INT32 VID_SetMode(INT32 modeNum)
|
|||
SDL_FreeSurface(bufSurface);
|
||||
bufSurface = NULL;
|
||||
}
|
||||
#ifdef HWRENDER
|
||||
HWR_FreeTextureCache();
|
||||
#endif
|
||||
SCR_SetDrawFuncs();
|
||||
}
|
||||
#ifdef HWRENDER
|
||||
else if (rendermode == render_opengl)
|
||||
{
|
||||
I_StartupHardwareGraphics();
|
||||
R_InitHardwareMode();
|
||||
HWR_Switch();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
INT32 VID_SetMode(INT32 modeNum)
|
||||
{
|
||||
SDLdoUngrabMouse();
|
||||
|
||||
vid.recalc = 1;
|
||||
vid.bpp = 1;
|
||||
|
||||
if (modeNum < 0)
|
||||
modeNum = 0;
|
||||
if (modeNum >= MAXWINMODES)
|
||||
modeNum = MAXWINMODES-1;
|
||||
|
||||
vid.width = windowedModes[modeNum][0];
|
||||
vid.height = windowedModes[modeNum][1];
|
||||
vid.modenum = modeNum;
|
||||
|
||||
//Impl_SetWindowName("SRB2 "VERSIONSTRING);
|
||||
VID_CheckRenderer();
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
|
@ -1472,8 +1532,7 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
|
|||
flags |= SDL_WINDOW_BORDERLESS;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
flags |= SDL_WINDOW_OPENGL;
|
||||
flags |= SDL_WINDOW_OPENGL;
|
||||
#endif
|
||||
|
||||
// Create a window
|
||||
|
@ -1486,38 +1545,7 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
|
|||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
// Renderer-specific stuff
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
sdlglcontext = SDL_GL_CreateContext(window);
|
||||
if (sdlglcontext == NULL)
|
||||
{
|
||||
SDL_DestroyWindow(window);
|
||||
I_Error("Failed to create a GL context: %s\n", SDL_GetError());
|
||||
}
|
||||
SDL_GL_MakeCurrent(window, sdlglcontext);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
flags = 0; // Use this to set SDL_RENDERER_* flags now
|
||||
if (usesdl2soft)
|
||||
flags |= SDL_RENDERER_SOFTWARE;
|
||||
else if (cv_vidwait.value)
|
||||
flags |= SDL_RENDERER_PRESENTVSYNC;
|
||||
|
||||
renderer = SDL_CreateRenderer(window, -1, flags);
|
||||
if (renderer == NULL)
|
||||
{
|
||||
CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
|
||||
return SDL_FALSE;
|
||||
}
|
||||
SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
|
||||
}
|
||||
|
||||
return SDL_TRUE;
|
||||
return Impl_CreateContext();
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1572,17 +1600,14 @@ static void Impl_VideoSetupSDLBuffer(void)
|
|||
static void Impl_VideoSetupBuffer(void)
|
||||
{
|
||||
// Set up game's software render buffer
|
||||
//if (rendermode == render_soft)
|
||||
vid.rowbytes = vid.width * vid.bpp;
|
||||
vid.direct = NULL;
|
||||
if (vid.buffer)
|
||||
free(vid.buffer);
|
||||
vid.buffer = calloc(vid.rowbytes*vid.height, NUMSCREENS);
|
||||
if (!vid.buffer)
|
||||
{
|
||||
vid.rowbytes = vid.width * vid.bpp;
|
||||
vid.direct = NULL;
|
||||
if (vid.buffer)
|
||||
free(vid.buffer);
|
||||
vid.buffer = calloc(vid.rowbytes*vid.height, NUMSCREENS);
|
||||
if (!vid.buffer)
|
||||
{
|
||||
I_Error("%s", M_GetText("Not enough memory for video buffer\n"));
|
||||
}
|
||||
I_Error("%s", M_GetText("Not enough memory for video buffer\n"));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1602,6 +1627,7 @@ void I_StartupGraphics(void)
|
|||
COM_AddCommand ("vid_mode", VID_Command_Mode_f);
|
||||
CV_RegisterVar (&cv_vidwait);
|
||||
CV_RegisterVar (&cv_stretch);
|
||||
CV_RegisterVar (&cv_alwaysgrabmouse);
|
||||
disable_mouse = M_CheckParm("-nomouse");
|
||||
disable_fullscreen = M_CheckParm("-win") ? 1 : 0;
|
||||
|
||||
|
@ -1626,10 +1652,13 @@ void I_StartupGraphics(void)
|
|||
))
|
||||
framebuffer = SDL_TRUE;
|
||||
}
|
||||
if (M_CheckParm("-software"))
|
||||
{
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (M_CheckParm("-opengl"))
|
||||
rendermode = render_opengl;
|
||||
else if (M_CheckParm("-software"))
|
||||
#endif
|
||||
rendermode = render_soft;
|
||||
}
|
||||
|
||||
usesdl2soft = M_CheckParm("-softblit");
|
||||
borderlesswindow = M_CheckParm("-borderless");
|
||||
|
@ -1637,44 +1666,7 @@ void I_StartupGraphics(void)
|
|||
//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY>>1,SDL_DEFAULT_REPEAT_INTERVAL<<2);
|
||||
VID_Command_ModeList_f();
|
||||
#ifdef HWRENDER
|
||||
if (M_CheckParm("-opengl") || rendermode == render_opengl)
|
||||
{
|
||||
rendermode = render_opengl;
|
||||
HWD.pfnInit = hwSym("Init",NULL);
|
||||
HWD.pfnFinishUpdate = NULL;
|
||||
HWD.pfnDraw2DLine = hwSym("Draw2DLine",NULL);
|
||||
HWD.pfnDrawPolygon = hwSym("DrawPolygon",NULL);
|
||||
HWD.pfnRenderSkyDome = hwSym("RenderSkyDome",NULL);
|
||||
HWD.pfnSetBlend = hwSym("SetBlend",NULL);
|
||||
HWD.pfnClearBuffer = hwSym("ClearBuffer",NULL);
|
||||
HWD.pfnSetTexture = hwSym("SetTexture",NULL);
|
||||
HWD.pfnReadRect = hwSym("ReadRect",NULL);
|
||||
HWD.pfnGClipRect = hwSym("GClipRect",NULL);
|
||||
HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
|
||||
HWD.pfnSetSpecialState = hwSym("SetSpecialState",NULL);
|
||||
HWD.pfnSetPalette = hwSym("SetPalette",NULL);
|
||||
HWD.pfnGetTextureUsed = hwSym("GetTextureUsed",NULL);
|
||||
HWD.pfnDrawModel = hwSym("DrawModel",NULL);
|
||||
HWD.pfnCreateModelVBOs = hwSym("CreateModelVBOs",NULL);
|
||||
HWD.pfnSetTransform = hwSym("SetTransform",NULL);
|
||||
HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
|
||||
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
|
||||
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
|
||||
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
|
||||
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
|
||||
HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
|
||||
HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
|
||||
HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
|
||||
HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
|
||||
HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
|
||||
// check gl renderer lib
|
||||
if (HWD.pfnGetRenderVersion() != VERSION)
|
||||
I_Error("%s", M_GetText("The version of the renderer doesn't match the version of the executable\nBe sure you have installed SRB2 properly.\n"));
|
||||
if (!HWD.pfnInit(I_Error)) // let load the OpenGL library
|
||||
{
|
||||
rendermode = render_soft;
|
||||
}
|
||||
}
|
||||
I_StartupHardwareGraphics();
|
||||
#endif
|
||||
|
||||
// Fury: we do window initialization after GL setup to allow
|
||||
|
@ -1724,16 +1716,55 @@ void I_StartupGraphics(void)
|
|||
SDL_RaiseWindow(window);
|
||||
|
||||
if (mousegrabok && !disable_mouse)
|
||||
{
|
||||
SDL_ShowCursor(SDL_DISABLE);
|
||||
SDL_SetRelativeMouseMode(SDL_TRUE);
|
||||
wrapmouseok = SDL_TRUE;
|
||||
SDL_SetWindowGrab(window, SDL_TRUE);
|
||||
}
|
||||
SDLdoGrabMouse();
|
||||
|
||||
graphics_started = true;
|
||||
}
|
||||
|
||||
void I_StartupHardwareGraphics(void)
|
||||
{
|
||||
#ifdef HWRENDER
|
||||
static boolean glstartup = false;
|
||||
if (!glstartup)
|
||||
{
|
||||
HWD.pfnInit = hwSym("Init",NULL);
|
||||
HWD.pfnFinishUpdate = NULL;
|
||||
HWD.pfnDraw2DLine = hwSym("Draw2DLine",NULL);
|
||||
HWD.pfnDrawPolygon = hwSym("DrawPolygon",NULL);
|
||||
HWD.pfnRenderSkyDome = hwSym("RenderSkyDome",NULL);
|
||||
HWD.pfnSetBlend = hwSym("SetBlend",NULL);
|
||||
HWD.pfnClearBuffer = hwSym("ClearBuffer",NULL);
|
||||
HWD.pfnSetTexture = hwSym("SetTexture",NULL);
|
||||
HWD.pfnReadRect = hwSym("ReadRect",NULL);
|
||||
HWD.pfnGClipRect = hwSym("GClipRect",NULL);
|
||||
HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
|
||||
HWD.pfnSetSpecialState = hwSym("SetSpecialState",NULL);
|
||||
HWD.pfnSetPalette = hwSym("SetPalette",NULL);
|
||||
HWD.pfnGetTextureUsed = hwSym("GetTextureUsed",NULL);
|
||||
HWD.pfnDrawModel = hwSym("DrawModel",NULL);
|
||||
HWD.pfnCreateModelVBOs = hwSym("CreateModelVBOs",NULL);
|
||||
HWD.pfnSetTransform = hwSym("SetTransform",NULL);
|
||||
HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
|
||||
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
|
||||
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
|
||||
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
|
||||
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
|
||||
HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
|
||||
HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
|
||||
HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
|
||||
HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
|
||||
HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
|
||||
// check gl renderer lib
|
||||
if (HWD.pfnGetRenderVersion() != VERSION)
|
||||
I_Error("%s", M_GetText("The version of the renderer doesn't match the version of the executable\nBe sure you have installed SRB2 properly.\n"));
|
||||
if (!HWD.pfnInit(I_Error)) // let load the OpenGL library
|
||||
rendermode = render_soft;
|
||||
else
|
||||
glstartup = true;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void I_ShutdownGraphics(void)
|
||||
{
|
||||
const rendermode_t oldrendermode = rendermode;
|
||||
|
|
|
@ -1432,6 +1432,8 @@ static void I_ResumeGME(void)
|
|||
|
||||
boolean I_LoadSong(char *data, size_t len)
|
||||
{
|
||||
(void)data;
|
||||
(void)len;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -1493,6 +1495,7 @@ boolean I_FadeSongFromVolume(UINT8 target_volume, UINT8 source_volume, UINT32 ms
|
|||
(void)target_volume;
|
||||
(void)source_volume;
|
||||
(void)ms;
|
||||
(void)callback;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -1500,6 +1503,7 @@ boolean I_FadeSong(UINT8 target_volume, UINT32 ms, void (*callback)(void))
|
|||
{
|
||||
(void)target_volume;
|
||||
(void)ms;
|
||||
(void)callback;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
42
src/sounds.c
42
src/sounds.c
|
@ -187,6 +187,7 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"shield", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Pity Shield"}, // generic GET!
|
||||
{"wirlsg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Whirlwind Shield"}, // Whirlwind GET!
|
||||
{"forcsg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Force Shield"}, // Force GET!
|
||||
{"frcssg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Weak Force Shield"}, // Force GET...? (consider making a custom shield with this instead of a single-hit force shield!)
|
||||
{"elemsg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Elemental Shield"}, // Elemental GET!
|
||||
{"armasg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Armageddon Shield"}, // Armaggeddon GET!
|
||||
{"attrsg", false, 60, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Attraction Shield"}, // Attract GET!
|
||||
|
@ -220,6 +221,9 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"sprong", false, 112, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Power spring"},
|
||||
{"lvfal1", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Rumble"},
|
||||
{"pscree", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "SCREE!"},
|
||||
{"iceb", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Ice crack"},
|
||||
{"shattr", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Shattering"},
|
||||
{"antiri", true, 255, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Depletion"},
|
||||
|
||||
// Menu, interface
|
||||
{"chchng", false, 120, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Score"},
|
||||
|
@ -233,6 +237,9 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"wepchg", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Weapon change"}, // Weapon switch is identical to menu for now
|
||||
{"wtrdng", true, 212, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Aquaphobia"}, // make sure you can hear the DING DING! Tails 03-08-2000
|
||||
{"zelda", false, 120, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Discovery"},
|
||||
{"adderr", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Error"},
|
||||
{"notadd", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Reject"},
|
||||
{"addfil", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Accept"},
|
||||
|
||||
// NiGHTS
|
||||
{"ideya", false, 127, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Success"},
|
||||
|
@ -427,24 +434,9 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"s25e", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s25f", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s260", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s261", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s262", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s263", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s264", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s265", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s266", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s267", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s268", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s269", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26a", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26b", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26c", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26d", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26e", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s26f", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
{"s270", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
|
||||
|
||||
// S3&K sounds
|
||||
{"s3k2b", true, 120, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Got Emerald"}, // Got Emerald!
|
||||
{"s3k33", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Sparkle"}, // stereo in original game, identical to latter
|
||||
{"s3k34", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Sparkle"}, // mono in original game, identical to previous
|
||||
{"s3k35", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Hurt"},
|
||||
|
@ -566,6 +558,21 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"s3ka9", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Aquaphobia"},
|
||||
{"s3kaa", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Bumper"},
|
||||
{"s3kab", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab1", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab2", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab3", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab4", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab5", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab6", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab7", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab8", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kab9", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kaba", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kabb", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kabc", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kabd", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kabe", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kabf", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Spindash"},
|
||||
{"s3kac", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Got Continue"},
|
||||
{"s3kad", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "GO!"},
|
||||
{"s3kae", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Pinball flipper"},
|
||||
|
@ -604,7 +611,8 @@ sfxinfo_t S_sfx[NUMSFX] =
|
|||
{"s3kc5l", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Revving up"}, // ditto
|
||||
{"s3kc6s", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Orbiting"},
|
||||
{"s3kc6l", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Orbiting"}, // ditto
|
||||
{"s3kc7", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Aiming"},
|
||||
{"s3kc7s", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Aiming"},
|
||||
{"s3kc7l", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Aiming"}, // ditto
|
||||
{"s3kc8s", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Sliding"},
|
||||
{"s3kc8l", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Sliding"}, // ditto
|
||||
{"s3kc9s", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Swinging"},
|
||||
|
|
42
src/sounds.h
42
src/sounds.h
|
@ -236,6 +236,7 @@ typedef enum
|
|||
sfx_shield,
|
||||
sfx_wirlsg,
|
||||
sfx_forcsg,
|
||||
sfx_frcssg,
|
||||
sfx_elemsg,
|
||||
sfx_armasg,
|
||||
sfx_attrsg,
|
||||
|
@ -269,6 +270,9 @@ typedef enum
|
|||
sfx_sprong,
|
||||
sfx_lvfal1,
|
||||
sfx_pscree,
|
||||
sfx_iceb,
|
||||
sfx_shattr,
|
||||
sfx_antiri,
|
||||
|
||||
// Menu, interface
|
||||
sfx_chchng,
|
||||
|
@ -282,6 +286,9 @@ typedef enum
|
|||
sfx_wepchg,
|
||||
sfx_wtrdng,
|
||||
sfx_zelda,
|
||||
sfx_adderr,
|
||||
sfx_notadd,
|
||||
sfx_addfil,
|
||||
|
||||
// NiGHTS
|
||||
sfx_ideya,
|
||||
|
@ -476,24 +483,9 @@ typedef enum
|
|||
sfx_s25e,
|
||||
sfx_s25f,
|
||||
sfx_s260,
|
||||
sfx_s261,
|
||||
sfx_s262,
|
||||
sfx_s263,
|
||||
sfx_s264,
|
||||
sfx_s265,
|
||||
sfx_s266,
|
||||
sfx_s267,
|
||||
sfx_s268,
|
||||
sfx_s269,
|
||||
sfx_s26a,
|
||||
sfx_s26b,
|
||||
sfx_s26c,
|
||||
sfx_s26d,
|
||||
sfx_s26e,
|
||||
sfx_s26f,
|
||||
sfx_s270,
|
||||
|
||||
// S3&K sounds
|
||||
sfx_s3k2b,
|
||||
sfx_s3k33,
|
||||
sfx_s3k34,
|
||||
sfx_s3k35,
|
||||
|
@ -615,6 +607,21 @@ typedef enum
|
|||
sfx_s3ka9,
|
||||
sfx_s3kaa,
|
||||
sfx_s3kab,
|
||||
sfx_s3kab1,
|
||||
sfx_s3kab2,
|
||||
sfx_s3kab3,
|
||||
sfx_s3kab4,
|
||||
sfx_s3kab5,
|
||||
sfx_s3kab6,
|
||||
sfx_s3kab7,
|
||||
sfx_s3kab8,
|
||||
sfx_s3kab9,
|
||||
sfx_s3kaba,
|
||||
sfx_s3kabb,
|
||||
sfx_s3kabc,
|
||||
sfx_s3kabd,
|
||||
sfx_s3kabe,
|
||||
sfx_s3kabf,
|
||||
sfx_s3kac,
|
||||
sfx_s3kad,
|
||||
sfx_s3kae,
|
||||
|
@ -653,7 +660,8 @@ typedef enum
|
|||
sfx_s3kc5l,
|
||||
sfx_s3kc6s,
|
||||
sfx_s3kc6l,
|
||||
sfx_s3kc7,
|
||||
sfx_s3kc7s,
|
||||
sfx_s3kc7l,
|
||||
sfx_s3kc8s,
|
||||
sfx_s3kc8l,
|
||||
sfx_s3kc9s,
|
||||
|
|
165
src/st_stuff.c
165
src/st_stuff.c
|
@ -694,7 +694,7 @@ static void ST_drawTime(void)
|
|||
else
|
||||
{
|
||||
// Counting down the hidetime?
|
||||
if ((gametyperules & GTR_HIDETIME) && (stplyr->realtime <= (hidetime*TICRATE)))
|
||||
if ((gametyperules & GTR_STARTCOUNTDOWN) && (stplyr->realtime <= (hidetime*TICRATE)))
|
||||
{
|
||||
tics = (hidetime*TICRATE - stplyr->realtime);
|
||||
if (tics < 3*TICRATE)
|
||||
|
@ -705,7 +705,7 @@ static void ST_drawTime(void)
|
|||
else
|
||||
{
|
||||
// Hidetime finish!
|
||||
if ((gametyperules & GTR_HIDETIME) && (stplyr->realtime < ((hidetime+1)*TICRATE)))
|
||||
if ((gametyperules & GTR_STARTCOUNTDOWN) && (stplyr->realtime < ((hidetime+1)*TICRATE)))
|
||||
ST_drawRaceNum(hidetime*TICRATE - stplyr->realtime);
|
||||
|
||||
// Time limit?
|
||||
|
@ -723,7 +723,7 @@ static void ST_drawTime(void)
|
|||
downwards = true;
|
||||
}
|
||||
// Post-hidetime normal.
|
||||
else if (gametyperules & GTR_TAG)
|
||||
else if (gametyperules & GTR_STARTCOUNTDOWN)
|
||||
tics = stplyr->realtime - hidetime*TICRATE;
|
||||
// "Shadow! What are you doing? Hurry and get back here
|
||||
// right now before the island blows up with you on it!"
|
||||
|
@ -845,69 +845,13 @@ static void ST_drawLivesArea(void)
|
|||
hudinfo[HUD_LIVES].f|V_PERPLAYER|V_HUDTRANS, faceprefix[stplyr->skin], colormap);
|
||||
}
|
||||
|
||||
// Lives number
|
||||
// Metal Sonic recording
|
||||
if (metalrecording)
|
||||
{
|
||||
if (((2*leveltime)/TICRATE) & 1)
|
||||
V_DrawRightAlignedString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y+8,
|
||||
hudinfo[HUD_LIVES].f|V_PERPLAYER|V_REDMAP|V_HUDTRANS, "REC");
|
||||
}
|
||||
else if (G_GametypeUsesLives() || gametype == GT_RACE)
|
||||
{
|
||||
// x
|
||||
V_DrawScaledPatch(hudinfo[HUD_LIVES].x+22, hudinfo[HUD_LIVES].y+10,
|
||||
hudinfo[HUD_LIVES].f|V_PERPLAYER|V_HUDTRANS, stlivex);
|
||||
|
||||
// lives number
|
||||
if (gametype == GT_RACE)
|
||||
{
|
||||
livescount = INFLIVES;
|
||||
notgreyedout = true;
|
||||
}
|
||||
else if ((netgame || multiplayer) && gametype == GT_COOP && cv_cooplives.value == 3)
|
||||
{
|
||||
INT32 i;
|
||||
livescount = 0;
|
||||
notgreyedout = (stplyr->lives > 0);
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
|
||||
if (players[i].lives < 1)
|
||||
continue;
|
||||
|
||||
if (players[i].lives > 1)
|
||||
notgreyedout = true;
|
||||
|
||||
if (players[i].lives == INFLIVES)
|
||||
{
|
||||
livescount = INFLIVES;
|
||||
break;
|
||||
}
|
||||
else if (livescount < 99)
|
||||
livescount += (players[i].lives);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
livescount = (((netgame || multiplayer) && gametype == GT_COOP && cv_cooplives.value == 0) ? INFLIVES : stplyr->lives);
|
||||
notgreyedout = true;
|
||||
}
|
||||
|
||||
if (livescount == INFLIVES)
|
||||
V_DrawCharacter(hudinfo[HUD_LIVES].x+50, hudinfo[HUD_LIVES].y+8,
|
||||
'\x16' | 0x80 | hudinfo[HUD_LIVES].f|V_PERPLAYER|V_HUDTRANS, false);
|
||||
else
|
||||
{
|
||||
if (stplyr->playerstate == PST_DEAD && !(stplyr->spectator) && (livescount || stplyr->deadtimer < (TICRATE<<1)))
|
||||
livescount++;
|
||||
if (livescount > 99)
|
||||
livescount = 99;
|
||||
V_DrawRightAlignedString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y+8,
|
||||
hudinfo[HUD_LIVES].f|V_PERPLAYER|(notgreyedout ? V_HUDTRANS : V_HUDTRANSHALF), va("%d",livescount));
|
||||
}
|
||||
}
|
||||
// Spectator
|
||||
else if (stplyr->spectator)
|
||||
v_colmap = V_GRAYMAP;
|
||||
|
@ -934,11 +878,89 @@ static void ST_drawLivesArea(void)
|
|||
v_colmap = V_BLUEMAP;
|
||||
}
|
||||
}
|
||||
// Lives number
|
||||
else
|
||||
{
|
||||
boolean candrawlives = true;
|
||||
|
||||
// Co-op and Competition, normal life counter
|
||||
if (G_GametypeUsesLives())
|
||||
{
|
||||
// Handle cooplives here
|
||||
if ((netgame || multiplayer) && G_GametypeUsesCoopLives() && cv_cooplives.value == 3)
|
||||
{
|
||||
INT32 i;
|
||||
livescount = 0;
|
||||
notgreyedout = (stplyr->lives > 0);
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
|
||||
if (players[i].lives < 1)
|
||||
continue;
|
||||
|
||||
if (players[i].lives > 1)
|
||||
notgreyedout = true;
|
||||
|
||||
if (players[i].lives == INFLIVES)
|
||||
{
|
||||
livescount = INFLIVES;
|
||||
break;
|
||||
}
|
||||
else if (livescount < 99)
|
||||
livescount += (players[i].lives);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
livescount = (((netgame || multiplayer) && G_GametypeUsesCoopLives() && cv_cooplives.value == 0) ? INFLIVES : stplyr->lives);
|
||||
notgreyedout = true;
|
||||
}
|
||||
}
|
||||
// Infinity symbol (Race)
|
||||
else if (G_PlatformGametype() && !(gametyperules & GTR_LIVES))
|
||||
{
|
||||
livescount = INFLIVES;
|
||||
notgreyedout = true;
|
||||
}
|
||||
// Otherwise nothing, sorry.
|
||||
// Special Stages keep not showing lives,
|
||||
// as G_GametypeUsesLives() returns false in
|
||||
// Special Stages, and the infinity symbol
|
||||
// cannot show up because Special Stages
|
||||
// still have the GTR_LIVES gametype rule
|
||||
// by default.
|
||||
else
|
||||
candrawlives = false;
|
||||
|
||||
// Draw the lives counter here.
|
||||
if (candrawlives)
|
||||
{
|
||||
// x
|
||||
V_DrawScaledPatch(hudinfo[HUD_LIVES].x+22, hudinfo[HUD_LIVES].y+10, hudinfo[HUD_LIVES].f|V_PERPLAYER|V_HUDTRANS, stlivex);
|
||||
if (livescount == INFLIVES)
|
||||
V_DrawCharacter(hudinfo[HUD_LIVES].x+50, hudinfo[HUD_LIVES].y+8,
|
||||
'\x16' | 0x80 | hudinfo[HUD_LIVES].f|V_PERPLAYER|V_HUDTRANS, false);
|
||||
else
|
||||
{
|
||||
if (stplyr->playerstate == PST_DEAD && !(stplyr->spectator) && (livescount || stplyr->deadtimer < (TICRATE<<1)))
|
||||
livescount++;
|
||||
if (livescount > 99)
|
||||
livescount = 99;
|
||||
V_DrawRightAlignedString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y+8,
|
||||
hudinfo[HUD_LIVES].f|V_PERPLAYER|(notgreyedout ? V_HUDTRANS : V_HUDTRANSHALF), va("%d",livescount));
|
||||
}
|
||||
}
|
||||
#undef ST_drawLivesX
|
||||
}
|
||||
|
||||
// name
|
||||
v_colmap |= (V_HUDTRANS|hudinfo[HUD_LIVES].f|V_PERPLAYER);
|
||||
if (strlen(skins[stplyr->skin].hudname) <= 5)
|
||||
V_DrawRightAlignedString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y, v_colmap, skins[stplyr->skin].hudname);
|
||||
else if (V_StringWidth(skins[stplyr->skin].hudname, v_colmap) <= 48)
|
||||
V_DrawString(hudinfo[HUD_LIVES].x+18, hudinfo[HUD_LIVES].y, v_colmap, skins[stplyr->skin].hudname);
|
||||
else if (V_ThinStringWidth(skins[stplyr->skin].hudname, v_colmap) <= 40)
|
||||
V_DrawRightAlignedThinString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y, v_colmap, skins[stplyr->skin].hudname);
|
||||
else
|
||||
|
@ -1157,10 +1179,20 @@ static void ST_drawInput(void)
|
|||
"AUTOBRAKE");
|
||||
y -= 8;
|
||||
}
|
||||
if (stplyr->pflags & PF_ANALOGMODE)
|
||||
switch (P_ControlStyle(stplyr))
|
||||
{
|
||||
case CS_LMAOGALOG:
|
||||
V_DrawThinString(x, y, hudinfo[HUD_LIVES].f, "ANALOG");
|
||||
y -= 8;
|
||||
break;
|
||||
|
||||
case CS_SIMPLE:
|
||||
V_DrawThinString(x, y, hudinfo[HUD_LIVES].f, "SIMPLE");
|
||||
y -= 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!demosynced) // should always be last, so it doesn't push anything else around
|
||||
|
@ -2176,7 +2208,7 @@ static void ST_drawTextHUD(void)
|
|||
|
||||
#define textHUDdraw(str) \
|
||||
{\
|
||||
V_DrawThinString(16, y, V_PERPLAYER|V_HUDTRANS|V_SNAPTOLEFT|V_SNAPTOBOTTOM, str);\
|
||||
V_DrawThinString(16, y, V_PERPLAYER|V_HUDTRANS|V_SNAPTOLEFT|V_SNAPTOTOP, str);\
|
||||
y += 8;\
|
||||
}
|
||||
|
||||
|
@ -2202,7 +2234,7 @@ static void ST_drawTextHUD(void)
|
|||
donef12 = true;
|
||||
}
|
||||
}
|
||||
else if (!G_PlatformGametype() && stplyr->playerstate == PST_DEAD && stplyr->lives) // Death overrides spectator text.
|
||||
else if ((gametyperules & GTR_RESPAWNDELAY) && stplyr->playerstate == PST_DEAD && stplyr->lives) // Death overrides spectator text.
|
||||
{
|
||||
INT32 respawntime = cv_respawntime.value - stplyr->deadtimer/TICRATE;
|
||||
|
||||
|
@ -2226,7 +2258,7 @@ static void ST_drawTextHUD(void)
|
|||
textHUDdraw(M_GetText("\x82""Wait for the stage to end..."))
|
||||
else if (G_PlatformGametype())
|
||||
{
|
||||
if (gametype == GT_COOP)
|
||||
if (G_GametypeUsesCoopLives())
|
||||
{
|
||||
if (stplyr->lives <= 0
|
||||
&& cv_cooplives.value == 2
|
||||
|
@ -2637,7 +2669,7 @@ static void ST_overlayDrawer(void)
|
|||
INT32 i = MAXPLAYERS;
|
||||
INT32 deadtimer = stplyr->spectator ? TICRATE : (stplyr->deadtimer-(TICRATE<<1));
|
||||
|
||||
if ((gametype == GT_COOP)
|
||||
if (G_GametypeUsesCoopLives()
|
||||
&& (netgame || multiplayer)
|
||||
&& (cv_cooplives.value != 1))
|
||||
{
|
||||
|
@ -2766,6 +2798,9 @@ static void ST_overlayDrawer(void)
|
|||
|
||||
void ST_Drawer(void)
|
||||
{
|
||||
if (needpatchrecache)
|
||||
R_ReloadHUDGraphics();
|
||||
|
||||
#ifdef SEENAMES
|
||||
if (cv_seenames.value && cv_allowseenames.value && displayplayer == consoleplayer && seenplayer && seenplayer->mo)
|
||||
{
|
||||
|
|
|
@ -1045,13 +1045,13 @@ void V_DrawContinueIcon(INT32 x, INT32 y, INT32 flags, INT32 skinnum, UINT8 skin
|
|||
{
|
||||
spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
|
||||
spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CONTINUE];
|
||||
patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
|
||||
patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
|
||||
const UINT8 *colormap = R_GetTranslationColormap(skinnum, skincolor, GTC_CACHE);
|
||||
|
||||
V_DrawMappedPatch(x, y, flags, patch, colormap);
|
||||
}
|
||||
else
|
||||
V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_CACHE));
|
||||
V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_PATCH));
|
||||
}
|
||||
|
||||
//
|
||||
|
|
|
@ -64,6 +64,7 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue);
|
|||
|
||||
// Retrieve the ARGB value from a palette color index
|
||||
#define V_GetColor(color) (pLocalPalette[color&0xFF])
|
||||
#define V_GetMasterColor(color) (pMasterPalette[color&0xFF])
|
||||
|
||||
// Bottom 8 bits are used for parameter (screen or character)
|
||||
#define V_PARAMMASK 0x000000FF
|
||||
|
|
22
src/w_wad.c
22
src/w_wad.c
|
@ -55,6 +55,7 @@
|
|||
#include "dehacked.h"
|
||||
#include "d_clisrv.h"
|
||||
#include "r_defs.h"
|
||||
#include "r_data.h"
|
||||
#include "i_system.h"
|
||||
#include "md5.h"
|
||||
#include "lua_script.h"
|
||||
|
@ -1375,7 +1376,6 @@ void *W_CacheLumpNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
|||
|
||||
void *W_CacheLumpNum(lumpnum_t lumpnum, INT32 tag)
|
||||
{
|
||||
|
||||
return W_CacheLumpNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
|
||||
}
|
||||
|
||||
|
@ -1465,6 +1465,21 @@ boolean W_IsPatchCached(lumpnum_t lumpnum, void *ptr)
|
|||
return W_IsPatchCachedPWAD(WADFILENUM(lumpnum),LUMPNUM(lumpnum), ptr);
|
||||
}
|
||||
|
||||
void W_FlushCachedPatches(void)
|
||||
{
|
||||
if (needpatchflush)
|
||||
{
|
||||
Z_FreeTag(PU_CACHE);
|
||||
Z_FreeTag(PU_PATCH);
|
||||
Z_FreeTag(PU_HUDGFX);
|
||||
Z_FreeTag(PU_HWRPATCHINFO);
|
||||
Z_FreeTag(PU_HWRMODELTEXTURE);
|
||||
Z_FreeTag(PU_HWRCACHE);
|
||||
Z_FreeTags(PU_HWRCACHE_UNLOCKED, PU_HWRPATCHINFO_UNLOCKED);
|
||||
}
|
||||
needpatchflush = false;
|
||||
}
|
||||
|
||||
// ==========================================================================
|
||||
// W_CacheLumpName
|
||||
// ==========================================================================
|
||||
|
@ -1494,6 +1509,9 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
|||
GLPatch_t *grPatch;
|
||||
#endif
|
||||
|
||||
if (needpatchflush)
|
||||
W_FlushCachedPatches();
|
||||
|
||||
if (!TestValidLump(wad, lump))
|
||||
return NULL;
|
||||
|
||||
|
@ -1522,7 +1540,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
|||
if (R_IsLumpPNG((UINT8 *)lumpdata, len))
|
||||
{
|
||||
size_t newlen;
|
||||
srcdata = R_PNGToPatch((UINT8 *)lumpdata, len, &newlen, true);
|
||||
srcdata = R_PNGToPatch((UINT8 *)lumpdata, len, &newlen);
|
||||
ptr = Z_Realloc(ptr, newlen, tag, &lumpcache[lump]);
|
||||
M_Memcpy(ptr, srcdata, newlen);
|
||||
Z_Free(srcdata);
|
||||
|
|
|
@ -196,6 +196,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag); // return a patch
|
|||
void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag); // return a patch_t
|
||||
|
||||
void W_UnlockCachedPatch(void *patch);
|
||||
void W_FlushCachedPatches(void);
|
||||
|
||||
void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
|
||||
|
||||
|
|
|
@ -1354,6 +1354,8 @@ getBufferedData:
|
|||
}
|
||||
}
|
||||
|
||||
void I_UpdateMouseGrab(void) {}
|
||||
|
||||
// ===========================================================================================
|
||||
// DIRECT INPUT JOYSTICK
|
||||
// ===========================================================================================
|
||||
|
|
|
@ -239,6 +239,11 @@ void I_StartupGraphics(void)
|
|||
if (!dedicated) graphics_started = true;
|
||||
}
|
||||
|
||||
void I_StartupHardwareGraphics(void)
|
||||
{
|
||||
// oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo y
|
||||
}
|
||||
|
||||
// ------------------
|
||||
// I_ShutdownGraphics
|
||||
// Close the screen, restore previous video mode.
|
||||
|
@ -946,6 +951,11 @@ INT32 VID_SetMode(INT32 modenum)
|
|||
return 1;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void)
|
||||
{
|
||||
// ..............
|
||||
}
|
||||
|
||||
// ========================================================================
|
||||
// Free the video buffer of the last video mode,
|
||||
// allocate a new buffer for the video mode to set.
|
||||
|
|
117
src/y_inter.c
117
src/y_inter.c
|
@ -161,6 +161,7 @@ typedef struct
|
|||
|
||||
boolean usebuffer = false;
|
||||
static boolean useinterpic;
|
||||
static boolean safetorender = true;
|
||||
static y_buffer_t *y_buffer;
|
||||
|
||||
static INT32 intertic;
|
||||
|
@ -177,6 +178,7 @@ static void Y_CalculateCompetitionWinners(void);
|
|||
static void Y_CalculateTimeRaceWinners(void);
|
||||
static void Y_CalculateMatchWinners(void);
|
||||
static void Y_UnloadData(void);
|
||||
static void Y_CleanupData(void);
|
||||
|
||||
// Stuff copy+pasted from st_stuff.c
|
||||
#define ST_DrawNumFromHud(h,n) V_DrawTallNum(hudinfo[h].x, hudinfo[h].y, hudinfo[h].f, n)
|
||||
|
@ -335,8 +337,19 @@ void Y_IntermissionDrawer(void)
|
|||
}
|
||||
|
||||
if (!usebuffer)
|
||||
// Lactozilla: Renderer switching
|
||||
if (needpatchrecache)
|
||||
{
|
||||
Y_CleanupData();
|
||||
safetorender = false;
|
||||
}
|
||||
|
||||
if (!usebuffer || !safetorender)
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
|
||||
|
||||
if (!safetorender)
|
||||
goto dontdrawbg;
|
||||
|
||||
if (useinterpic)
|
||||
V_DrawScaledPatch(0, 0, 0, interpic);
|
||||
else if (!usetile)
|
||||
|
@ -377,6 +390,7 @@ void Y_IntermissionDrawer(void)
|
|||
goto skiptallydrawer;
|
||||
#endif
|
||||
|
||||
dontdrawbg:
|
||||
if (intertype == int_coop)
|
||||
{
|
||||
INT32 bonusy;
|
||||
|
@ -426,14 +440,17 @@ void Y_IntermissionDrawer(void)
|
|||
|
||||
bonusy = 150;
|
||||
// Total
|
||||
V_DrawScaledPatch(152, bonusy, 0, data.coop.ptotal);
|
||||
V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.total);
|
||||
if (safetorender)
|
||||
{
|
||||
V_DrawScaledPatch(152, bonusy, 0, data.coop.ptotal);
|
||||
V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.total);
|
||||
}
|
||||
bonusy -= (3*SHORT(tallnum[0]->height)/2) + 1;
|
||||
|
||||
// Draw bonuses
|
||||
for (i = 3; i >= 0; --i)
|
||||
{
|
||||
if (data.coop.bonuses[i].display)
|
||||
if (data.coop.bonuses[i].display && safetorender)
|
||||
{
|
||||
V_DrawScaledPatch(152, bonusy, 0, data.coop.bonuspatches[i]);
|
||||
V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.bonuses[i].points);
|
||||
|
@ -662,7 +679,8 @@ void Y_IntermissionDrawer(void)
|
|||
char strtime[10];
|
||||
|
||||
// draw the header
|
||||
V_DrawScaledPatch(112, 2, 0, data.match.result);
|
||||
if (safetorender)
|
||||
V_DrawScaledPatch(112, 2, 0, data.match.result);
|
||||
|
||||
// draw the level name
|
||||
V_DrawCenteredString(BASEVIDWIDTH/2, 20, 0, data.match.levelstring);
|
||||
|
@ -1194,6 +1212,8 @@ void Y_StartIntermission(void)
|
|||
I_Error("endtic is dirty");
|
||||
#endif
|
||||
|
||||
safetorender = true;
|
||||
|
||||
if (!multiplayer)
|
||||
{
|
||||
timer = 0;
|
||||
|
@ -1249,20 +1269,20 @@ void Y_StartIntermission(void)
|
|||
data.coop.tics = players[consoleplayer].realtime;
|
||||
|
||||
for (i = 0; i < 4; ++i)
|
||||
data.coop.bonuspatches[i] = W_CachePatchName(data.coop.bonuses[i].patch, PU_STATIC);
|
||||
data.coop.ptotal = W_CachePatchName("YB_TOTAL", PU_STATIC);
|
||||
data.coop.bonuspatches[i] = W_CachePatchName(data.coop.bonuses[i].patch, PU_PATCH);
|
||||
data.coop.ptotal = W_CachePatchName("YB_TOTAL", PU_PATCH);
|
||||
|
||||
// get act number
|
||||
data.coop.actnum = mapheaderinfo[gamemap-1]->actnum;
|
||||
|
||||
// get background patches
|
||||
widebgpatch = W_CachePatchName("INTERSCW", PU_STATIC);
|
||||
bgpatch = W_CachePatchName("INTERSCR", PU_STATIC);
|
||||
widebgpatch = W_CachePatchName("INTERSCW", PU_PATCH);
|
||||
bgpatch = W_CachePatchName("INTERSCR", PU_PATCH);
|
||||
|
||||
// grab an interscreen if appropriate
|
||||
if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
|
||||
{
|
||||
interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_STATIC);
|
||||
interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
|
||||
useinterpic = true;
|
||||
usebuffer = false;
|
||||
}
|
||||
|
@ -1320,18 +1340,18 @@ void Y_StartIntermission(void)
|
|||
Y_AwardSpecialStageBonus();
|
||||
|
||||
for (i = 0; i < 2; ++i)
|
||||
data.spec.bonuspatches[i] = W_CachePatchName(data.spec.bonuses[i].patch, PU_STATIC);
|
||||
data.spec.bonuspatches[i] = W_CachePatchName(data.spec.bonuses[i].patch, PU_PATCH);
|
||||
|
||||
data.spec.pscore = W_CachePatchName("YB_SCORE", PU_STATIC);
|
||||
data.spec.pcontinues = W_CachePatchName("YB_CONTI", PU_STATIC);
|
||||
data.spec.pscore = W_CachePatchName("YB_SCORE", PU_PATCH);
|
||||
data.spec.pcontinues = W_CachePatchName("YB_CONTI", PU_PATCH);
|
||||
|
||||
// get background tile
|
||||
bgtile = W_CachePatchName("SPECTILE", PU_STATIC);
|
||||
bgtile = W_CachePatchName("SPECTILE", PU_PATCH);
|
||||
|
||||
// grab an interscreen if appropriate
|
||||
if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
|
||||
{
|
||||
interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_STATIC);
|
||||
interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
|
||||
useinterpic = true;
|
||||
}
|
||||
else
|
||||
|
@ -1343,14 +1363,14 @@ void Y_StartIntermission(void)
|
|||
// get special stage specific patches
|
||||
/* if (!stagefailed && ALL7EMERALDS(emeralds))
|
||||
{
|
||||
data.spec.cemerald = W_CachePatchName("GOTEMALL", PU_STATIC);
|
||||
data.spec.cemerald = W_CachePatchName("GOTEMALL", PU_PATCH);
|
||||
data.spec.headx = 70;
|
||||
data.spec.nowsuper = players[consoleplayer].skin
|
||||
? NULL : W_CachePatchName("NOWSUPER", PU_STATIC);
|
||||
? NULL : W_CachePatchName("NOWSUPER", PU_PATCH);
|
||||
}
|
||||
else
|
||||
{
|
||||
data.spec.cemerald = W_CachePatchName("CEMERALD", PU_STATIC);
|
||||
data.spec.cemerald = W_CachePatchName("CEMERALD", PU_PATCH);
|
||||
data.spec.headx = 48;
|
||||
data.spec.nowsuper = NULL;
|
||||
} */
|
||||
|
@ -1428,9 +1448,9 @@ void Y_StartIntermission(void)
|
|||
|
||||
// get RESULT header
|
||||
data.match.result =
|
||||
W_CachePatchName("RESULT", PU_STATIC);
|
||||
W_CachePatchName("RESULT", PU_PATCH);
|
||||
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
|
||||
usetile = true;
|
||||
useinterpic = false;
|
||||
break;
|
||||
|
@ -1456,9 +1476,9 @@ void Y_StartIntermission(void)
|
|||
data.match.levelstring[sizeof data.match.levelstring - 1] = '\0';
|
||||
|
||||
// get RESULT header
|
||||
data.match.result = W_CachePatchName("RESULT", PU_STATIC);
|
||||
data.match.result = W_CachePatchName("RESULT", PU_PATCH);
|
||||
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
|
||||
usetile = true;
|
||||
useinterpic = false;
|
||||
break;
|
||||
|
@ -1495,7 +1515,7 @@ void Y_StartIntermission(void)
|
|||
data.match.blueflag = bmatcico;
|
||||
}
|
||||
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
|
||||
usetile = true;
|
||||
useinterpic = false;
|
||||
break;
|
||||
|
@ -1521,7 +1541,7 @@ void Y_StartIntermission(void)
|
|||
data.competition.levelstring[sizeof data.competition.levelstring - 1] = '\0';
|
||||
|
||||
// get background tile
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
|
||||
bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
|
||||
usetile = true;
|
||||
useinterpic = false;
|
||||
break;
|
||||
|
@ -1977,7 +1997,7 @@ static void Y_AwardCoopBonuses(void)
|
|||
|
||||
if (i == consoleplayer)
|
||||
{
|
||||
data.coop.gotlife = (((netgame || multiplayer) && gametype == GT_COOP && cv_cooplives.value == 0) ? 0 : ptlives);
|
||||
data.coop.gotlife = (((netgame || multiplayer) && G_GametypeUsesCoopLives() && cv_cooplives.value == 0) ? 0 : ptlives);
|
||||
M_Memcpy(&data.coop.bonuses, &localbonuses, sizeof(data.coop.bonuses));
|
||||
}
|
||||
}
|
||||
|
@ -2032,7 +2052,7 @@ static void Y_AwardSpecialStageBonus(void)
|
|||
|
||||
if (i == consoleplayer)
|
||||
{
|
||||
data.spec.gotlife = (((netgame || multiplayer) && gametype == GT_COOP && cv_cooplives.value == 0) ? 0 : ptlives);
|
||||
data.spec.gotlife = (((netgame || multiplayer) && G_GametypeUsesCoopLives() && cv_cooplives.value == 0) ? 0 : ptlives);
|
||||
M_Memcpy(&data.spec.bonuses, &localbonuses, sizeof(data.spec.bonuses));
|
||||
|
||||
// Continues related
|
||||
|
@ -2059,7 +2079,8 @@ void Y_EndIntermission(void)
|
|||
usebuffer = false;
|
||||
}
|
||||
|
||||
#define UNLOAD(x) Z_ChangeTag(x, PU_CACHE); x = NULL
|
||||
#define UNLOAD(x) if (x) {Z_ChangeTag(x, PU_CACHE);} x = NULL;
|
||||
#define CLEANUP(x) x = NULL;
|
||||
|
||||
//
|
||||
// Y_UnloadData
|
||||
|
@ -2110,5 +2131,47 @@ static void Y_UnloadData(void)
|
|||
//are not handled
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void Y_CleanupData(void)
|
||||
{
|
||||
// unload the background patches
|
||||
CLEANUP(bgpatch);
|
||||
CLEANUP(widebgpatch);
|
||||
CLEANUP(bgtile);
|
||||
CLEANUP(interpic);
|
||||
|
||||
switch (intertype)
|
||||
{
|
||||
case int_coop:
|
||||
// unload the coop and single player patches
|
||||
CLEANUP(data.coop.bonuspatches[3]);
|
||||
CLEANUP(data.coop.bonuspatches[2]);
|
||||
CLEANUP(data.coop.bonuspatches[1]);
|
||||
CLEANUP(data.coop.bonuspatches[0]);
|
||||
CLEANUP(data.coop.ptotal);
|
||||
break;
|
||||
case int_spec:
|
||||
// unload the special stage patches
|
||||
//CLEANUP(data.spec.cemerald);
|
||||
//CLEANUP(data.spec.nowsuper);
|
||||
CLEANUP(data.spec.bonuspatches[1]);
|
||||
CLEANUP(data.spec.bonuspatches[0]);
|
||||
CLEANUP(data.spec.pscore);
|
||||
CLEANUP(data.spec.pcontinues);
|
||||
break;
|
||||
case int_match:
|
||||
case int_race:
|
||||
CLEANUP(data.match.result);
|
||||
break;
|
||||
case int_ctf:
|
||||
CLEANUP(data.match.blueflag);
|
||||
CLEANUP(data.match.redflag);
|
||||
break;
|
||||
default:
|
||||
//without this default,
|
||||
//int_none, int_tag, int_chaos, and int_classicrace
|
||||
//are not handled
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
30
src/z_zone.c
30
src/z_zone.c
|
@ -27,6 +27,7 @@
|
|||
|
||||
#include "doomdef.h"
|
||||
#include "doomstat.h"
|
||||
#include "r_patch.h"
|
||||
#include "i_system.h" // I_GetFreeMem
|
||||
#include "i_video.h" // rendermode
|
||||
#include "z_zone.h"
|
||||
|
@ -497,6 +498,35 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
|
|||
// Utility functions
|
||||
// -----------------
|
||||
|
||||
// for renderer switching, free a bunch of stuff
|
||||
boolean needpatchflush = false;
|
||||
boolean needpatchrecache = false;
|
||||
|
||||
// flush all patches from memory
|
||||
// (also frees memory tagged with PU_CACHE)
|
||||
// (which are not necessarily patches but I don't care)
|
||||
void Z_FlushCachedPatches(void)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "Z_FlushCachedPatches()...\n");
|
||||
Z_FreeTag(PU_CACHE);
|
||||
Z_FreeTag(PU_PATCH);
|
||||
Z_FreeTag(PU_HUDGFX);
|
||||
Z_FreeTag(PU_HWRPATCHINFO);
|
||||
Z_FreeTag(PU_HWRMODELTEXTURE);
|
||||
Z_FreeTag(PU_HWRCACHE);
|
||||
Z_FreeTag(PU_HWRCACHE_UNLOCKED);
|
||||
Z_FreeTag(PU_HWRPATCHINFO_UNLOCKED);
|
||||
}
|
||||
|
||||
// happens before a renderer switch
|
||||
void Z_PreparePatchFlush(void)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "Z_PreparePatchFlush()...\n");
|
||||
#ifdef ROTSPRITE
|
||||
R_FreeAllRotSprite();
|
||||
#endif
|
||||
}
|
||||
|
||||
// starting value of nextcleanup
|
||||
#define CLEANUPCOUNT 2000
|
||||
|
||||
|
|
|
@ -43,6 +43,7 @@ enum
|
|||
PU_SOUND = 11, // static while playing
|
||||
PU_MUSIC = 12, // static while playing
|
||||
PU_HUDGFX = 13, // static until WAD added
|
||||
PU_PATCH = 14, // static until renderer change
|
||||
|
||||
PU_HWRPATCHINFO = 21, // Hardware GLPatch_t struct for OpenGL texture cache
|
||||
PU_HWRPATCHCOLMIPMAP = 22, // Hardware GLMipmap_t struct colormap variation of patch
|
||||
|
@ -142,4 +143,10 @@ size_t Z_TagsUsage(INT32 lowtag, INT32 hightag);
|
|||
char *Z_StrDup(const char *in);
|
||||
#define Z_Unlock(p) (void)p // TODO: remove this now that NDS code has been removed
|
||||
|
||||
// For renderer switching
|
||||
extern boolean needpatchflush;
|
||||
extern boolean needpatchrecache;
|
||||
void Z_FlushCachedPatches(void);
|
||||
void Z_PreparePatchFlush(void);
|
||||
|
||||
#endif
|
||||
|
|
Loading…
Reference in a new issue