Merge branch 'Saturn-Next' into retrySOCK
This commit is contained in:
commit
7855b2ed95
37 files changed
+986
-533
No files matched your search
+53
-39
@@ -62,7 +62,7 @@ static boolean con_started = false; // console has been initialised
|
||||
static boolean con_forcepic = true; // at startup toggle console translucency when first off
|
||||
boolean con_recalc = false; // set true when screen size has changed
|
||||
|
||||
static tic_t con_tick; // console ticker for anim or blinking prompt cursor
|
||||
static tic_t con_tick; // console ticker for blinking prompt cursor
|
||||
// con_scrollup should use time (currenttime - lasttime)..
|
||||
|
||||
static boolean consoletoggle; // true when console key pushed, ticker will handle
|
||||
@@ -103,6 +103,7 @@ static void CON_InputInit(void);
|
||||
static void CON_RecalcSize(void);
|
||||
static void CON_ChangeHeight(void);
|
||||
|
||||
static void CONS_height_Change(void);
|
||||
static void CONS_hudlines_Change(void);
|
||||
static void CONS_backcolor_Change(void);
|
||||
|
||||
@@ -131,7 +132,7 @@ static CV_PossibleValue_t speed_cons_t[] = {{0, "MIN"}, {64, "MAX"}, {0, NULL}};
|
||||
static consvar_t cons_speed = {"con_speed", "8", CV_SAVE, speed_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// percentage of screen height to use for console
|
||||
static consvar_t cons_height = {"con_height", "50", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static consvar_t cons_height = {"con_height", "50", CV_CALL|CV_SAVE, CV_Unsigned, CONS_height_Change, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t backpic_cons_t[] = {{0, "translucent"}, {1, "picture"}, {0, NULL}};
|
||||
// whether to use console background picture, or translucent mode
|
||||
@@ -173,6 +174,18 @@ consvar_t cons_consoleprintinmenu = {"consoleprintinmenu", "Off", CV_SAVE, CV_On
|
||||
|
||||
static void CON_Print(char *msg);
|
||||
|
||||
// Change the console height on demand
|
||||
//
|
||||
static void CONS_height_Change(void)
|
||||
{
|
||||
Lock_state();
|
||||
|
||||
if (con_destlines > 0 && !con_startup) // If the console is open (as in, not using "bind")...
|
||||
CON_ChangeHeight(); // ...update its height now, not only when it's closed and re-opened
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
static void CONS_hudlines_Change(void)
|
||||
@@ -1637,53 +1650,54 @@ static void CON_DrawConsole(void)
|
||||
}
|
||||
|
||||
// draw console text lines from top to bottom
|
||||
if (con_curlines < minheight)
|
||||
return;
|
||||
|
||||
i = con_cy - con_scrollup;
|
||||
|
||||
// skip the last empty line due to the cursor being at the start of a new line
|
||||
i--;
|
||||
|
||||
i -= (con_curlines - minheight) / charheight;
|
||||
|
||||
if (rendermode == render_none) return;
|
||||
|
||||
for (y = (con_curlines-minheight) % charheight; y <= con_curlines-minheight; y += charheight, i++)
|
||||
if (con_curlines >= minheight)
|
||||
{
|
||||
INT32 x;
|
||||
size_t c;
|
||||
i = con_cy - con_scrollup;
|
||||
|
||||
p = (UINT8 *)&con_buffer[((i > 0 ? i : 0)%con_totallines)*con_width];
|
||||
// skip the last empty line due to the cursor being at the start of a new line
|
||||
i--;
|
||||
|
||||
for (c = 0, x = charwidth; c < con_width; c++, x += charwidth, p++)
|
||||
i -= (con_curlines - minheight) / charheight;
|
||||
|
||||
if (rendermode == render_none)
|
||||
return;
|
||||
|
||||
for (y = (con_curlines-minheight) % charheight; y <= con_curlines-minheight; y += charheight, i++)
|
||||
{
|
||||
while (*p & 0x80)
|
||||
INT32 x;
|
||||
size_t c;
|
||||
|
||||
p = (UINT8 *)&con_buffer[((i > 0 ? i : 0)%con_totallines)*con_width];
|
||||
|
||||
for (c = 0, x = charwidth; c < con_width; c++, x += charwidth, p++)
|
||||
{
|
||||
charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
|
||||
p++;
|
||||
c++;
|
||||
while (*p & 0x80)
|
||||
{
|
||||
charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
|
||||
p++;
|
||||
c++;
|
||||
}
|
||||
|
||||
if (c >= con_width)
|
||||
break;
|
||||
|
||||
int emotelen;
|
||||
emote_t *emote;
|
||||
|
||||
if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
|
||||
{
|
||||
M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
|
||||
p += emotelen-1;
|
||||
c += emotelen-1;
|
||||
continue;
|
||||
}
|
||||
V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
}
|
||||
|
||||
if (c >= con_width)
|
||||
break;
|
||||
|
||||
int emotelen;
|
||||
emote_t *emote;
|
||||
|
||||
if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
|
||||
{
|
||||
M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
|
||||
p += emotelen-1;
|
||||
c += emotelen-1;
|
||||
continue;
|
||||
}
|
||||
V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
}
|
||||
}
|
||||
|
||||
// draw prompt if enough place (not while game startup)
|
||||
if ((con_curlines == con_destlines) && (con_curlines >= minheight) && !con_startup)
|
||||
if ((con_curlines >= (minheight-charheight)) && !con_startup)
|
||||
CON_DrawInput();
|
||||
}
|
||||
|
||||
|
||||
+4
-1
@@ -3497,6 +3497,9 @@ void CL_RemovePlayer(INT32 playernum, INT32 reason)
|
||||
while ((doomcom->numslots > 1) && !playeringame[doomcom->numslots-1])
|
||||
doomcom->numslots--;
|
||||
|
||||
// Unmute slot if player was muted
|
||||
player_muted[playernum] = false;
|
||||
|
||||
// Reset the name
|
||||
sprintf(player_names[playernum], "Player %d", playernum+1);
|
||||
|
||||
@@ -4795,7 +4798,7 @@ void CL_RemoveSplitscreenPlayer(UINT8 p)
|
||||
// is there a game running
|
||||
boolean Playing(void)
|
||||
{
|
||||
return (server && serverrunning) || (client && cl_mode == CL_CONNECTED);
|
||||
return ((server && serverrunning) || (client && cl_mode == CL_CONNECTED));
|
||||
}
|
||||
|
||||
boolean SV_SpawnServer(void)
|
||||
|
||||
+10
-8
@@ -1353,7 +1353,7 @@ static void IdentifyVersion(void)
|
||||
//
|
||||
// search for maps
|
||||
//
|
||||
static void D_CheckMaps(boolean checkreplaced)
|
||||
static void D_CheckMapReplacements(boolean checkreplaced)
|
||||
{
|
||||
INT32 i;
|
||||
char *name;
|
||||
@@ -1829,17 +1829,19 @@ void D_SRB2Main(void)
|
||||
// conversion sometimes needs the palette
|
||||
V_ReloadPalette();
|
||||
|
||||
D_CheckMaps(false);
|
||||
D_CheckMapReplacements(false);
|
||||
|
||||
W_InitMultipleFiles(startuppwads, startuppwadcount, true);
|
||||
|
||||
// Only search for pwad maps if we actually have a pwad added
|
||||
if (startuppwadcount > 0)
|
||||
{
|
||||
D_CheckMaps(true);
|
||||
CONS_Printf("W_InitMultipleFiles(): Adding extra PWADs.\n");
|
||||
W_InitMultipleFiles(startuppwads, startuppwadcount, true);
|
||||
|
||||
// Only search for pwad maps if we actually have a pwad added
|
||||
D_CheckMapReplacements(true);
|
||||
|
||||
D_CleanFile(startuppwads, startuppwadcount);
|
||||
}
|
||||
|
||||
D_CleanFile(startuppwads, startuppwadcount);
|
||||
startuppwadcount = 0;
|
||||
|
||||
cht_Init();
|
||||
@@ -1926,7 +1928,7 @@ void D_SRB2Main(void)
|
||||
CONS_Printf("R_Init(): Init SRB2 refresh daemon.\n");
|
||||
R_Init();
|
||||
|
||||
#if SOUND==SOUND_DUMMY
|
||||
#if SOUND == SOUND_DUMMY
|
||||
sound_disabled = true;
|
||||
music_disabled = true;
|
||||
#else
|
||||
|
||||
+21
-3
@@ -150,6 +150,7 @@ static void Command_ListWADS_f(void);
|
||||
static void Command_LocateLump_f(void);
|
||||
static void Command_ListDoomednums_f(void);
|
||||
static void Command_ListUnusedSprites_f(void);
|
||||
static void Command_ListUnusedMapSlots_f(void);
|
||||
static void Command_RunSOC(void);
|
||||
static void Command_Pause(void);
|
||||
static void Command_Respawn(void);
|
||||
@@ -645,6 +646,7 @@ void D_RegisterServerCommands(void)
|
||||
COM_AddCommand("locatelump", Command_LocateLump_f);
|
||||
COM_AddCommand("listmapthings", Command_ListDoomednums_f);
|
||||
COM_AddCommand("listunusedsprites", Command_ListUnusedSprites_f);
|
||||
COM_AddCommand("listunusedmapslots", Command_ListUnusedMapSlots_f);
|
||||
|
||||
COM_AddCommand("runsoc", Command_RunSOC);
|
||||
COM_AddCommand("pause", Command_Pause);
|
||||
@@ -1548,8 +1550,8 @@ static void SendNameAndColor(UINT8 splitplayer)
|
||||
// TODO: make those cvars arrays
|
||||
consvar_t *playercolor, *playername, *playerskin;
|
||||
consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
|
||||
consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
|
||||
consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
|
||||
consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
|
||||
consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
|
||||
|
||||
playercolor = colorvars[splitplayer];
|
||||
playername = namevars[splitplayer];
|
||||
@@ -4591,6 +4593,23 @@ void Command_ListUnusedSprites_f(void)
|
||||
}
|
||||
}
|
||||
|
||||
void Command_ListUnusedMapSlots_f(void)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
CONS_Printf("\x82Printing map slot non-usage...\n");
|
||||
|
||||
for (i = 0; i < NUMMAPS; i++)
|
||||
{
|
||||
// is checking this enough?
|
||||
if (mapheaderinfo[i])
|
||||
continue;
|
||||
|
||||
CONS_Printf("%s\n", G_BuildMapName(i+1));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// =========================================================================
|
||||
// MISC. COMMANDS
|
||||
// =========================================================================
|
||||
@@ -5471,7 +5490,6 @@ static void Name_OnChange(void)
|
||||
}
|
||||
|
||||
SendNameAndColor(0);
|
||||
|
||||
}
|
||||
|
||||
static void Name2_OnChange(void)
|
||||
|
||||
+88
-49
@@ -337,12 +337,14 @@ static void readfreeslots(MYFILE *f)
|
||||
{
|
||||
if (used_spr[(i-SPR_FIRSTFREESLOT)/8] & (1<<(i%8)))
|
||||
{
|
||||
if (!sprnames[i][4] && memcmp(sprnames[i],word,4)==0)
|
||||
if (!sprnames[i][4] && memcmp(sprnames[i], word, 4) == 0)
|
||||
sprnames[i][4] = (char)f->wad;
|
||||
|
||||
continue; // Already allocated, next.
|
||||
}
|
||||
|
||||
// Found a free slot!
|
||||
strncpy(sprnames[i],word,4);
|
||||
strncpy(sprnames[i], word, 4);
|
||||
//sprnames[i][4] = 0;
|
||||
CONS_Printf("Sprite SPR_%s allocated.\n",word);
|
||||
|
||||
@@ -351,22 +353,26 @@ static void readfreeslots(MYFILE *f)
|
||||
used_spr[(i-SPR_FIRSTFREESLOT)/8] |= 1<<(i%8); // Okay, this sprite slot has been named now.
|
||||
break;
|
||||
}
|
||||
|
||||
if (i > SPR_LASTFREESLOT)
|
||||
I_Error("Out of Sprite Freeslots while allocating \"%s\"\nLoad less addons to fix this.", word);
|
||||
}
|
||||
else if (fastcmp(type, "S"))
|
||||
{
|
||||
for (i = 0; i < NUMSTATEFREESLOTS; i++)
|
||||
if (!FREE_STATES[i]) {
|
||||
CONS_Printf("State S_%s allocated.\n",word);
|
||||
{
|
||||
if (!FREE_STATES[i])
|
||||
{
|
||||
CONS_Printf("State S_%s allocated.\n", word);
|
||||
|
||||
LUA_InvalidateMathlibCache(va("S_%s", word));
|
||||
|
||||
FREE_STATES[i] = Z_Malloc(strlen(word)+1, PU_STATIC, NULL);
|
||||
strcpy(FREE_STATES[i],word);
|
||||
strcpy(FREE_STATES[i], word);
|
||||
freeslotusage[0][0]++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == NUMSTATEFREESLOTS)
|
||||
I_Error("Out of State Freeslots while allocating \"%s\"\nLoad less addons to fix this.", word);
|
||||
@@ -374,16 +380,19 @@ static void readfreeslots(MYFILE *f)
|
||||
else if (fastcmp(type, "MT"))
|
||||
{
|
||||
for (i = 0; i < NUMMOBJFREESLOTS; i++)
|
||||
if (!FREE_MOBJS[i]) {
|
||||
CONS_Printf("MobjType MT_%s allocated.\n",word);
|
||||
{
|
||||
if (!FREE_MOBJS[i])
|
||||
{
|
||||
CONS_Printf("MobjType MT_%s allocated.\n", word);
|
||||
|
||||
LUA_InvalidateMathlibCache(va("MT_%s", word));
|
||||
|
||||
FREE_MOBJS[i] = Z_Malloc(strlen(word)+1, PU_STATIC, NULL);
|
||||
strcpy(FREE_MOBJS[i],word);
|
||||
strcpy(FREE_MOBJS[i], word);
|
||||
freeslotusage[1][0]++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == NUMMOBJFREESLOTS)
|
||||
I_Error("Out of Mobj Freeslots while allocating \"%s\"\nLoad less addons to fix this.", word);
|
||||
@@ -426,8 +435,11 @@ static void readthing(MYFILE *f, INT32 num)
|
||||
strupr(word2);
|
||||
else
|
||||
break;
|
||||
if (word2[strlen(word2)-1] == '\n')
|
||||
word2[strlen(word2)-1] = '\0';
|
||||
|
||||
const size_t word2len = strlen(word2);
|
||||
|
||||
if (word2[word2len-1] == '\n')
|
||||
word2[word2len-1] = '\0';
|
||||
|
||||
if (fastcmp(word, "MAPTHINGNUM") || fastcmp(word, "DOOMEDNUM"))
|
||||
{
|
||||
@@ -734,14 +746,20 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
|
||||
{
|
||||
UINT16 tol = 0;
|
||||
tmp = strtok(word2,",");
|
||||
|
||||
do {
|
||||
for (i = 0; TYPEOFLEVEL[i].name; i++)
|
||||
{
|
||||
if (fastcmp(tmp, TYPEOFLEVEL[i].name))
|
||||
break;
|
||||
}
|
||||
|
||||
if (!TYPEOFLEVEL[i].name)
|
||||
deh_warning("Level header %d: unknown typeoflevel flag %s\n", num, tmp);
|
||||
|
||||
tol |= TYPEOFLEVEL[i].flag;
|
||||
} while((tmp = strtok(NULL,",")) != NULL);
|
||||
|
||||
mapheaderinfo[num-1]->typeoflevel = tol;
|
||||
}
|
||||
}
|
||||
@@ -1037,8 +1055,11 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
|
||||
else
|
||||
break;
|
||||
|
||||
if (word2[strlen(word2)-1] == '\n')
|
||||
word2[strlen(word2)-1] = '\0';
|
||||
const size_t word2len = strlen(word2);
|
||||
|
||||
if (word2[word2len-1] == '\n')
|
||||
word2[word2len-1] = '\0';
|
||||
|
||||
i = atoi(word2);
|
||||
usi = (UINT16)i;
|
||||
|
||||
@@ -1088,12 +1109,14 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
|
||||
else if (fastcmp(word, "MUSICSLOT"))
|
||||
{
|
||||
i = get_mus(word2, true);
|
||||
|
||||
if (i && i <= 1035)
|
||||
snprintf(cutscenes[num]->scene[scenenum].musswitch, 7, "%sM", G_BuildMapName(i));
|
||||
else if (i && i <= 1050)
|
||||
strncpy(cutscenes[num]->scene[scenenum].musswitch, compat_special_music_slots[i - 1036], 7);
|
||||
else
|
||||
cutscenes[num]->scene[scenenum].musswitch[0] = 0; // becomes empty string
|
||||
|
||||
cutscenes[num]->scene[scenenum].musswitch[6] = 0;
|
||||
}
|
||||
#endif
|
||||
@@ -1498,8 +1521,11 @@ static void readframe(MYFILE *f, INT32 num)
|
||||
strupr(word2);
|
||||
else
|
||||
break;
|
||||
if (word2[strlen(word2)-1] == '\n')
|
||||
word2[strlen(word2)-1] = '\0';
|
||||
|
||||
const size_t word2len = strlen(word2);
|
||||
|
||||
if (word2[word2len-1] == '\n')
|
||||
word2[word2len-1] = '\0';
|
||||
|
||||
if (fastcmp(word1, "SPRITENUMBER") || fastcmp(word1, "SPRITENAME"))
|
||||
{
|
||||
@@ -1828,13 +1854,19 @@ static void readextraemblemdata(MYFILE *f, INT32 num)
|
||||
value = atoi(word2); // used for numerical settings
|
||||
|
||||
if (fastcmp(word, "NAME"))
|
||||
{
|
||||
deh_strlcpy(extraemblems[num-1].name, word2,
|
||||
sizeof (extraemblems[num-1].name), va("Extra emblem %d: name", num));
|
||||
sizeof (extraemblems[num-1].name), va("Extra emblem %d: name", num));
|
||||
}
|
||||
else if (fastcmp(word, "OBJECTIVE"))
|
||||
{
|
||||
deh_strlcpy(extraemblems[num-1].description, word2,
|
||||
sizeof (extraemblems[num-1].description), va("Extra emblem %d: objective", 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, "SPRITE"))
|
||||
{
|
||||
if (word2[0] >= 'A' && word2[0] <= 'Z')
|
||||
@@ -1906,11 +1938,15 @@ static void readunlockable(MYFILE *f, INT32 num)
|
||||
i = atoi(word2); // used for numerical settings
|
||||
|
||||
if (fastcmp(word, "NAME"))
|
||||
{
|
||||
deh_strlcpy(unlockables[num].name, word2,
|
||||
sizeof (unlockables[num].name), va("Unlockable %d: name", num));
|
||||
sizeof (unlockables[num].name), va("Unlockable %d: name", num));
|
||||
}
|
||||
else if (fastcmp(word, "OBJECTIVE"))
|
||||
{
|
||||
deh_strlcpy(unlockables[num].objective, word2,
|
||||
sizeof (unlockables[num].objective), va("Unlockable %d: objective", num));
|
||||
sizeof (unlockables[num].objective), va("Unlockable %d: objective", num));
|
||||
}
|
||||
else if (fastcmp(word, "SHOWCONDITIONSET"))
|
||||
unlockables[num].showconditionset = (UINT8)i;
|
||||
else if (fastcmp(word, "CONDITIONSET"))
|
||||
@@ -8102,7 +8138,7 @@ static mobjtype_t get_mobjtype(const char *word)
|
||||
if (*word >= '0' && *word <= '9')
|
||||
return atoi(word);
|
||||
|
||||
if (fastncmp("MT_",word,3))
|
||||
if (fastncmp("MT_", word, 3))
|
||||
word += 3; // take off the MT_
|
||||
|
||||
for (i = 0; i < NUMMOBJFREESLOTS; i++)
|
||||
@@ -8128,7 +8164,7 @@ static statenum_t get_state(const char *word)
|
||||
if (*word >= '0' && *word <= '9')
|
||||
return atoi(word);
|
||||
|
||||
if (fastncmp("S_",word,2))
|
||||
if (fastncmp("S_", word, 2))
|
||||
word += 2; // take off the S_
|
||||
|
||||
for (i = 0; i < NUMSTATEFREESLOTS; i++)
|
||||
@@ -8155,11 +8191,11 @@ static spritenum_t get_sprite(const char *word)
|
||||
if (*word >= '0' && *word <= '9')
|
||||
return atoi(word);
|
||||
|
||||
if (fastncmp("SPR_",word,4))
|
||||
if (fastncmp("SPR_", word, 4))
|
||||
word += 4; // take off the SPR_
|
||||
|
||||
for (i = 0; i < NUMSPRITES; i++)
|
||||
if (!sprnames[i][4] && memcmp(word,sprnames[i],4) == 0)
|
||||
if (!sprnames[i][4] && memcmp(word, sprnames[i], 4) == 0)
|
||||
return i;
|
||||
|
||||
deh_warning("Couldn't find sprite named 'SPR_%s'",word);
|
||||
@@ -8200,14 +8236,15 @@ static UINT16 get_mus(const char *word, UINT8 dehacked_mode)
|
||||
if (!word[2] && toupper(word[0]) >= 'A' && toupper(word[0]) <= 'Z')
|
||||
return (UINT16)M_MapNumber(word[0], word[1]);
|
||||
|
||||
if (fastncmp("MUS_",word,4))
|
||||
if (fastncmp("MUS_", word, 4))
|
||||
word += 4; // take off the MUS_
|
||||
else if (fastncmp("O_",word,2) || fastncmp("D_",word,2))
|
||||
else if (fastncmp("O_", word, 2) || fastncmp("D_", word, 2))
|
||||
word += 2; // take off the O_ or D_
|
||||
|
||||
strncpy(lumptmp, word, 4);
|
||||
lumptmp[3] = 0;
|
||||
if (fasticmp("MAP",lumptmp))
|
||||
|
||||
if (fasticmp("MAP", lumptmp))
|
||||
{
|
||||
word += 3;
|
||||
if (toupper(word[0]) >= 'A' && toupper(word[0]) <= 'Z')
|
||||
@@ -8320,7 +8357,7 @@ static inline int lib_freeslot(lua_State *L)
|
||||
{
|
||||
sfxenum_t sfx;
|
||||
strlwr(word);
|
||||
CONS_Printf("Sound sfx_%s allocated.\n",word);
|
||||
CONS_Printf("Sound sfx_%s allocated.\n", word);
|
||||
sfx = S_AddSoundFx(word, false, 0, false);
|
||||
|
||||
if (sfx != sfx_None)
|
||||
@@ -8344,8 +8381,10 @@ static inline int lib_freeslot(lua_State *L)
|
||||
{
|
||||
if (!sprnames[j][4] && memcmp(sprnames[j], word, 4) == 0)
|
||||
sprnames[j][4] = wad;
|
||||
|
||||
continue; // Already allocated, next.
|
||||
}
|
||||
|
||||
// Found a free slot!
|
||||
CONS_Printf("Sprite SPR_%s allocated.\n",word);
|
||||
|
||||
@@ -8353,7 +8392,7 @@ static inline int lib_freeslot(lua_State *L)
|
||||
lua_pushfstring(L, "SPR_%s", word);
|
||||
lua_call(L, 1, 0);
|
||||
|
||||
strncpy(sprnames[j],word,4);
|
||||
strncpy(sprnames[j], word, 4);
|
||||
//sprnames[j][4] = 0;
|
||||
used_spr[(j-SPR_FIRSTFREESLOT)/8] |= 1<<(j%8); // Okay, this sprite slot has been named now.
|
||||
lua_pushinteger(L, j);
|
||||
@@ -8371,7 +8410,7 @@ static inline int lib_freeslot(lua_State *L)
|
||||
{
|
||||
if (!FREE_STATES[i])
|
||||
{
|
||||
CONS_Printf("State S_%s allocated.\n",word);
|
||||
CONS_Printf("State S_%s allocated.\n", word);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_invalidate_cache);
|
||||
lua_pushfstring(L, "S_%s", word);
|
||||
@@ -8396,14 +8435,14 @@ static inline int lib_freeslot(lua_State *L)
|
||||
{
|
||||
if (!FREE_MOBJS[i])
|
||||
{
|
||||
CONS_Printf("MobjType MT_%s allocated.\n",word);
|
||||
CONS_Printf("MobjType MT_%s allocated.\n", word);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_invalidate_cache);
|
||||
lua_pushfstring(L, "MT_%s", word);
|
||||
lua_call(L, 1, 0);
|
||||
|
||||
FREE_MOBJS[i] = Z_Malloc(strlen(word)+1, PU_STATIC, NULL);
|
||||
strcpy(FREE_MOBJS[i],word);
|
||||
strcpy(FREE_MOBJS[i], word);
|
||||
freeslotusage[1][0]++;
|
||||
lua_pushinteger(L, i);
|
||||
r++;
|
||||
@@ -8590,6 +8629,7 @@ static int lua_enumlib_mobjtype_get(lua_State *L)
|
||||
{
|
||||
if (!FREE_MOBJS[i])
|
||||
break;
|
||||
|
||||
if (fastcmp(s+3, FREE_MOBJS[i]))
|
||||
{
|
||||
lua_pushinteger(L, MT_FIRSTFREESLOT+i);
|
||||
@@ -8678,30 +8718,29 @@ static int lua_enumlib_sfx_get_ds(lua_State *L)
|
||||
}
|
||||
|
||||
#ifdef MUSICSLOT_COMPATIBILITY
|
||||
static int lua_enumlib_mus_get(lua_State *L)
|
||||
{
|
||||
const char *name = strchr(lua_tostring(L, 1), '_') + 1;
|
||||
int mus = get_mus(name, false);
|
||||
|
||||
static int lua_enumlib_mus_get(lua_State *L)
|
||||
{
|
||||
const char *name = strchr(lua_tostring(L, 1), '_') + 1;
|
||||
int mus = get_mus(name, false);
|
||||
if (mus == 0)
|
||||
return 0;
|
||||
|
||||
if (mus == 0)
|
||||
return 0;
|
||||
lua_pushinteger(L, mus);
|
||||
return 1;
|
||||
}
|
||||
|
||||
lua_pushinteger(L, mus);
|
||||
return 1;
|
||||
}
|
||||
static int lua_enumlib_mus_get_mathlib(lua_State *L)
|
||||
{
|
||||
const char *name = strchr(lua_tostring(L, 1), '_') + 1;
|
||||
int mus = get_mus(name, false);
|
||||
|
||||
static int lua_enumlib_mus_get_mathlib(lua_State *L)
|
||||
{
|
||||
const char *name = strchr(lua_tostring(L, 1), '_') + 1;
|
||||
int mus = get_mus(name, false);
|
||||
if (mus == 0)
|
||||
return luaL_error(L, "music '%s' could not be found.\n", lua_tostring(L, 1));
|
||||
|
||||
if (mus == 0)
|
||||
return luaL_error(L, "music '%s' could not be found.\n", lua_tostring(L, 1));
|
||||
|
||||
lua_pushinteger(L, mus);
|
||||
return 1;
|
||||
}
|
||||
lua_pushinteger(L, mus);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int lua_enumlib_power_get(lua_State *L)
|
||||
|
||||
+3
-1
@@ -81,10 +81,12 @@ typedef struct
|
||||
INT16 flags;
|
||||
INT16 special;
|
||||
INT16 tag;
|
||||
// sidenum[1] will be 0xffff if one sided
|
||||
// sidenum[1] will be NO_INDEX if one sided
|
||||
UINT16 sidenum[2];
|
||||
} ATTRPACK maplinedef_t;
|
||||
|
||||
#define NO_INDEX 0xffff
|
||||
|
||||
//
|
||||
// LineDef attributes.
|
||||
//
|
||||
|
||||
@@ -602,6 +602,13 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
// None of these that are disabled in the normal build are guaranteed to work perfectly
|
||||
// Compile them at your own risk!
|
||||
|
||||
// undefine to enable fixes and features that are not vanilla compatible
|
||||
#define COMPAT_VANILLA
|
||||
// if we build with 32 player (or more!) support we dont need to care vanilla compat
|
||||
#if MAXPLAYERS > 16
|
||||
#undef COMPAT_VANILLA
|
||||
#endif
|
||||
|
||||
//-- SATURN __
|
||||
/// Detect if a client is on Saturn in the clientconfig.
|
||||
/// To seperately allow them to join or block joining from vanilla clients.
|
||||
@@ -666,6 +673,14 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
#undef UPDATE_ALERT
|
||||
#endif
|
||||
|
||||
// overwrite some of those
|
||||
// when not compiling in vanilla compat mode
|
||||
#ifndef COMPAT_VANILLA
|
||||
#define SATURNJOIN
|
||||
#define SATURNPAK
|
||||
#undef SEENAMES
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
+68
-63
@@ -447,7 +447,8 @@ void G_WriteDemoExtraData(void)
|
||||
{
|
||||
static UINT8 timeout = 0;
|
||||
|
||||
if (timeout) timeout--;
|
||||
if (timeout)
|
||||
timeout--;
|
||||
|
||||
if (demo_writerng == 1 || (demo_writerng == 2 && timeout == 0))
|
||||
{
|
||||
@@ -467,6 +468,7 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
|
||||
|
||||
if (!demobuf.p || !demo.deferstart)
|
||||
return;
|
||||
|
||||
ziptic = READUINT8(demobuf.p);
|
||||
|
||||
if (ziptic & ZT_FWD)
|
||||
@@ -488,11 +490,12 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
|
||||
|
||||
// what in the actual fuck is this???
|
||||
// SRB2kart: Copy-pasted from ticcmd building, removes that crappy demo cam
|
||||
if (((players[displayplayers[0]].mo && players[displayplayers[0]].speed > 0) // Moving
|
||||
const player_t *player = &players[displayplayers[0]];
|
||||
if (((player->mo && player->speed > 0) // Moving
|
||||
|| (leveltime > starttime && (cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE)) // Rubber-burn turn
|
||||
|| (players[displayplayers[0]].kartstuff[k_respawn]) // Respawning
|
||||
|| (players[displayplayers[0]].spectator || objectplacing)) // Not a physical player
|
||||
&& !(players[displayplayers[0]].kartstuff[k_spinouttimer] && players[displayplayers[0]].kartstuff[k_sneakertimer])) // Spinning and boosting cancels out spinout
|
||||
|| (player->kartstuff[k_respawn]) // Respawning
|
||||
|| (player->spectator || objectplacing)) // Not a physical player
|
||||
&& !(player->kartstuff[k_spinouttimer] && player->kartstuff[k_sneakertimer])) // Spinning and boosting cancels out spinout
|
||||
localangle[0] += (cmd->angleturn<<16);
|
||||
|
||||
if (!(demoflags & DF_GHOST) && *demobuf.p == DEMOMARKER)
|
||||
@@ -515,49 +518,49 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
|
||||
|
||||
if (cmd->forwardmove != oldcmd[playernum].forwardmove)
|
||||
{
|
||||
WRITEUINT8(demobuf.p,cmd->forwardmove);
|
||||
WRITEUINT8(demobuf.p, cmd->forwardmove);
|
||||
oldcmd[playernum].forwardmove = cmd->forwardmove;
|
||||
ziptic |= ZT_FWD;
|
||||
}
|
||||
|
||||
if (cmd->sidemove != oldcmd[playernum].sidemove)
|
||||
{
|
||||
WRITEUINT8(demobuf.p,cmd->sidemove);
|
||||
WRITEUINT8(demobuf.p, cmd->sidemove);
|
||||
oldcmd[playernum].sidemove = cmd->sidemove;
|
||||
ziptic |= ZT_SIDE;
|
||||
}
|
||||
|
||||
if (cmd->angleturn != oldcmd[playernum].angleturn)
|
||||
{
|
||||
WRITEINT16(demobuf.p,cmd->angleturn);
|
||||
WRITEINT16(demobuf.p, cmd->angleturn);
|
||||
oldcmd[playernum].angleturn = cmd->angleturn;
|
||||
ziptic |= ZT_ANGLE;
|
||||
}
|
||||
|
||||
if (cmd->buttons != oldcmd[playernum].buttons)
|
||||
{
|
||||
WRITEUINT16(demobuf.p,cmd->buttons);
|
||||
WRITEUINT16(demobuf.p, cmd->buttons);
|
||||
oldcmd[playernum].buttons = cmd->buttons;
|
||||
ziptic |= ZT_BUTTONS;
|
||||
}
|
||||
|
||||
if (cmd->aiming != oldcmd[playernum].aiming)
|
||||
{
|
||||
WRITEINT16(demobuf.p,cmd->aiming);
|
||||
WRITEINT16(demobuf.p, cmd->aiming);
|
||||
oldcmd[playernum].aiming = cmd->aiming;
|
||||
ziptic |= ZT_AIMING;
|
||||
}
|
||||
|
||||
if (cmd->driftturn != oldcmd[playernum].driftturn)
|
||||
{
|
||||
WRITEINT16(demobuf.p,cmd->driftturn);
|
||||
WRITEINT16(demobuf.p, cmd->driftturn);
|
||||
oldcmd[playernum].driftturn = cmd->driftturn;
|
||||
ziptic |= ZT_DRIFT;
|
||||
}
|
||||
|
||||
if (cmd->latency != oldcmd[playernum].latency)
|
||||
{
|
||||
WRITEUINT8(demobuf.p,cmd->latency);
|
||||
WRITEUINT8(demobuf.p, cmd->latency);
|
||||
oldcmd[playernum].latency = cmd->latency;
|
||||
ziptic |= ZT_LATENCY;
|
||||
}
|
||||
@@ -726,8 +729,8 @@ void G_WriteGhostTic(mobj_t *ghost, INT32 playernum)
|
||||
|
||||
// GZT_XYZ is only useful if you've moved 256 FRACUNITS or more in a single tic.
|
||||
if (abs(ghost->x-oldghost[playernum].x) > MAXMOM
|
||||
|| abs(ghost->y-oldghost[playernum].y) > MAXMOM
|
||||
|| abs(ghost->z-oldghost[playernum].z) > MAXMOM
|
||||
|| abs(ghost->y-oldghost[playernum].y) > MAXMOM
|
||||
|| abs(ghost->z-oldghost[playernum].z) > MAXMOM
|
||||
|| ((UINT8)(leveltime & 255) > 0 && (UINT8)(leveltime & 255) <= (UINT8)cv_netdemosyncquality.value)) // Hack to enable slightly nicer resyncing
|
||||
{
|
||||
oldghost[playernum].x = ghost->x;
|
||||
@@ -1344,7 +1347,7 @@ fadeghost:
|
||||
}
|
||||
else
|
||||
{
|
||||
mobj = P_SpawnMobj(g->mo->x, g->mo->y, g->mo->z - FixedDiv(FixedMul(g->mo->info->height, g->mo->scale) - g->mo->height,3*FRACUNIT), MT_THOK);
|
||||
mobj = P_SpawnMobj(g->mo->x, g->mo->y, g->mo->z - FixedDiv(FixedMul(g->mo->info->height, g->mo->scale) - g->mo->height, 3*FRACUNIT), MT_THOK);
|
||||
mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
|
||||
mobj->frame = (states[mobjinfo[type].spawnstate].frame & FF_FRAMEMASK) | tr_trans60<<FF_TRANSSHIFT;
|
||||
mobj->tics = -1; // nope.
|
||||
@@ -1375,7 +1378,7 @@ fadeghost:
|
||||
UINT16 i, health;
|
||||
UINT16 count = READUINT16(g->p);
|
||||
//UINT32 type;
|
||||
fixed_t x,y,z;
|
||||
fixed_t x, y, z;
|
||||
angle_t angle;
|
||||
mobj_t *poof;
|
||||
|
||||
@@ -1518,7 +1521,9 @@ void G_PreviewRewind(tic_t previewtime)
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i] || players[i].spectator)
|
||||
player_t *player = &players[i];
|
||||
|
||||
if (!playeringame[i] || player->spectator)
|
||||
{
|
||||
if (info->playerinfo[i].player.mo)
|
||||
{
|
||||
@@ -1530,35 +1535,35 @@ void G_PreviewRewind(tic_t previewtime)
|
||||
|
||||
if (!info->playerinfo[i].ingame || !info->playerinfo[i].player.mo)
|
||||
{
|
||||
if (players[i].mo)
|
||||
players[i].mo->flags2 |= MF2_DONTDRAW;
|
||||
if (player->mo)
|
||||
player->mo->flags2 |= MF2_DONTDRAW;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!players[i].mo)
|
||||
if (!player->mo)
|
||||
continue; //@TODO spawn temp object to act as a player display
|
||||
|
||||
players[i].mo->flags2 &= ~MF2_DONTDRAW;
|
||||
player->mo->flags2 &= ~MF2_DONTDRAW;
|
||||
|
||||
P_UnsetThingPosition(players[i].mo);
|
||||
P_UnsetThingPosition(player->mo);
|
||||
#define TWEEN(pr) info->playerinfo[i].mobj.pr + FixedMul((INT32) (next_info->playerinfo[i].mobj.pr - info->playerinfo[i].mobj.pr), tweenvalue)
|
||||
players[i].mo->x = TWEEN(x);
|
||||
players[i].mo->y = TWEEN(y);
|
||||
players[i].mo->z = TWEEN(z);
|
||||
players[i].mo->angle = TWEEN(angle);
|
||||
player->mo->x = TWEEN(x);
|
||||
player->mo->y = TWEEN(y);
|
||||
player->mo->z = TWEEN(z);
|
||||
player->mo->angle = TWEEN(angle);
|
||||
#undef TWEEN
|
||||
P_SetThingPosition(players[i].mo);
|
||||
P_SetThingPosition(player->mo);
|
||||
|
||||
players[i].frameangle = info->playerinfo[i].player.frameangle + FixedMul((INT32) (next_info->playerinfo[i].player.frameangle - info->playerinfo[i].player.frameangle), tweenvalue);
|
||||
player->frameangle = info->playerinfo[i].player.frameangle + FixedMul((INT32) (next_info->playerinfo[i].player.frameangle - info->playerinfo[i].player.frameangle), tweenvalue);
|
||||
|
||||
players[i].mo->sprite = info->playerinfo[i].mobj.sprite;
|
||||
players[i].mo->frame = info->playerinfo[i].mobj.frame;
|
||||
player->mo->sprite = info->playerinfo[i].mobj.sprite;
|
||||
player->mo->frame = info->playerinfo[i].mobj.frame;
|
||||
|
||||
players[i].realtime = info->playerinfo[i].player.realtime;
|
||||
player->realtime = info->playerinfo[i].player.realtime;
|
||||
|
||||
for (j = 0; j < NUMKARTSTUFF; j++)
|
||||
players[i].kartstuff[j] = info->playerinfo[i].player.kartstuff[j];
|
||||
player->kartstuff[j] = info->playerinfo[i].player.kartstuff[j];
|
||||
}
|
||||
|
||||
for (i = splitscreen; i >= 0; i--)
|
||||
@@ -1691,7 +1696,7 @@ void G_BeginRecording(void)
|
||||
return;
|
||||
}
|
||||
|
||||
memset(name,0,sizeof(name));
|
||||
memset(name, 0, sizeof(name));
|
||||
|
||||
demobuf.p = demobuf.buffer;
|
||||
demoflags = DF_GHOST|(multiplayer ? DF_MULTIPLAYER : (modeattacking<<DF_ATTACKSHIFT));
|
||||
@@ -1705,9 +1710,9 @@ void G_BeginRecording(void)
|
||||
|
||||
// Setup header.
|
||||
memcpy(demobuf.p, DEMOHEADER, 12); demobuf.p += 12;
|
||||
WRITEUINT8(demobuf.p,VERSION);
|
||||
WRITEUINT8(demobuf.p,SUBVERSION);
|
||||
WRITEUINT16(demobuf.p,DEMOVERSION);
|
||||
WRITEUINT8(demobuf.p, VERSION);
|
||||
WRITEUINT8(demobuf.p, SUBVERSION);
|
||||
WRITEUINT16(demobuf.p, DEMOVERSION);
|
||||
|
||||
// Full replay title
|
||||
demobuf.p += 64;
|
||||
@@ -1736,7 +1741,7 @@ void G_BeginRecording(void)
|
||||
|
||||
// game data
|
||||
memcpy(demobuf.p, "PLAY", 4); demobuf.p += 4;
|
||||
WRITEINT16(demobuf.p,gamemap);
|
||||
WRITEINT16(demobuf.p, gamemap);
|
||||
memcpy(demobuf.p, mapmd5, 16); demobuf.p += 16;
|
||||
|
||||
WRITEUINT8(demobuf.p, demoflags);
|
||||
@@ -1768,8 +1773,8 @@ void G_BeginRecording(void)
|
||||
break;
|
||||
case ATTACKING_RECORD: // 1
|
||||
demotime_p = demobuf.p;
|
||||
WRITEUINT32(demobuf.p,UINT32_MAX); // time
|
||||
WRITEUINT32(demobuf.p,UINT32_MAX); // lap
|
||||
WRITEUINT32(demobuf.p, UINT32_MAX); // time
|
||||
WRITEUINT32(demobuf.p, UINT32_MAX); // lap
|
||||
break;
|
||||
default: // 3
|
||||
break;
|
||||
@@ -1826,9 +1831,9 @@ void G_BeginRecording(void)
|
||||
if (demoflags & DF_LUAVARS)
|
||||
LUA_Archive(&demobuf, false);
|
||||
|
||||
memset(&oldcmd,0,sizeof(oldcmd));
|
||||
memset(&oldghost,0,sizeof(oldghost));
|
||||
memset(&ghostext,0,sizeof(ghostext));
|
||||
memset(&oldcmd, 0, sizeof(oldcmd));
|
||||
memset(&oldghost, 0, sizeof(oldghost));
|
||||
memset(&ghostext, 0, sizeof(ghostext));
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
@@ -1868,19 +1873,19 @@ void G_WriteStanding(UINT8 ranking, char *name, INT32 skinnum, UINT8 color, UINT
|
||||
// Name
|
||||
memset(temp, 0, 16);
|
||||
strncpy(temp, name, 16);
|
||||
memcpy(demobuf.p,temp,16);
|
||||
memcpy(demobuf.p, temp, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Skin
|
||||
memset(temp, 0, 16);
|
||||
strncpy(temp, skins[skinnum].name, 16);
|
||||
memcpy(demobuf.p,temp,16);
|
||||
memcpy(demobuf.p, temp, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Color
|
||||
memset(temp, 0, 16);
|
||||
strncpy(temp, KartColor_Names[color], 16);
|
||||
memcpy(demobuf.p,temp,16);
|
||||
memcpy(demobuf.p, temp, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Score/time/whatever
|
||||
@@ -2339,7 +2344,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
extrainfo_p += 16;
|
||||
|
||||
// Skin
|
||||
memcpy(temp,extrainfo_p,16);
|
||||
memcpy(temp, extrainfo_p, 16);
|
||||
extrainfo_p += 16;
|
||||
pdemo->standings[count].skin = UINT8_MAX;
|
||||
|
||||
@@ -2353,12 +2358,12 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
}
|
||||
|
||||
// Color
|
||||
memcpy(temp,extrainfo_p,16);
|
||||
memcpy(temp, extrainfo_p, 16);
|
||||
extrainfo_p += 16;
|
||||
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
{
|
||||
if (fasticmp(KartColor_Names[i],temp)) // SRB2kart
|
||||
if (fasticmp(KartColor_Names[i], temp)) // SRB2kart
|
||||
{
|
||||
pdemo->standings[count].color = i;
|
||||
break;
|
||||
@@ -2827,15 +2832,15 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
if (demo.version == 0x0001)
|
||||
{
|
||||
// Player name
|
||||
memcpy(player_names[0],demobuf.p,16);
|
||||
memcpy(player_names[0], demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Skin
|
||||
memcpy(skin,demobuf.p,16);
|
||||
memcpy(skin, demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Color
|
||||
memcpy(color,demobuf.p,16);
|
||||
memcpy(color, demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
demobuf.p += 5; // Backwards compat - some stats
|
||||
@@ -2868,7 +2873,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// Set color
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
{
|
||||
if (fasticmp(KartColor_Names[i],color)) // SRB2kart
|
||||
if (fasticmp(KartColor_Names[i], color)) // SRB2kart
|
||||
{
|
||||
players[0].skincolor = i;
|
||||
break;
|
||||
@@ -2888,9 +2893,9 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
return;
|
||||
}
|
||||
|
||||
memset(&oldcmd,0,sizeof(oldcmd));
|
||||
memset(&oldghost,0,sizeof(oldghost));
|
||||
memset(&ghostext,0,sizeof(ghostext));
|
||||
memset(&oldcmd, 0, sizeof(oldcmd));
|
||||
memset(&oldghost, 0, sizeof(oldghost));
|
||||
memset(&ghostext, 0, sizeof(ghostext));
|
||||
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo version does not match game version. Desyncs may occur.\n"));
|
||||
|
||||
@@ -2994,16 +2999,16 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
players[p].spectator = spectator;
|
||||
|
||||
// Name
|
||||
memcpy(player_names[p],demobuf.p,16);
|
||||
memcpy(player_names[p], demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
// Skin
|
||||
memcpy(skin,demobuf.p,16);
|
||||
memcpy(skin, demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
SetPlayerSkin(p, skin);
|
||||
|
||||
// Color
|
||||
memcpy(color,demobuf.p,16);
|
||||
memcpy(color, demobuf.p, 16);
|
||||
demobuf.p += 16;
|
||||
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
@@ -3221,15 +3226,15 @@ void G_AddGhost(char *defdemoname)
|
||||
if (ghostversion == 0x0001)
|
||||
{
|
||||
// Player name (TODO: Display this somehow if it doesn't match cv_playername!)
|
||||
memcpy(name, p,16);
|
||||
memcpy(name, p, 16);
|
||||
p += 16;
|
||||
|
||||
// Skin
|
||||
memcpy(skin, p,16);
|
||||
memcpy(skin, p, 16);
|
||||
p += 16;
|
||||
|
||||
// Color
|
||||
memcpy(color, p,16);
|
||||
memcpy(color, p, 16);
|
||||
p += 16;
|
||||
|
||||
// Ghosts do not have a player structure to put this in.
|
||||
@@ -3381,7 +3386,7 @@ void G_AddGhost(char *defdemoname)
|
||||
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
{
|
||||
if (fasticmp(KartColor_Names[i],color)) // SRB2kart
|
||||
if (fasticmp(KartColor_Names[i], color)) // SRB2kart
|
||||
{
|
||||
gh->mo->color = (UINT8)i;
|
||||
break;
|
||||
@@ -3473,7 +3478,7 @@ void G_UpdateStaffGhostName(lumpnum_t l)
|
||||
if (ghostversion == 0x0001)
|
||||
{
|
||||
// Player name
|
||||
memcpy(dummystaffname, p,16);
|
||||
memcpy(dummystaffname, p, 16);
|
||||
dummystaffname[16] = '\0';
|
||||
return; // Not really a failure but whatever
|
||||
}
|
||||
|
||||
+6
-2
@@ -857,7 +857,8 @@ static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
|
||||
static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
|
||||
{
|
||||
INT32 axis = 0;
|
||||
const boolean usejoystick = cv_usejoystick[(ssplayer-1)].value;
|
||||
const UINT8 forplayer = (ssplayer-1);
|
||||
const boolean usejoystick = cv_usejoystick[forplayer].value;
|
||||
|
||||
// check for inputs and return button commands
|
||||
// for stuff like joining with item button, saltyhop, honking, etc.
|
||||
@@ -893,7 +894,7 @@ static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
|
||||
#undef CHECKINPUT
|
||||
|
||||
axis = JoyAxis(AXISLOOKBACK, ssplayer);
|
||||
camspin[ssplayer-1] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
|
||||
camspin[forplayer] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
|
||||
|
||||
// Reset to our spec player if we watch someone else.
|
||||
if ((cmd->driftturn || cmd->buttons)
|
||||
@@ -1309,6 +1310,7 @@ static void G_DoLoadLevel(boolean resetplayer)
|
||||
{
|
||||
// fail so reset game stuff
|
||||
Command_ExitGame_f();
|
||||
P_FreeCorruptMapWarnings();
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -1342,6 +1344,8 @@ static void G_DoLoadLevel(boolean resetplayer)
|
||||
|
||||
// clear hud messages remains (usually from game startup)
|
||||
CON_ClearHUD();
|
||||
// print any map errors now due to clearhud above :chaosleep:
|
||||
P_PrintCorruptMapWarnings();
|
||||
|
||||
server_lagless = !cv_gentlemens.value;
|
||||
|
||||
|
||||
@@ -373,7 +373,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 count, poly_t *poly)
|
||||
if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL)
|
||||
gl_maphashorizonlines = true;
|
||||
|
||||
if (line->sidenum[1] != 0xffff)
|
||||
if (line->sidenum[1] != NO_INDEX)
|
||||
{
|
||||
if (sides[line->sidenum[0]].sector == sides[line->sidenum[1]].sector)
|
||||
{
|
||||
|
||||
@@ -729,7 +729,7 @@ static void HWR_PrecacheLevelTextures(void)
|
||||
for (j = 0; j < 2; j++)
|
||||
{
|
||||
// check if single-sided linedef
|
||||
if (line->sidenum[j] == 0xffff)
|
||||
if (line->sidenum[j] == NO_INDEX)
|
||||
continue;
|
||||
|
||||
const side_t *side = &sides[line->sidenum[j]];
|
||||
|
||||
@@ -80,8 +80,8 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
|
||||
gl_portal_t *portal = HWR_Portal_Add(seg);
|
||||
|
||||
// Offset the portal view by the linedef centers
|
||||
line_t* start = &lines[line1];
|
||||
line_t* dest = &lines[line2];
|
||||
line_t* start = &lines[line1];
|
||||
line_t* dest = &lines[line2];
|
||||
|
||||
angle_t dangle = R_PointToAngle2(0, 0, dest->dx, dest->dy) - R_PointToAngle2(start->dx, start->dy, 0, 0);
|
||||
|
||||
@@ -99,7 +99,7 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
|
||||
dest_c.y = dest->v1->y/2 + dest->v2->y/2;
|
||||
|
||||
disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint += dangle;
|
||||
|
||||
portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
@@ -220,9 +220,9 @@ boolean HWR_PortalCheckBBox(const fixed_t *bspcoord)
|
||||
if (!portalclipline)
|
||||
return true;
|
||||
|
||||
if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) ||
|
||||
if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXBOTTOM]))
|
||||
{
|
||||
return true;
|
||||
|
||||
@@ -76,6 +76,11 @@
|
||||
//
|
||||
|
||||
// Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro.
|
||||
|
||||
// dither shader based on
|
||||
// https://github.com/hughsk/glsl-dither/blob/master/8x8.glsl
|
||||
// https://github.com/libretro/glsl-shaders/blob/master/dithering/shaders/bayer_4x4.glsl
|
||||
// adapted and messed about to work with srb2 and scale per resolution
|
||||
#define GLSL_DOOM_COLORMAP_DITHER \
|
||||
"float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
|
||||
"float patscale = min(scr_resolution.x / 1280.0, scr_resolution.y / 720.0);\n" \
|
||||
|
||||
@@ -1698,7 +1698,7 @@ static void GL_SetBlendMode(FBITFIELD flags)
|
||||
|
||||
void GL_SetBlend(FBITFIELD PolyFlags)
|
||||
{
|
||||
const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;;
|
||||
const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;
|
||||
|
||||
if (Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Skydecal|PF_Invisible))
|
||||
{
|
||||
|
||||
+36
-9
@@ -133,6 +133,7 @@ static void Command_Say_f(void);
|
||||
static void Command_Sayto_f(void);
|
||||
static void Command_Sayteam_f(void);
|
||||
static void Command_CSay_f(void);
|
||||
static void Command_Mute_f(void);
|
||||
static void Got_Saycmd(const UINT8 **p, INT32 playernum);
|
||||
|
||||
void HU_LoadGraphics(void)
|
||||
@@ -260,6 +261,8 @@ void HU_Init(void)
|
||||
COM_AddCommand("csay", Command_CSay_f);
|
||||
RegisterNetXCmd(XD_SAY, Got_Saycmd);
|
||||
|
||||
COM_AddCommand("muteplayer", Command_Mute_f);
|
||||
|
||||
if (dedicated || rendermode == render_none)
|
||||
return;
|
||||
|
||||
@@ -963,7 +966,7 @@ void HU_Ticker(void)
|
||||
size_t i = 0;
|
||||
|
||||
// handle spam while we're at it:
|
||||
for(; (i < MAXPLAYERS); i++)
|
||||
for (; (i < MAXPLAYERS); i++)
|
||||
{
|
||||
if (stop_spamming[i] > 0)
|
||||
stop_spamming[i]--;
|
||||
@@ -1022,21 +1025,42 @@ static boolean HU_clearChatSpaces(void)
|
||||
return nothingbutspaces;
|
||||
}
|
||||
|
||||
static void DoMute(const char *name)
|
||||
static void DoMute(const char *name, boolean chat)
|
||||
{
|
||||
INT32 pnum = D_LookupPlayer(name);
|
||||
|
||||
if (pnum < 0)
|
||||
// Shortcut to reuse this function for console and chat command
|
||||
#define PRINT(msg, sound) do { \
|
||||
if (chat) \
|
||||
HU_AddChatText((msg), (sound)); \
|
||||
else \
|
||||
CONS_Printf("%s\n", msg); \
|
||||
} while (0)
|
||||
|
||||
if (pnum < 0 || !playeringame[pnum])
|
||||
{
|
||||
HU_AddChatText("\x85""ERROR: \x80Player not found.", false);
|
||||
PRINT("\x85""ERROR: \x80Player not found.", false);
|
||||
return;
|
||||
}
|
||||
|
||||
player_muted[pnum] = !player_muted[pnum];
|
||||
|
||||
HU_AddChatText(va("Player '%s' has been %smuted.", player_names[pnum], player_muted[pnum] ? "" : "un"), false);
|
||||
PRINT(va("Player '%s' has been %smuted.", player_names[pnum], player_muted[pnum] ? "" : "un"), false);
|
||||
if (player_muted[pnum])
|
||||
HU_AddChatText("Use same command to unmute them.", false);
|
||||
PRINT("Use same command to unmute them.", false);
|
||||
|
||||
#undef PRINT
|
||||
}
|
||||
|
||||
static void Command_Mute_f(void)
|
||||
{
|
||||
if (COM_Argc() < 2)
|
||||
{
|
||||
CONS_Printf(M_GetText("mute <playername|playernum>: mute/unmute a player\n"));
|
||||
return;
|
||||
}
|
||||
|
||||
DoMute(COM_Argv(1), false);
|
||||
}
|
||||
|
||||
static void HU_SendChatMessage(void)
|
||||
@@ -1070,7 +1094,7 @@ static void HU_SendChatMessage(void)
|
||||
if (msglength >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
|
||||
{
|
||||
if (msglength > 6)
|
||||
DoMute(msg+6);
|
||||
DoMute(msg+6, true);
|
||||
else
|
||||
HU_AddChatText("\x82NOTICE: \x80Usage: /mute <name|node>", false);
|
||||
|
||||
@@ -1111,6 +1135,7 @@ static void HU_SendChatMessage(void)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// I'm very bad at C, I swear I am, additional checks eww!
|
||||
if (spc != 0)
|
||||
{
|
||||
@@ -1257,13 +1282,15 @@ boolean HU_Responder(event_t *ev)
|
||||
chat_on = false;
|
||||
I_SetTextInput(false);
|
||||
}
|
||||
else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0 && !OLDCHAT) // CHAT SCROLLING YAYS!
|
||||
else if ((c == KEY_UPARROW || c == KEY_PGUP || c == KEY_MOUSEWHEELUP) &&
|
||||
((chat_scroll > 0) && !OLDCHAT)) // CHAT SCROLLING YAYS!
|
||||
{
|
||||
chat_scroll--;
|
||||
justscrolledup = true;
|
||||
chat_scrolltime = 4;
|
||||
}
|
||||
else if ((c == KEY_DOWNARROW || c == KEY_MOUSEWHEELDOWN) && chat_scroll < chat_maxscroll && chat_maxscroll > 0 && !OLDCHAT)
|
||||
else if ((c == KEY_DOWNARROW || c == KEY_PGDN || c == KEY_MOUSEWHEELDOWN) &&
|
||||
((chat_scroll < chat_maxscroll) && (chat_maxscroll > 0) && !OLDCHAT))
|
||||
{
|
||||
chat_scroll++;
|
||||
justscrolleddown = true;
|
||||
|
||||
@@ -452,7 +452,11 @@ void A_SpawnFreshCopy(void *actor);
|
||||
extern boolean actionsoverridden[NUMACTIONS];
|
||||
|
||||
// ratio of states to sprites to mobj types is roughly 6 : 1 : 1
|
||||
#ifdef COMPAT_VANILLA
|
||||
#define NUMMOBJFREESLOTS 1024
|
||||
#else
|
||||
#define NUMMOBJFREESLOTS 4096 // should be sufficient
|
||||
#endif
|
||||
#define NUMSPRITEFREESLOTS NUMMOBJFREESLOTS
|
||||
#define NUMSTATEFREESLOTS (NUMMOBJFREESLOTS*8)
|
||||
|
||||
|
||||
+54
-35
@@ -4559,50 +4559,59 @@ void K_DropHnextList(player_t *player)
|
||||
P_RemoveMobj(work);
|
||||
}
|
||||
|
||||
{
|
||||
// we need this here too because this is done in afterthink - pointers are cleaned up at the START of each tic...
|
||||
P_SetTarget(&player->mo->hnext, NULL);
|
||||
player->kartstuff[k_bananadrag] = 0;
|
||||
// we need this here too because this is done in afterthink - pointers are cleaned up at the START of each tic...
|
||||
P_SetTarget(&player->mo->hnext, NULL);
|
||||
player->kartstuff[k_bananadrag] = 0;
|
||||
|
||||
if (player->kartstuff[k_eggmanheld])
|
||||
player->kartstuff[k_eggmanheld] = 0;
|
||||
else if (player->kartstuff[k_itemheld]
|
||||
&& (dropall || (--player->kartstuff[k_itemamount] <= 0)))
|
||||
{
|
||||
player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
|
||||
player->kartstuff[k_itemtype] = KITEM_NONE;
|
||||
}
|
||||
if (player->kartstuff[k_eggmanheld])
|
||||
player->kartstuff[k_eggmanheld] = 0;
|
||||
else if (player->kartstuff[k_itemheld]
|
||||
&& (dropall || (--player->kartstuff[k_itemamount] <= 0)))
|
||||
{
|
||||
player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
|
||||
player->kartstuff[k_itemtype] = KITEM_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
static void K_DropPaperItem(player_t *player, boolean thunderhack, INT32 itemamount)
|
||||
{
|
||||
const mobj_t *pmo = player->mo;
|
||||
|
||||
if (P_MobjWasRemoved(pmo))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
mobj_t *drop = P_SpawnMobj(pmo->x, pmo->y, (pmo->z + pmo->height/2), MT_FLOATINGITEM);
|
||||
P_SetScale(drop, drop->scale>>4);
|
||||
|
||||
drop->destscale = (3*drop->destscale)/2;
|
||||
|
||||
drop->angle = pmo->angle + ANGLE_90;
|
||||
P_Thrust(drop, FixedAngle(P_RandomFixed()*180) + pmo->angle + ANGLE_90, 16*mapobjectscale);
|
||||
drop->momz = P_MobjFlip(pmo)*3*mapobjectscale;
|
||||
if (drop->eflags & MFE_UNDERWATER)
|
||||
drop->momz = (117 * drop->momz) / 200;
|
||||
|
||||
drop->threshold = (thunderhack ? KITEM_THUNDERSHIELD : player->kartstuff[k_itemtype]);
|
||||
drop->movecount = itemamount;
|
||||
|
||||
drop->flags |= MF_NOCLIPTHING;
|
||||
}
|
||||
|
||||
// For getting EXTRA hit!
|
||||
void K_DropItems(player_t *player)
|
||||
{
|
||||
boolean thunderhack = (player->kartstuff[k_curshield] && player->kartstuff[k_itemtype] == KITEM_THUNDERSHIELD);
|
||||
const boolean thunderhack = (player->kartstuff[k_curshield] && player->kartstuff[k_itemtype] == KITEM_THUNDERSHIELD);
|
||||
|
||||
if (thunderhack)
|
||||
player->kartstuff[k_itemtype] = KITEM_NONE;
|
||||
|
||||
K_DropHnextList(player);
|
||||
|
||||
if (!P_MobjWasRemoved(player->mo) && player->kartstuff[k_itemamount])
|
||||
if (player->kartstuff[k_itemamount])
|
||||
{
|
||||
mobj_t *drop = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z + player->mo->height/2, MT_FLOATINGITEM);
|
||||
P_SetScale(drop, drop->scale>>4);
|
||||
drop->destscale = (3*drop->destscale)/2;
|
||||
|
||||
drop->angle = player->mo->angle + ANGLE_90;
|
||||
P_Thrust(drop,
|
||||
FixedAngle(P_RandomFixed()*180) + player->mo->angle + ANGLE_90,
|
||||
16*mapobjectscale);
|
||||
drop->momz = P_MobjFlip(player->mo)*3*mapobjectscale;
|
||||
if (drop->eflags & MFE_UNDERWATER)
|
||||
drop->momz = (117 * drop->momz) / 200;
|
||||
|
||||
drop->threshold = (thunderhack ? KITEM_THUNDERSHIELD : player->kartstuff[k_itemtype]);
|
||||
drop->movecount = player->kartstuff[k_itemamount];
|
||||
|
||||
drop->flags |= MF_NOCLIPTHING;
|
||||
K_DropPaperItem(player, thunderhack, player->kartstuff[k_itemamount]);
|
||||
}
|
||||
|
||||
K_StripItems(player);
|
||||
@@ -4620,7 +4629,7 @@ void K_DropRocketSneaker(player_t *player)
|
||||
while ((shoe = shoe->hnext) && !P_MobjWasRemoved(shoe))
|
||||
{
|
||||
if (shoe->type != MT_ROCKETSNEAKER)
|
||||
return; //woah, not a rocketsneaker, bail! safeguard in case this gets used when you're holding non-rocketsneakers
|
||||
return; // woah, not a rocketsneaker, bail! safeguard in case this gets used when you're holding non-rocketsneakers
|
||||
|
||||
shoe->flags2 &= ~MF2_DONTDRAW;
|
||||
shoe->flags &= ~MF_NOGRAVITY;
|
||||
@@ -4658,7 +4667,7 @@ void K_DropKitchenSink(player_t *player)
|
||||
return;
|
||||
|
||||
if (player->mo->hnext->type != MT_SINK_SHIELD)
|
||||
return; //so we can just call this function regardless of what is being held
|
||||
return; // so we can just call this function regardless of what is being held
|
||||
|
||||
P_KillMobj(player->mo->hnext, NULL, NULL);
|
||||
|
||||
@@ -4684,9 +4693,12 @@ void K_RepairOrbitChain(mobj_t *orbit)
|
||||
}
|
||||
|
||||
// Then recount to make sure item amount is correct
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (!P_MobjWasRemoved(orbit->target) && orbit->target->player)
|
||||
#else
|
||||
if (orbit->target && orbit->target->player)
|
||||
#endif
|
||||
{
|
||||
player_t *player = orbit->target->player;
|
||||
INT32 num = 0;
|
||||
|
||||
mobj_t *cur = orbit->target->hnext;
|
||||
@@ -4696,13 +4708,18 @@ void K_RepairOrbitChain(mobj_t *orbit)
|
||||
{
|
||||
prev = cur;
|
||||
cur = cur->hnext;
|
||||
if (++num > player->kartstuff[k_itemamount])
|
||||
if (++num > orbit->target->player->kartstuff[k_itemamount])
|
||||
P_RemoveMobj(prev);
|
||||
else
|
||||
prev->movedir = num;
|
||||
}
|
||||
|
||||
player->kartstuff[k_itemamount] = num;
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (!P_MobjWasRemoved(orbit->target))
|
||||
#else
|
||||
if (orbit->target)
|
||||
#endif
|
||||
orbit->target->player->kartstuff[k_itemamount] = num;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4934,8 +4951,10 @@ static void K_MoveHeldObjects(player_t *player)
|
||||
cur->momx = FixedMul(FINECOSINE(cur->angle>>ANGLETOFINESHIFT), cur->extravalue1);
|
||||
cur->momy = FixedMul(FINESINE(cur->angle>>ANGLETOFINESHIFT), cur->extravalue1);
|
||||
cur->flags &= ~MF_NOCLIPTHING;
|
||||
|
||||
if (!P_TryMove(cur, player->mo->x + cur->momx, player->mo->y + cur->momy, true))
|
||||
P_SlideMove(cur, true);
|
||||
|
||||
if (P_IsObjectOnGround(player->mo))
|
||||
{
|
||||
if (P_MobjFlip(cur) > 0)
|
||||
|
||||
+13
-8
@@ -644,20 +644,22 @@ static int libd_drawScaled(lua_State *L)
|
||||
// KART: draw patch on minimap from x, y coordinates on the map
|
||||
static int libd_drawOnMinimap(lua_State *L)
|
||||
{
|
||||
fixed_t x, y, scale; // coordinates of the object
|
||||
patch_t *patch; // patch we want to draw
|
||||
UINT8 *colormap = NULL; // do we want to colormap this patch?
|
||||
boolean centered; // the patch is centered and doesn't need readjusting on x/y coordinates.
|
||||
fixed_t x, y, scale; // coordinates of the object
|
||||
patch_t *patch; // patch we want to draw
|
||||
UINT8 *colormap = NULL; // do we want to colormap this patch?
|
||||
boolean centered; // the patch is centered and doesn't need readjusting on x/y coordinates.
|
||||
huddrawlist_h list;
|
||||
patch_t *AutomapPic = NULL;
|
||||
drawinfo_t info;
|
||||
|
||||
// variables used to replicate k_kart's mmap drawer:
|
||||
patch_t *AutomapPic;
|
||||
|
||||
// variables used for actually drawing the icon:
|
||||
INT32 splitflags, minimaptrans;
|
||||
fixed_t amnumxpos, amnumypos;
|
||||
fixed_t amxpos, amypos;
|
||||
INT32 mm_x, mm_y;
|
||||
fixed_t patchw = 0, patchh = 0;
|
||||
fixed_t patchw, patchh;
|
||||
|
||||
HUDONLY // only run this function in hud hooks
|
||||
|
||||
@@ -722,8 +724,11 @@ static int libd_drawOnMinimap(lua_State *L)
|
||||
|
||||
mm_y -= AutomapPic->topoffset;
|
||||
|
||||
// patch is supposedly already centered, don't butt in.
|
||||
if (!centered)
|
||||
if (centered)
|
||||
{
|
||||
patchw = patchh = 0; // patch is supposedly already centered, don't butt in.
|
||||
}
|
||||
else
|
||||
{
|
||||
// scale patch coords
|
||||
patchw = (patch->width * scale / 2);
|
||||
|
||||
+1
-1
@@ -652,7 +652,7 @@ static int line_get(lua_State *L)
|
||||
LUA_PushUserdata(L, &sides[line->sidenum[0]], META_SIDE);
|
||||
return 1;
|
||||
case line_backside: // backside
|
||||
if (line->sidenum[1] == 0xffff)
|
||||
if (line->sidenum[1] == NO_INDEX)
|
||||
return 0;
|
||||
LUA_PushUserdata(L, &sides[line->sidenum[1]], META_SIDE);
|
||||
return 1;
|
||||
|
||||
+3
-3
@@ -845,7 +845,7 @@ void T_BounceCheese(levelspecthink_t *bouncer)
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->ceilingheight, 0, 1, -1); // update things on ceiling
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->floorheight, 0, 0, -1); // update things on floor
|
||||
bouncer->sector->ceilingdata = NULL;
|
||||
bouncer->sector->floordata = NULL;;
|
||||
bouncer->sector->floordata = NULL;
|
||||
bouncer->sector->moved = true;
|
||||
P_RemoveThinker(&bouncer->thinker); // remove bouncer from actives
|
||||
}
|
||||
@@ -2338,7 +2338,7 @@ void T_RaiseSector(levelspecthink_t *raise)
|
||||
fixed_t origspeed = raise->vars[3];
|
||||
|
||||
// Slow down as you get closer to the bottom
|
||||
raise->vars[3] = FixedMul(raise->vars[3],FixedDiv(raise->sector->ceilingheight - raise->vars[7], (raise->vars[5] - raise->vars[7])>>5));
|
||||
raise->vars[3] = FixedMul(raise->vars[3], FixedDiv(raise->sector->ceilingheight - raise->vars[7], (raise->vars[5] - raise->vars[7])>>5));
|
||||
|
||||
if (raise->vars[3] <= origspeed/16)
|
||||
raise->vars[3] = origspeed/16;
|
||||
@@ -2349,7 +2349,7 @@ void T_RaiseSector(levelspecthink_t *raise)
|
||||
{
|
||||
fixed_t origspeed = raise->vars[3];
|
||||
// Slow down as you get closer to the top
|
||||
raise->vars[3] = FixedMul(raise->vars[3],FixedDiv(raise->vars[5] - raise->sector->ceilingheight, (raise->vars[5] - raise->vars[7])>>5));
|
||||
raise->vars[3] = FixedMul(raise->vars[3], FixedDiv(raise->vars[5] - raise->sector->ceilingheight, (raise->vars[5] - raise->vars[7])>>5));
|
||||
|
||||
if (raise->vars[3] <= origspeed/16)
|
||||
raise->vars[3] = origspeed/16;
|
||||
|
||||
+106
-72
@@ -1462,49 +1462,15 @@ boolean P_CheckRacers(void)
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Kills an object.
|
||||
*
|
||||
* \param target The victim.
|
||||
* \param inflictor The attack weapon. May be NULL (environmental damage).
|
||||
* \param source The attacker. May be NULL.
|
||||
* \todo Cleanup, refactor, split up.
|
||||
* \sa P_DamageMobj
|
||||
*/
|
||||
void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
static void P_UpdateRemovedOrbital(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
{
|
||||
mobjtype_t item;
|
||||
mobj_t *mo;
|
||||
int ms;
|
||||
|
||||
if (target->flags & (MF_ENEMY|MF_BOSS))
|
||||
target->momx = target->momy = target->momz = 0;
|
||||
|
||||
// SRB2kart
|
||||
if (target->type != MT_PLAYER && !(target->flags & MF_MONITOR)
|
||||
&& !(target->type == MT_ORBINAUT || target->type == MT_ORBINAUT_SHIELD
|
||||
|| target->type == MT_JAWZ || target->type == MT_JAWZ_DUD || target->type == MT_JAWZ_SHIELD
|
||||
|| target->type == MT_BANANA || target->type == MT_BANANA_SHIELD
|
||||
|| target->type == MT_EGGMANITEM || target->type == MT_EGGMANITEM_SHIELD
|
||||
|| target->type == MT_BALLHOG || target->type == MT_SPB)) // kart dead items
|
||||
target->flags |= MF_NOGRAVITY; // Don't drop Tails 03-08-2000
|
||||
else
|
||||
target->flags &= ~MF_NOGRAVITY; // lose it if you for whatever reason have it, I'm looking at you shields
|
||||
//
|
||||
|
||||
if (target->flags2 & MF2_NIGHTSPULL)
|
||||
P_SetTarget(&target->tracer, NULL);
|
||||
|
||||
// dead target is no more shootable
|
||||
target->flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SPECIAL);
|
||||
target->flags2 &= ~(MF2_SKULLFLY|MF2_NIGHTSPULL);
|
||||
target->health = 0; // This makes it easy to check if something's dead elsewhere.
|
||||
|
||||
if (LUA_HookMobjDeath(target, inflictor, source) || P_MobjWasRemoved(target))
|
||||
return;
|
||||
|
||||
// SRB2kart
|
||||
// I wish I knew a better way to do this
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (!P_MobjWasRemoved(target->target) && target->target->player && !P_MobjWasRemoved(target->target->player->mo))
|
||||
#else
|
||||
if (target->target && target->target->player && target->target->player->mo)
|
||||
#endif
|
||||
{
|
||||
if (target->target->player->kartstuff[k_eggmanheld] && target->type == MT_EGGMANITEM_SHIELD)
|
||||
target->target->player->kartstuff[k_eggmanheld] = 0;
|
||||
@@ -1517,7 +1483,11 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
{
|
||||
if (target->movedir != 0 && target->movedir < (UINT16)target->target->player->kartstuff[k_itemamount])
|
||||
{
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (!P_MobjWasRemoved(target->target->hnext))
|
||||
#else
|
||||
if (target->target->hnext)
|
||||
#endif
|
||||
K_KillBananaChain(target->target->hnext, inflictor, source);
|
||||
|
||||
target->target->player->kartstuff[k_itemamount] = 0;
|
||||
@@ -1546,14 +1516,60 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
P_SetTarget(&target->target->hnext, NULL);
|
||||
}
|
||||
}
|
||||
// Above block does not clean up rocket sneakers when a player dies, so we need to do it here target->target is null when using rocket sneakers
|
||||
}
|
||||
|
||||
|
||||
/** Kills an object.
|
||||
*
|
||||
* \param target The victim.
|
||||
* \param inflictor The attack weapon. May be NULL (environmental damage).
|
||||
* \param source The attacker. May be NULL.
|
||||
* \todo Cleanup, refactor, split up.
|
||||
* \sa P_DamageMobj
|
||||
*/
|
||||
void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
{
|
||||
mobjtype_t item;
|
||||
mobj_t *mo;
|
||||
int ms;
|
||||
|
||||
if (target->flags & (MF_ENEMY|MF_BOSS))
|
||||
target->momx = target->momy = target->momz = 0;
|
||||
|
||||
// SRB2kart
|
||||
if (target->type != MT_PLAYER
|
||||
&& !(target->flags & MF_MONITOR)
|
||||
&& !(target->type == MT_ORBINAUT || target->type == MT_ORBINAUT_SHIELD
|
||||
|| target->type == MT_JAWZ || target->type == MT_JAWZ_DUD || target->type == MT_JAWZ_SHIELD
|
||||
|| target->type == MT_BANANA || target->type == MT_BANANA_SHIELD
|
||||
|| target->type == MT_EGGMANITEM || target->type == MT_EGGMANITEM_SHIELD
|
||||
|| target->type == MT_BALLHOG || target->type == MT_SPB)) // kart dead items
|
||||
target->flags |= MF_NOGRAVITY; // Don't drop Tails 03-08-2000
|
||||
else
|
||||
target->flags &= ~MF_NOGRAVITY; // lose it if you for whatever reason have it, I'm looking at you shields
|
||||
//
|
||||
|
||||
if (target->flags2 & MF2_NIGHTSPULL)
|
||||
P_SetTarget(&target->tracer, NULL);
|
||||
|
||||
// dead target is no more shootable
|
||||
target->flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SPECIAL);
|
||||
target->flags2 &= ~(MF2_SKULLFLY|MF2_NIGHTSPULL);
|
||||
target->health = 0; // This makes it easy to check if something's dead elsewhere.
|
||||
|
||||
if (LUA_HookMobjDeath(target, inflictor, source) || P_MobjWasRemoved(target))
|
||||
return;
|
||||
|
||||
P_UpdateRemovedOrbital(target, inflictor, source);
|
||||
|
||||
if (target->player)
|
||||
{
|
||||
// Above block does not clean up rocket sneakers when a player dies, so we need to do it here target->target is null when using rocket sneakers
|
||||
K_DropRocketSneaker(target->player);
|
||||
|
||||
// Let EVERYONE know what happened to a player! 01-29-2002 Tails
|
||||
if (target->player && !target->player->spectator)
|
||||
{
|
||||
target->flags2 &= ~MF2_DONTDRAW;
|
||||
// Let EVERYONE know what happened to a player! 01-29-2002 Tails
|
||||
if (!target->player->spectator)
|
||||
target->flags2 &= ~MF2_DONTDRAW;
|
||||
}
|
||||
|
||||
// if killed by a player
|
||||
@@ -1563,6 +1579,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
{
|
||||
P_SetTarget(&target->target, source);
|
||||
source->player->numboxes++;
|
||||
|
||||
if (cv_itemrespawn.value && (netgame || multiplayer))
|
||||
{
|
||||
target->fuse = cv_itemrespawntime.value*TICRATE + 2; // Random box generation
|
||||
@@ -1580,35 +1597,41 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
|
||||
target->player->playerstate = PST_DEAD;
|
||||
|
||||
if (cv_fading.value && P_IsLocalPlayer(target->player))
|
||||
if (P_IsLocalPlayer(target->player))
|
||||
{
|
||||
if (netgame || multiplayer)
|
||||
ms = cv_respawntime.value * 1000;
|
||||
else
|
||||
ms = 1000;
|
||||
if (cv_fading.value)
|
||||
{
|
||||
if (netgame || multiplayer)
|
||||
ms = cv_respawntime.value * 1000;
|
||||
else
|
||||
ms = 1000;
|
||||
|
||||
/*
|
||||
If the time spent with the music paused is less than half
|
||||
a second, continue playing the song (just mute it).
|
||||
*/
|
||||
if ((ms - cv_respawnfademusicout.value) < 500)
|
||||
S_FadeMusic(0, cv_respawnfademusicout.value);
|
||||
else
|
||||
S_FadeOutStopMusic(cv_respawnfademusicout.value);
|
||||
}
|
||||
/*
|
||||
* If the time spent with the music paused is less than half
|
||||
* a second, continue playing the song (just mute it).
|
||||
*/
|
||||
if ((ms - cv_respawnfademusicout.value) < 500)
|
||||
S_FadeMusic(0, cv_respawnfademusicout.value);
|
||||
else
|
||||
S_FadeOutStopMusic(cv_respawnfademusicout.value);
|
||||
}
|
||||
|
||||
for (UINT8 i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (target->player == P_GetLocalPlayerForNum(i))
|
||||
if (target->player == &players[consoleplayer])
|
||||
{
|
||||
// don't die in auto map,
|
||||
// switch view prior to dying
|
||||
if (i == 0 && automapactive)
|
||||
if (automapactive)
|
||||
AM_Stop();
|
||||
}
|
||||
|
||||
// added : 22-02-98: recenter view for next life...
|
||||
localaiming[i] = 0;
|
||||
break;
|
||||
for (UINT8 i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (target->player == P_GetLocalPlayerForNum(i))
|
||||
{
|
||||
// added : 22-02-98: recenter view for next life...
|
||||
localaiming[i] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1678,7 +1701,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
else
|
||||
prandom = P_RandomKey(5); // No placable object, just use a random number.
|
||||
|
||||
switch(prandom)
|
||||
switch (prandom)
|
||||
{
|
||||
default: item = MT_BUNNY; break;
|
||||
case 1: item = MT_BIRD; break;
|
||||
@@ -2222,16 +2245,26 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
return false;
|
||||
|
||||
// well no clue but this may happen ig
|
||||
if (!target || (target->health <= 0))
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(target))
|
||||
#else
|
||||
if (!target)
|
||||
#endif
|
||||
return false;
|
||||
|
||||
if (target->health <= 0)
|
||||
return false;
|
||||
|
||||
// Spectator handling
|
||||
if (netgame)
|
||||
{
|
||||
if (damage == DMG_SPECTATOR && target->player && target->player->spectator)
|
||||
damage = DMG_INSTAKILL;
|
||||
else if (target->player && target->player->spectator)
|
||||
return false;
|
||||
if (target->player && target->player->spectator)
|
||||
{
|
||||
if (damage == DMG_SPECTATOR)
|
||||
damage = DMG_INSTAKILL;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
if (source && source->player && source->player->spectator)
|
||||
return false;
|
||||
@@ -2337,6 +2370,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
{
|
||||
if (source == target)
|
||||
return false; // Don't hit yourself with your own paraloop, baka
|
||||
|
||||
if (source && source->player && !cv_friendlyfire.value
|
||||
&& (gametype == GT_COOP
|
||||
|| (G_GametypeHasTeams() && target->player->ctfteam == source->player->ctfteam)))
|
||||
@@ -2386,7 +2420,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
|
||||
else if (player->kartstuff[k_invincibilitytimer] > 0 || player->kartstuff[k_growshrinktimer] > 0 || player->powers[pw_flashing])
|
||||
{
|
||||
if (!force) // shoulddamage bypasses all of that.
|
||||
if (!force) // shoulddamage bypasses all of that.
|
||||
{
|
||||
K_DoInstashield(player);
|
||||
return false;
|
||||
|
||||
+10
-6
@@ -719,11 +719,11 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
if (thing->type != MT_PLAYER)
|
||||
return true;
|
||||
|
||||
if (thing->player && thing->player->powers[pw_flashing])
|
||||
return true;
|
||||
|
||||
if (thing->type == MT_PLAYER && thing->player)
|
||||
if (thing->player)
|
||||
{
|
||||
if (thing->player->powers[pw_flashing])
|
||||
return true;
|
||||
|
||||
if (tmthing->state == &states[S_MINEEXPLOSION1])
|
||||
K_ExplodePlayer(thing->player, tmthing->target, tmthing);
|
||||
else
|
||||
@@ -1077,6 +1077,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
thing->momy -= FixedMul(PUSHACCEL, thing->scale);
|
||||
tmthing->momy += FixedMul(PUSHACCEL, thing->scale);
|
||||
}
|
||||
|
||||
if (tmthing->momx > 0 && tmthing->momx > FixedMul(4*FRACUNIT, thing->scale)
|
||||
&& tmthing->momx > thing->momx)
|
||||
{
|
||||
@@ -1094,6 +1095,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
thing->momx = FixedMul(thing->info->speed, thing->scale);
|
||||
else if (thing->momx < -FixedMul(thing->info->speed, thing->scale))
|
||||
thing->momx = -FixedMul(thing->info->speed, thing->scale);
|
||||
|
||||
if (thing->momy > FixedMul(thing->info->speed, thing->scale))
|
||||
thing->momy = FixedMul(thing->info->speed, thing->scale);
|
||||
else if (thing->momy < -FixedMul(thing->info->speed, thing->scale))
|
||||
@@ -1105,6 +1107,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
tmthing->momx = FixedMul(4*FRACUNIT, thing->scale);
|
||||
else if (tmthing->momx < FixedMul(-4*FRACUNIT, thing->scale))
|
||||
tmthing->momx = FixedMul(-4*FRACUNIT, thing->scale);
|
||||
|
||||
if (tmthing->momy > FixedMul(4*FRACUNIT, thing->scale))
|
||||
tmthing->momy = FixedMul(4*FRACUNIT, thing->scale);
|
||||
else if (tmthing->momy < FixedMul(-4*FRACUNIT, thing->scale))
|
||||
@@ -1126,6 +1129,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
P_TouchSpecialThing(thing, tmthing, true); // can remove thing
|
||||
return true;
|
||||
}
|
||||
|
||||
// check again for special pickup
|
||||
if (tmthing->flags & MF_SPECIAL && thing->player)
|
||||
{
|
||||
@@ -1575,13 +1579,13 @@ static boolean PIT_CheckLine(line_t *ld)
|
||||
tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
|
||||
tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
|
||||
tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
|
||||
return true;
|
||||
return true; // didn't hit it
|
||||
|
||||
if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID))
|
||||
return true;
|
||||
|
||||
if (P_BoxOnLineSide(tmbbox, ld) != -1)
|
||||
return true;
|
||||
return true; // didn't hit it
|
||||
|
||||
if (tmthing->flags & MF_PAPERCOLLISION) // Caution! Turning whilst up against a wall will get you stuck. You probably shouldn't give the player this flag.
|
||||
{
|
||||
|
||||
+9
-2
@@ -242,7 +242,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
sector_t *back;
|
||||
fixed_t frontfloor, frontceiling, backfloor, backceiling;
|
||||
|
||||
if (linedef->sidenum[1] == 0xffff)
|
||||
if (linedef->sidenum[1] == NO_INDEX)
|
||||
{
|
||||
// single sided line
|
||||
openrange = 0;
|
||||
@@ -398,7 +398,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
{
|
||||
sector_t *front, *back;
|
||||
|
||||
if (linedef->sidenum[1] == 0xffff)
|
||||
if (linedef->sidenum[1] == NO_INDEX)
|
||||
{
|
||||
// single sided line
|
||||
openrange = 0;
|
||||
@@ -972,6 +972,10 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *))
|
||||
// First index is really empty, so +1 it.
|
||||
for (list = blockmaplump + offset + 1; *list != -1; list++)
|
||||
{
|
||||
#ifdef RANGECHECK
|
||||
if (*list < 0 || (UINT32)*list >= numlines)
|
||||
I_Error("P_BlockLinesIterator: index >= numlines");
|
||||
#endif
|
||||
ld = &lines[*list];
|
||||
|
||||
if (ld->validcount == validcount)
|
||||
@@ -1000,11 +1004,13 @@ boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *))
|
||||
for (mobj = blocklinks[y*bmapwidth + x]; mobj; mobj = bnext)
|
||||
{
|
||||
P_SetTarget(&bnext, mobj->bnext); // We want to note our reference to bnext here incase it is MF_NOTHINK and gets removed!
|
||||
|
||||
if (!func(mobj))
|
||||
{
|
||||
P_SetTarget(&bnext, NULL);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (P_MobjWasRemoved(tmthing) // func just popped our tmthing, cannot continue.
|
||||
|| (bnext && P_MobjWasRemoved(bnext))) // func just broke blockmap chain, cannot continue.
|
||||
{
|
||||
@@ -1012,6 +1018,7 @@ boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
P_SetTarget(&bnext, NULL);
|
||||
return true;
|
||||
}
|
||||
|
||||
+172
-125
@@ -1249,7 +1249,6 @@ static void P_PushableCheckBustables(mobj_t *mo)
|
||||
if (rover->master->frontsector->crumblestate)
|
||||
continue;
|
||||
|
||||
topheight = P_GetFOFTopZ(mo, node->m_sector, rover, mo->x, mo->y, NULL);
|
||||
bottomheight = P_GetFOFBottomZ(mo, node->m_sector, rover, mo->x, mo->y, NULL);
|
||||
|
||||
// Height checks
|
||||
@@ -1261,29 +1260,34 @@ static void P_PushableCheckBustables(mobj_t *mo)
|
||||
if (mo->z+mo->height > bottomheight)
|
||||
continue;
|
||||
}
|
||||
else if (rover->flags & FF_SPINBUST)
|
||||
{
|
||||
if (mo->z+mo->momz > topheight)
|
||||
continue;
|
||||
|
||||
if (mo->z+mo->height < bottomheight)
|
||||
continue;
|
||||
}
|
||||
else if (rover->flags & FF_SHATTER)
|
||||
{
|
||||
if (mo->z+mo->momz > topheight)
|
||||
continue;
|
||||
|
||||
if (mo->z+mo->momz + mo->height < bottomheight)
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo->z >= topheight)
|
||||
continue;
|
||||
topheight = P_GetFOFTopZ(mo, node->m_sector, rover, mo->x, mo->y, NULL);
|
||||
|
||||
if (mo->z+mo->height < bottomheight)
|
||||
continue;
|
||||
if (rover->flags & FF_SPINBUST)
|
||||
{
|
||||
if (mo->z+mo->momz > topheight)
|
||||
continue;
|
||||
|
||||
if (mo->z+mo->height < bottomheight)
|
||||
continue;
|
||||
}
|
||||
else if (rover->flags & FF_SHATTER)
|
||||
{
|
||||
if (mo->z+mo->momz > topheight)
|
||||
continue;
|
||||
|
||||
if (mo->z+mo->momz + mo->height < bottomheight)
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo->z >= topheight)
|
||||
continue;
|
||||
|
||||
if (mo->z+mo->height < bottomheight)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
EV_CrumbleChain(node->m_sector, rover);
|
||||
@@ -2950,7 +2954,8 @@ void P_MobjCheckWater(mobj_t *mobj)
|
||||
if ((mobj->eflags & MFE_VERTICALFLIP) && mobj->ceilingz-mobj->waterbottom <= FixedMul(mobj->info->height, mobj->scale)>>1)
|
||||
return;
|
||||
|
||||
if ((mobj->eflags & MFE_GOOWATER || wasingoo)) { // Decide what happens to your momentum when you enter/leave goopy water.
|
||||
if ((mobj->eflags & MFE_GOOWATER || wasingoo)) // Decide what happens to your momentum when you enter/leave goopy water.
|
||||
{
|
||||
if (P_MobjFlip(mobj)*mobj->momz < 0) // You are entering the goo?
|
||||
mobj->momz = FixedMul(mobj->momz, FixedDiv(2*FRACUNIT, 5*FRACUNIT)); // kill momentum significantly, to make the goo feel thick.
|
||||
}
|
||||
@@ -2964,6 +2969,7 @@ void P_MobjCheckWater(mobj_t *mobj)
|
||||
{
|
||||
// Spawn a splash
|
||||
mobj_t *splish;
|
||||
|
||||
if (mobj->eflags & MFE_VERTICALFLIP)
|
||||
{
|
||||
splish = P_SpawnMobj(mobj->x, mobj->y, mobj->waterbottom-FixedMul(mobjinfo[MT_SPLISH].height, mobj->scale), MT_SPLISH);
|
||||
@@ -2972,6 +2978,7 @@ void P_MobjCheckWater(mobj_t *mobj)
|
||||
}
|
||||
else
|
||||
splish = P_SpawnMobj(mobj->x, mobj->y, mobj->watertop, MT_SPLISH);
|
||||
|
||||
splish->destscale = mobj->scale;
|
||||
P_SetScale(splish, mobj->scale);
|
||||
}
|
||||
@@ -3372,7 +3379,11 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
|
||||
I_Assert(mobj->player != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(mobj));
|
||||
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
#else
|
||||
if (!mobj)
|
||||
#endif
|
||||
return;
|
||||
|
||||
P_MobjCheckWater(mobj);
|
||||
@@ -5161,9 +5172,9 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
{
|
||||
// Stunned after vector form
|
||||
if (mobj->movedir > ANGLE_180)
|
||||
mobj->angle -= FixedAngle(FixedMul(AngleFixed(InvAngle(mobj->movedir)),FixedDiv(mobj->reactiontime<<FRACBITS,24<<FRACBITS)));
|
||||
mobj->angle -= FixedAngle(FixedMul(AngleFixed(InvAngle(mobj->movedir)), FixedDiv(mobj->reactiontime<<FRACBITS,24<<FRACBITS)));
|
||||
else
|
||||
mobj->angle += FixedAngle(FixedMul(AngleFixed(mobj->movedir),FixedDiv(mobj->reactiontime<<FRACBITS,24<<FRACBITS)));
|
||||
mobj->angle += FixedAngle(FixedMul(AngleFixed(mobj->movedir), FixedDiv(mobj->reactiontime<<FRACBITS,24<<FRACBITS)));
|
||||
|
||||
mobj->reactiontime--;
|
||||
|
||||
@@ -5205,99 +5216,99 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
// It's time to attack! What are we gonna do?!
|
||||
switch(mobj->movecount)
|
||||
{
|
||||
case 0:
|
||||
default:
|
||||
// Fly up and prepare for an attack!
|
||||
// We have to charge up first, so let's go up into the air
|
||||
P_SetMobjState(mobj, mobj->info->raisestate);
|
||||
if (mobj->floorz >= mobj->target->floorz)
|
||||
mobj->watertop = mobj->floorz + 256*FRACUNIT;
|
||||
else
|
||||
mobj->watertop = mobj->target->floorz + 256*FRACUNIT;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
{
|
||||
// Okay, we're up? Good, time to gather energy...
|
||||
if (mobj->health > mobj->info->damage)
|
||||
{ // No more bubble if we're broken (pinch phase)
|
||||
mobj_t *shield = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_MSSHIELD_FRONT);
|
||||
P_SetTarget(&mobj->tracer, shield);
|
||||
P_SetTarget(&shield->target, mobj);
|
||||
}
|
||||
else
|
||||
P_LinedefExecute(LE_PINCHPHASE, mobj, NULL);
|
||||
mobj->fuse = 4*TICRATE;
|
||||
mobj->flags |= MF_PAIN;
|
||||
if (mobj->info->attacksound)
|
||||
S_StartSound(mobj, mobj->info->attacksound);
|
||||
A_FaceTarget(mobj);
|
||||
break;
|
||||
}
|
||||
|
||||
case 2:
|
||||
// We're all charged and ready now! Unleash the fury!!
|
||||
if (mobj->health > mobj->info->damage)
|
||||
{
|
||||
mobj_t *removemobj = mobj->tracer;
|
||||
P_SetTarget(&mobj->tracer, mobj->hnext);
|
||||
P_RemoveMobj(removemobj);
|
||||
}
|
||||
if (mobj->health <= mobj->info->damage)
|
||||
{
|
||||
// Attack 1: Pinball dash!
|
||||
if (mobj->health == 1)
|
||||
mobj->movedir = 0;
|
||||
case 0:
|
||||
default:
|
||||
// Fly up and prepare for an attack!
|
||||
// We have to charge up first, so let's go up into the air
|
||||
P_SetMobjState(mobj, mobj->info->raisestate);
|
||||
if (mobj->floorz >= mobj->target->floorz)
|
||||
mobj->watertop = mobj->floorz + 256*FRACUNIT;
|
||||
else
|
||||
mobj->movedir = 2;
|
||||
if (mobj->info->seesound)
|
||||
S_StartSound(mobj, mobj->info->seesound);
|
||||
P_SetMobjState(mobj, mobj->info->seestate);
|
||||
if (mobj->movedir == 2)
|
||||
mobj->threshold = 16; // bounce 16 times
|
||||
else
|
||||
mobj->threshold = 32; // bounce 32 times
|
||||
mobj->watertop = mobj->target->floorz + 16*FRACUNIT;
|
||||
P_LinedefExecute(LE_PINCHPHASE, mobj, NULL);
|
||||
}
|
||||
else
|
||||
mobj->watertop = mobj->target->floorz + 256*FRACUNIT;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
{
|
||||
// Attack 2: Energy shot!
|
||||
mobj->movedir = 1;
|
||||
|
||||
if (mobj->health >= 8)
|
||||
mobj->extravalue1 = 0;
|
||||
else if (mobj->health >= 5)
|
||||
mobj->extravalue1 = 2;
|
||||
else if (mobj->health >= 4)
|
||||
mobj->extravalue1 = 1;
|
||||
else
|
||||
mobj->extravalue1 = 3;
|
||||
|
||||
switch(mobj->extravalue1)
|
||||
{
|
||||
case 0: // shoot once
|
||||
case 2: // spread-shot
|
||||
default:
|
||||
mobj->threshold = 2;
|
||||
break;
|
||||
case 1: // shoot 3 times
|
||||
mobj->threshold = 3*2;
|
||||
break;
|
||||
case 3: // shoot like a goddamn machinegun
|
||||
mobj->threshold = 8*2;
|
||||
break;
|
||||
// Okay, we're up? Good, time to gather energy...
|
||||
if (mobj->health > mobj->info->damage)
|
||||
{ // No more bubble if we're broken (pinch phase)
|
||||
mobj_t *shield = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_MSSHIELD_FRONT);
|
||||
P_SetTarget(&mobj->tracer, shield);
|
||||
P_SetTarget(&shield->target, mobj);
|
||||
}
|
||||
else
|
||||
P_LinedefExecute(LE_PINCHPHASE, mobj, NULL);
|
||||
mobj->fuse = 4*TICRATE;
|
||||
mobj->flags |= MF_PAIN;
|
||||
if (mobj->info->attacksound)
|
||||
S_StartSound(mobj, mobj->info->attacksound);
|
||||
A_FaceTarget(mobj);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
// Return to idle.
|
||||
mobj->watertop = mobj->target->floorz + 32*FRACUNIT;
|
||||
P_SetMobjState(mobj, mobj->info->spawnstate);
|
||||
mobj->flags &= ~MF_PAIN;
|
||||
mobj->fuse = 10*TICRATE;
|
||||
break;
|
||||
case 2:
|
||||
// We're all charged and ready now! Unleash the fury!!
|
||||
if (mobj->health > mobj->info->damage)
|
||||
{
|
||||
mobj_t *removemobj = mobj->tracer;
|
||||
P_SetTarget(&mobj->tracer, mobj->hnext);
|
||||
P_RemoveMobj(removemobj);
|
||||
}
|
||||
if (mobj->health <= mobj->info->damage)
|
||||
{
|
||||
// Attack 1: Pinball dash!
|
||||
if (mobj->health == 1)
|
||||
mobj->movedir = 0;
|
||||
else
|
||||
mobj->movedir = 2;
|
||||
if (mobj->info->seesound)
|
||||
S_StartSound(mobj, mobj->info->seesound);
|
||||
P_SetMobjState(mobj, mobj->info->seestate);
|
||||
if (mobj->movedir == 2)
|
||||
mobj->threshold = 16; // bounce 16 times
|
||||
else
|
||||
mobj->threshold = 32; // bounce 32 times
|
||||
mobj->watertop = mobj->target->floorz + 16*FRACUNIT;
|
||||
P_LinedefExecute(LE_PINCHPHASE, mobj, NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Attack 2: Energy shot!
|
||||
mobj->movedir = 1;
|
||||
|
||||
if (mobj->health >= 8)
|
||||
mobj->extravalue1 = 0;
|
||||
else if (mobj->health >= 5)
|
||||
mobj->extravalue1 = 2;
|
||||
else if (mobj->health >= 4)
|
||||
mobj->extravalue1 = 1;
|
||||
else
|
||||
mobj->extravalue1 = 3;
|
||||
|
||||
switch (mobj->extravalue1)
|
||||
{
|
||||
case 0: // shoot once
|
||||
case 2: // spread-shot
|
||||
default:
|
||||
mobj->threshold = 2;
|
||||
break;
|
||||
case 1: // shoot 3 times
|
||||
mobj->threshold = 3*2;
|
||||
break;
|
||||
case 3: // shoot like a goddamn machinegun
|
||||
mobj->threshold = 8*2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
// Return to idle.
|
||||
mobj->watertop = mobj->target->floorz + 32*FRACUNIT;
|
||||
P_SetMobjState(mobj, mobj->info->spawnstate);
|
||||
mobj->flags &= ~MF_PAIN;
|
||||
mobj->fuse = 10*TICRATE;
|
||||
break;
|
||||
}
|
||||
mobj->movecount++;
|
||||
mobj->movecount %= 4;
|
||||
@@ -5315,6 +5326,7 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
// Face your target
|
||||
angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y); // absolute angle
|
||||
angle = (angle-mobj->angle); // relative angle
|
||||
|
||||
if (angle < ANGLE_180)
|
||||
mobj->angle += angle/8;
|
||||
else
|
||||
@@ -5326,18 +5338,19 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
|| mobj->target->player->powers[pw_invulnerability]
|
||||
|| mobj->target->player->powers[pw_super]))
|
||||
danger = false;
|
||||
if (mobj->target->x+mobj->target->radius+abs(mobj->target->momx*2) < mobj->x-mobj->radius)
|
||||
else if (mobj->target->x+mobj->target->radius+abs(mobj->target->momx*2) < mobj->x-mobj->radius)
|
||||
danger = false;
|
||||
if (mobj->target->x-mobj->target->radius-abs(mobj->target->momx*2) > mobj->x+mobj->radius)
|
||||
else if (mobj->target->x-mobj->target->radius-abs(mobj->target->momx*2) > mobj->x+mobj->radius)
|
||||
danger = false;
|
||||
if (mobj->target->y+mobj->target->radius+abs(mobj->target->momy*2) < mobj->y-mobj->radius)
|
||||
else if (mobj->target->y+mobj->target->radius+abs(mobj->target->momy*2) < mobj->y-mobj->radius)
|
||||
danger = false;
|
||||
if (mobj->target->y-mobj->target->radius-abs(mobj->target->momy*2) > mobj->y+mobj->radius)
|
||||
else if (mobj->target->y-mobj->target->radius-abs(mobj->target->momy*2) > mobj->y+mobj->radius)
|
||||
danger = false;
|
||||
if (mobj->target->z+mobj->target->height+mobj->target->momz*2 < mobj->z)
|
||||
else if (mobj->target->z+mobj->target->height+mobj->target->momz*2 < mobj->z)
|
||||
danger = false;
|
||||
if (mobj->target->z+mobj->target->momz*2 > mobj->z+mobj->height)
|
||||
else if (mobj->target->z+mobj->target->momz*2 > mobj->z+mobj->height)
|
||||
danger = false;
|
||||
|
||||
if (danger)
|
||||
{
|
||||
// An incoming attack is detected! What should we do?!
|
||||
@@ -5345,21 +5358,27 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
mobj->movedir = ANGLE_11hh - FixedAngle(FixedMul(AngleFixed(ANGLE_11hh), FixedDiv((mobj->info->spawnhealth - mobj->health)<<FRACBITS, (mobj->info->spawnhealth-1)<<FRACBITS)));
|
||||
if (P_RandomChance(FRACUNIT/2))
|
||||
mobj->movedir = InvAngle(mobj->movedir);
|
||||
|
||||
mobj->threshold = 6 + (FixedMul(24<<FRACBITS, FixedDiv((mobj->info->spawnhealth - mobj->health)<<FRACBITS, (mobj->info->spawnhealth-1)<<FRACBITS))>>FRACBITS);
|
||||
|
||||
if (mobj->info->activesound)
|
||||
S_StartSound(mobj, mobj->info->activesound);
|
||||
if (mobj->info->painchance)
|
||||
P_SetMobjState(mobj, mobj->info->painchance);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Move normally: Approach the player using normal thrust and simulated friction.
|
||||
dist = P_AproxDistance(mobj->x-mobj->target->x, mobj->y-mobj->target->y);
|
||||
|
||||
P_Thrust(mobj, R_PointToAngle2(0, 0, mobj->momx, mobj->momy), -3*FRACUNIT/8);
|
||||
|
||||
if (dist < 64*FRACUNIT)
|
||||
P_Thrust(mobj, mobj->angle, -4*FRACUNIT);
|
||||
else if (dist > 180*FRACUNIT)
|
||||
P_Thrust(mobj, mobj->angle, FRACUNIT);
|
||||
|
||||
mobj->momz += P_AproxDistance(mobj->momx, mobj->momy)/12; // Move up higher the faster you're going.
|
||||
}
|
||||
}
|
||||
@@ -5614,7 +5633,11 @@ void P_SetScale(mobj_t *mobj, fixed_t newscale)
|
||||
player_t *player;
|
||||
fixed_t oldscale;
|
||||
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
#else
|
||||
if (!mobj)
|
||||
#endif
|
||||
return;
|
||||
|
||||
oldscale = mobj->scale; //keep for adjusting stuff below
|
||||
@@ -8663,14 +8686,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
|
||||
{
|
||||
const angle_t fa = (i*FINEANGLES/16) & FINEMASK;
|
||||
ns = FixedMul(64 * FRACUNIT, mobj->scale);
|
||||
x = mobj->x + FixedMul(FINESINE(fa),ns);
|
||||
y = mobj->y + FixedMul(FINECOSINE(fa),ns);
|
||||
x = mobj->x + FixedMul(FINESINE(fa), ns);
|
||||
y = mobj->y + FixedMul(FINECOSINE(fa), ns);
|
||||
|
||||
mo2 = P_SpawnMobj(x, y, z, MT_EXPLODE);
|
||||
ns = FixedMul(16 * FRACUNIT, mobj->scale);
|
||||
mo2->momx = FixedMul(FINESINE(fa),ns);
|
||||
mo2->momy = FixedMul(FINECOSINE(fa),ns);
|
||||
mo2->momx = FixedMul(FINESINE(fa), ns);
|
||||
mo2->momy = FixedMul(FINECOSINE(fa), ns);
|
||||
}
|
||||
|
||||
z -= FixedMul(32*FRACUNIT, mobj->scale);
|
||||
}
|
||||
P_SetMobjState(mobj, mobj->info->deathstate);
|
||||
@@ -8864,9 +8888,9 @@ static void P_IceBlockFuseThink(mobj_t *mobj)
|
||||
for (i = 0; i < 5; i++)
|
||||
{
|
||||
mobj_t *debris = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_SMK_ICEBLOCK_DEBRIS);
|
||||
debris->angle = FixedAngle(P_RandomRange(0,360)<<FRACBITS);
|
||||
P_InstaThrust(debris, debris->angle, P_RandomRange(3,18)*(FRACUNIT/4));
|
||||
debris->momz = P_RandomRange(4,8)<<FRACBITS;
|
||||
debris->angle = FixedAngle(P_RandomRange(0, 360)<<FRACBITS);
|
||||
P_InstaThrust(debris, debris->angle, P_RandomRange(3, 18)*(FRACUNIT/4));
|
||||
debris->momz = P_RandomRange(4, 8)<<FRACBITS;
|
||||
if (!i) // kinda hacky :V
|
||||
S_StartSound(debris, sfx_s3k82);
|
||||
}
|
||||
@@ -8962,7 +8986,11 @@ static boolean P_FuseThink(mobj_t *mobj)
|
||||
static boolean P_MobjPushableThink(mobj_t *mobj)
|
||||
{
|
||||
// would be cool if we could use P_MobjWasRemoved Zzz...
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
#else
|
||||
if (!mobj)
|
||||
#endif
|
||||
return false;
|
||||
|
||||
P_MobjCheckWater(mobj);
|
||||
@@ -9167,6 +9195,14 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
|| P_WeaponOrPanel(mobj->type))
|
||||
{
|
||||
P_TryMove(mobj, mobj->x, mobj->y, true); // Sets mo->standingslope correctly
|
||||
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj)) // anything that calls checkposition can be lethal
|
||||
#else
|
||||
if (!mobj) // anything that calls checkposition can be lethal
|
||||
#endif
|
||||
return;
|
||||
|
||||
P_ButteredSlope(mobj);
|
||||
}
|
||||
|
||||
@@ -9192,6 +9228,13 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
#else
|
||||
if (!mobj)
|
||||
#endif
|
||||
return; // obligatory paranoia check
|
||||
|
||||
// Can end up here if a player dies.
|
||||
P_CycleMobjState(mobj);
|
||||
|
||||
@@ -9249,7 +9292,11 @@ void P_PushableThinker(mobj_t *mobj)
|
||||
|
||||
I_Assert(!P_MobjWasRemoved(mobj));
|
||||
|
||||
#ifndef COMPAT_VANILLA
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
#else
|
||||
if (!mobj)
|
||||
#endif
|
||||
return;
|
||||
|
||||
sec = mobj->subsector->sector;
|
||||
|
||||
+9
-4
@@ -691,7 +691,7 @@ static void ArchiveLines(savebuffer_t *save)
|
||||
if (spawnli->special == 321 || spawnli->special == 322) // only reason li->callcount would be non-zero is if either of these are involved
|
||||
diff |= LD_CLLCOUNT;
|
||||
|
||||
if (li->sidenum[0] != 0xffff)
|
||||
if (li->sidenum[0] != NO_INDEX)
|
||||
{
|
||||
si = &sides[li->sidenum[0]];
|
||||
spawnsi = &spawnsides[li->sidenum[0]];
|
||||
@@ -706,7 +706,8 @@ static void ArchiveLines(savebuffer_t *save)
|
||||
if (si->midtexture != spawnsi->midtexture)
|
||||
diff |= LD_S1MIDTEX;
|
||||
}
|
||||
if (li->sidenum[1] != 0xffff)
|
||||
|
||||
if (li->sidenum[1] != NO_INDEX)
|
||||
{
|
||||
si = &sides[li->sidenum[1]];
|
||||
spawnsi = &spawnsides[li->sidenum[1]];
|
||||
@@ -786,6 +787,7 @@ static void UnArchiveFFloors(savebuffer_t *save, const sector_t *ss)
|
||||
I_Error("Sector does not have any ffloors!");
|
||||
|
||||
fflr_i = READUINT16(save->p); // get first modified ffloor's number ready
|
||||
|
||||
for (;;) // for some reason the usual for (rover = x; ...) thing doesn't work here?
|
||||
{
|
||||
if (fflr_i == 0xffff) // end of modified ffloors list, let's stop already
|
||||
@@ -3510,7 +3512,7 @@ static void P_ReloadSaveLevelData(void)
|
||||
li->firsttag = spawnli->firsttag;
|
||||
li->nexttag = spawnli->nexttag;
|
||||
|
||||
if (li->sidenum[0] != 0xffff)
|
||||
if (li->sidenum[0] != NO_INDEX)
|
||||
{
|
||||
si = &sides[li->sidenum[0]];
|
||||
spawnsi = &spawnsides[li->sidenum[0]];
|
||||
@@ -3521,7 +3523,7 @@ static void P_ReloadSaveLevelData(void)
|
||||
si->midtexture = spawnsi->midtexture;
|
||||
}
|
||||
|
||||
if (li->sidenum[1] != 0xffff)
|
||||
if (li->sidenum[1] != NO_INDEX)
|
||||
{
|
||||
si = &sides[li->sidenum[1]];
|
||||
spawnsi = &spawnsides[li->sidenum[1]];
|
||||
@@ -3588,8 +3590,11 @@ FUNCINLINE static ATTRINLINE boolean P_NetUnArchiveMisc(savebuffer_t *save, bool
|
||||
if (!P_SetupLevel(true, reloading))
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Can't load the level!\n"));
|
||||
P_FreeCorruptMapWarnings();
|
||||
return false;
|
||||
}
|
||||
|
||||
P_PrintCorruptMapWarnings();
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
+209
-37
@@ -188,6 +188,57 @@ FUNCNORETURN static ATTRNORETURN void CorruptMapError(const char *msg)
|
||||
I_Error("Invalid or corrupt map.\nLook in log file or text console for technical details.");
|
||||
}
|
||||
|
||||
static char **mapwarnings = NULL;
|
||||
static size_t nummapwarnings = 0;
|
||||
|
||||
// collect map errors we can fix clientside
|
||||
// we then can print em when the map finishes loading
|
||||
// so they actually appear and raise awareness shits fucked
|
||||
// see G_DoLoadLevel as to why :chaosleep:
|
||||
static void CorruptMapWarning(const char *msg)
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
// just error out
|
||||
I_Error("%sThis WILL crash Vanilla clients!\n", msg);
|
||||
#endif
|
||||
nummapwarnings++;
|
||||
mapwarnings = Z_Realloc(mapwarnings, nummapwarnings * sizeof(*mapwarnings), PU_STATIC, NULL);
|
||||
mapwarnings[nummapwarnings-1] = Z_StrDup(msg);
|
||||
}
|
||||
|
||||
void P_PrintCorruptMapWarnings(void)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!nummapwarnings)
|
||||
return;
|
||||
|
||||
for (i = 0; i < nummapwarnings; i++)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "%sAttempting to fix... This WILL crash Vanilla clients!\n", mapwarnings[i]);
|
||||
}
|
||||
|
||||
P_FreeCorruptMapWarnings();
|
||||
}
|
||||
|
||||
void P_FreeCorruptMapWarnings(void)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!nummapwarnings)
|
||||
return;
|
||||
|
||||
for (i = 0; i < nummapwarnings; i++)
|
||||
{
|
||||
Z_Free(mapwarnings[i]);
|
||||
mapwarnings[i] = NULL;
|
||||
}
|
||||
|
||||
Z_Free(mapwarnings);
|
||||
mapwarnings = NULL;
|
||||
nummapwarnings = 0;
|
||||
}
|
||||
|
||||
#define NUMLAPS_DEFAULT 3
|
||||
|
||||
static void P_ClearMapHeaderLighting(mapheader_lighting_t *lighting)
|
||||
@@ -437,8 +488,39 @@ static void P_LoadSegs(UINT8 *data)
|
||||
|
||||
for (i = 0; i < numsegs; i++, li++, ml++)
|
||||
{
|
||||
li->v1 = &vertexes[SHORT(ml->v1)];
|
||||
li->v2 = &vertexes[SHORT(ml->v2)];
|
||||
INT16 v1, v2;
|
||||
|
||||
v1 = SHORT(ml->v1);
|
||||
v2 = SHORT(ml->v2);
|
||||
|
||||
// e6y
|
||||
// check and fix wrong references to non-existent vertexes
|
||||
// see e1m9 @ NIVELES.WAD
|
||||
// http://www.doomworld.com/idgames/index.php?id=12647
|
||||
if ((unsigned)v1 >= numvertexes || (unsigned)v2 >= numvertexes)
|
||||
{
|
||||
if ((unsigned)v1 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v1));
|
||||
if ((unsigned)v2 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v2));
|
||||
|
||||
if (li->sidedef == &sides[li->linedef->sidenum[0]])
|
||||
{
|
||||
li->v1 = lines[ml->linedef].v1;
|
||||
li->v2 = lines[ml->linedef].v2;
|
||||
}
|
||||
else
|
||||
{
|
||||
li->v1 = lines[ml->linedef].v2;
|
||||
li->v2 = lines[ml->linedef].v1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
li->v1 = &vertexes[v1];
|
||||
li->v2 = &vertexes[v2];
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
@@ -455,14 +537,59 @@ static void P_LoadSegs(UINT8 *data)
|
||||
li->angle = (SHORT(ml->angle))<<FRACBITS;
|
||||
li->offset = (SHORT(ml->offset))<<FRACBITS;
|
||||
rawlinedef = SHORT(ml->linedef);
|
||||
|
||||
//e6y: check for wrong indexes
|
||||
if ((unsigned)rawlinedef >= numlines)
|
||||
{
|
||||
I_Error("P_LoadSegs: seg %s references a non-existent linedef %d", sizeu1(i), (unsigned)rawlinedef);
|
||||
}
|
||||
|
||||
ldef = &lines[rawlinedef];
|
||||
li->linedef = ldef;
|
||||
li->side = rawside = SHORT(ml->side);
|
||||
rawside = SHORT(ml->side);
|
||||
|
||||
//e6y: fix wrong side index
|
||||
if (rawside != 0 && rawside != 1)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s contains wrong side index %d.\n", sizeu1(i), rawside));
|
||||
rawside = 1;
|
||||
}
|
||||
|
||||
//e6y: check for wrong indexes
|
||||
if (ldef->sidenum[rawside] >= numsides)
|
||||
{
|
||||
I_Error("P_LoadSegs: linedef %d for seg %s references a non-existent sidedef %d", rawlinedef, sizeu1(i), ldef->sidenum[rawside]);
|
||||
}
|
||||
|
||||
li->side = rawside;
|
||||
|
||||
li->sidedef = &sides[ldef->sidenum[rawside]];
|
||||
li->frontsector = sides[ldef->sidenum[rawside]].sector;
|
||||
|
||||
/* cph 2006/09/30 - our frontsector can be the second side of the
|
||||
* linedef, so must check for NO_INDEX in case we are incorrectly
|
||||
* referencing the back of a 1S line */
|
||||
if (ldef->sidenum[rawside] == NO_INDEX)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadSegs: front of seg %s has no sidedef\n", sizeu1(i)));
|
||||
li->frontsector = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
li->frontsector = sides[ldef->sidenum[rawside]].sector;
|
||||
}
|
||||
|
||||
if (ldef->flags & ML_TWOSIDED)
|
||||
li->backsector = sides[ldef->sidenum[rawside^1]].sector;
|
||||
{
|
||||
if (ldef->sidenum[rawside^1] == NO_INDEX)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadSegs: back of seg %s has no sidedef while being marked as double sided\n", sizeu1(i)));
|
||||
li->backsector = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
li->backsector = sides[ldef->sidenum[rawside^1]].sector;
|
||||
}
|
||||
}
|
||||
|
||||
P_UpdateSegLightOffset(li);
|
||||
}
|
||||
@@ -738,7 +865,33 @@ static void P_LoadNodes(UINT8 *data)
|
||||
|
||||
for (j = 0; j < 2; j++)
|
||||
{
|
||||
no->children[j] = SHORT(mn->children[j]);
|
||||
UINT16 child;
|
||||
|
||||
child = SHORT(mn->children[j]);
|
||||
|
||||
if (child & NF_SUBSECTOR)
|
||||
{
|
||||
// Convert to extended type
|
||||
child &= ~NF_SUBSECTOR;
|
||||
|
||||
// haleyjd 11/06/10: check for invalid subsector reference
|
||||
if (child >= numsubsectors)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadNodes: BSP tree %s references invalid subsector %d\n", sizeu1(i), child));
|
||||
child = 0;
|
||||
}
|
||||
|
||||
child |= NF_SUBSECTOR;
|
||||
}
|
||||
else if (child >= numnodes)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadNodes: BSP node %s references invalid node.\n", sizeu1(i)));
|
||||
//I_Error("P_LoadNodes: BSP node %d references invalid node %d.\n", sizeu1(i), Index(((node_t *)no->children[j])));
|
||||
child = 0;
|
||||
}
|
||||
|
||||
no->children[j] = child;
|
||||
|
||||
for (k = 0; k < 4; k++)
|
||||
no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
|
||||
}
|
||||
@@ -1001,9 +1154,9 @@ static void P_InitializeLinedef(line_t *ld)
|
||||
// cph 2002/07/20 - these errors are fatal if not fixed, so apply them
|
||||
for (j = 0; j < 2; j++)
|
||||
{
|
||||
if (ld->sidenum[j] != 0xffff && ld->sidenum[j] >= (UINT16)numsides)
|
||||
if (ld->sidenum[j] != NO_INDEX && ld->sidenum[j] >= (UINT16)numsides)
|
||||
{
|
||||
ld->sidenum[j] = 0xffff;
|
||||
ld->sidenum[j] = NO_INDEX;
|
||||
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has out-of-range sidedef number\n", sizeu1((size_t)(ld - lines)));
|
||||
}
|
||||
}
|
||||
@@ -1011,23 +1164,24 @@ static void P_InitializeLinedef(line_t *ld)
|
||||
ld->firsttag = ld->nexttag = -1;
|
||||
|
||||
// killough 11/98: fix common wad errors (missing sidedefs):
|
||||
if (ld->sidenum[0] == 0xffff)
|
||||
if (ld->sidenum[0] == NO_INDEX)
|
||||
{
|
||||
ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side
|
||||
// cph - print a warning about the bug
|
||||
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s missing first sidedef\n", sizeu1((size_t)(ld - lines)));
|
||||
}
|
||||
|
||||
if ((ld->sidenum[1] == 0xffff) && (ld->flags & ML_TWOSIDED))
|
||||
if ((ld->sidenum[1] == NO_INDEX) && (ld->flags & ML_TWOSIDED))
|
||||
{
|
||||
ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side
|
||||
// cph - print a warning about the bug
|
||||
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has two-sided flag set, but no second sidedef\n", sizeu1((size_t)(ld - lines)));
|
||||
}
|
||||
|
||||
if (ld->sidenum[0] != 0xffff && ld->special)
|
||||
// killough 4/4/98: support special sidedef interpretation below
|
||||
if (ld->sidenum[0] != NO_INDEX && ld->special)
|
||||
sides[ld->sidenum[0]].special = ld->special;
|
||||
if (ld->sidenum[1] != 0xffff && ld->special)
|
||||
if (ld->sidenum[1] != NO_INDEX && ld->special)
|
||||
sides[ld->sidenum[1]].special = ld->special;
|
||||
}
|
||||
|
||||
@@ -1060,10 +1214,10 @@ static void P_LoadLineDefs2(void)
|
||||
for (; i--; ld++)
|
||||
{
|
||||
ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
|
||||
ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : NULL;
|
||||
ld->backsector = ld->sidenum[1] != NO_INDEX ? sides[ld->sidenum[1]].sector : NULL;
|
||||
|
||||
// Repeat count for midtexture
|
||||
if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff))
|
||||
if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != NO_INDEX))
|
||||
{
|
||||
sides[ld->sidenum[0]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) >> 12);
|
||||
sides[ld->sidenum[0]].textureoffset = (((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
|
||||
@@ -1079,13 +1233,13 @@ static void P_LoadLineDefs2(void)
|
||||
{
|
||||
size_t len = strlen(sides[ld->sidenum[0]].text)+1;
|
||||
|
||||
if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
|
||||
if (ld->sidenum[1] != NO_INDEX && sides[ld->sidenum[1]].text)
|
||||
len += strlen(sides[ld->sidenum[1]].text);
|
||||
|
||||
ld->text = Z_Malloc(len, PU_LEVEL, NULL);
|
||||
memcpy(ld->text, sides[ld->sidenum[0]].text, strlen(sides[ld->sidenum[0]].text)+1);
|
||||
|
||||
if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
|
||||
if (ld->sidenum[1] != NO_INDEX && sides[ld->sidenum[1]].text)
|
||||
memcpy(ld->text+strlen(ld->text)+1, sides[ld->sidenum[1]].text, strlen(sides[ld->sidenum[1]].text)+1);
|
||||
}
|
||||
break;
|
||||
@@ -1747,16 +1901,11 @@ static boolean P_LoadRawBlockMap(UINT8 *data, size_t count)
|
||||
// http://www.doomworld.com/idgames/index.php?id=12935
|
||||
if (!P_VerifyBlockMap(count))
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
I_Error("P_LoadBlockMap: erroneous BLOCKMAP lump may cause crashes.\n");
|
||||
#endif
|
||||
CONS_Alert(CONS_ERROR, "P_LoadBlockMap: erroneous BLOCKMAP lump may cause crashes.\n");
|
||||
|
||||
//Z_Free(blockmaplump);
|
||||
//blockmaplump = NULL;
|
||||
//return false; // ideally we would just let the game rebuild the blockmap
|
||||
// but this has a chance of desynching vanilla clients
|
||||
// not sure whats worse honestly and i do not want to decide that :chaosleep:
|
||||
CorruptMapWarning(va("P_LoadBlockMap: corrupted or invalid BLOCKMAP lump! Check the log for more information.\n"));
|
||||
// vanilla WILL crash here anyways so just rebuild it ourselves
|
||||
Z_Free(blockmaplump);
|
||||
blockmaplump = NULL;
|
||||
return false;
|
||||
}
|
||||
|
||||
// clear out mobj chains
|
||||
@@ -1793,22 +1942,35 @@ static void P_GroupLines(void)
|
||||
for (i = 0; i < numsubsectors; i++, ss++)
|
||||
{
|
||||
if (ss->firstline >= numsegs)
|
||||
{
|
||||
CorruptMapError(va("P_GroupLines: ss->firstline invalid "
|
||||
"(subsector %s, firstline refers to %d of %s)", sizeu1(i), ss->firstline,
|
||||
sizeu2(numsegs)));
|
||||
}
|
||||
|
||||
seg = &segs[ss->firstline];
|
||||
sidei = (size_t)(seg->sidedef - sides);
|
||||
|
||||
if (!seg->sidedef)
|
||||
{
|
||||
CorruptMapError(va("P_GroupLines: seg->sidedef is NULL "
|
||||
"(subsector %s, firstline is %d)", sizeu1(i), ss->firstline));
|
||||
}
|
||||
|
||||
if (seg->sidedef - sides < 0 || seg->sidedef - sides > (UINT16)numsides)
|
||||
{
|
||||
CorruptMapError(va("P_GroupLines: seg->sidedef refers to sidedef %s of %s "
|
||||
"(subsector %s, firstline is %d)", sizeu1(sidei), sizeu2(numsides),
|
||||
sizeu3(i), ss->firstline));
|
||||
}
|
||||
|
||||
if (!seg->sidedef->sector)
|
||||
{
|
||||
CorruptMapError(va("P_GroupLines: seg->sidedef->sector is NULL "
|
||||
"(subsector %s, firstline is %d, sidedef is %s)", sizeu1(i), ss->firstline,
|
||||
sizeu1(sidei)));
|
||||
}
|
||||
|
||||
ss->sector = seg->sidedef->sector;
|
||||
}
|
||||
|
||||
@@ -1886,11 +2048,16 @@ static void P_LoadReject(UINT8 *data, size_t rejectsize)
|
||||
{
|
||||
if (rejectsize < neededsize)
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
I_Error("REJECT is %s byte%s too small. REJECT might be invalid and crash vanilla clients!\n", sizeu1(neededsize - rejectsize), (neededsize - rejectsize) == 1 ? "" : "s");
|
||||
#endif
|
||||
CONS_Alert(CONS_ERROR, "REJECT is %s byte%s too small. REJECT might be invalid and crash vanilla clients!\n", sizeu1(neededsize - rejectsize), (neededsize - rejectsize) == 1 ? "" : "s");
|
||||
CorruptMapWarning(va("P_LoadReject: REJECT is %s byte%s too small. REJECT might be invalid!\n", sizeu1(neededsize - rejectsize), (neededsize - rejectsize) == 1 ? "" : "s"));
|
||||
#ifdef COMPAT_VANILLA
|
||||
// we can pad this and somewhat prevent desyncs
|
||||
// probs not cool if the reject is from a completely different map
|
||||
// but whatever
|
||||
allocsize = neededsize;
|
||||
#else
|
||||
rejectmatrix = NULL;
|
||||
return;
|
||||
#endif
|
||||
}
|
||||
|
||||
rejectmatrix = Z_Calloc(allocsize, PU_LEVEL, NULL); // allocate memory for the reject matrix
|
||||
@@ -2329,7 +2496,9 @@ static void P_LoadRecordGhosts(void)
|
||||
if (!gpath)
|
||||
return;
|
||||
|
||||
sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(gamemap));
|
||||
const char *mapname = G_BuildMapName(gamemap);
|
||||
|
||||
sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, mapname);
|
||||
|
||||
// Best Time ghost
|
||||
if (cv_ghost_besttime.value)
|
||||
@@ -2379,9 +2548,10 @@ static void P_LoadRecordGhosts(void)
|
||||
{
|
||||
lumpnum_t l;
|
||||
UINT8 j = 1;
|
||||
while (j <= 99 && (l = W_CheckNumForName(va("%sS%02u",G_BuildMapName(gamemap),j))) != LUMPERROR)
|
||||
|
||||
while (j <= 99 && (l = W_CheckNumForName(va("%sS%02u", mapname, j))) != LUMPERROR)
|
||||
{
|
||||
G_AddGhost(va("%sS%02u",G_BuildMapName(gamemap),j));
|
||||
G_AddGhost(va("%sS%02u", mapname, j));
|
||||
j++;
|
||||
}
|
||||
}
|
||||
@@ -2423,10 +2593,12 @@ static void P_InitMinimapInfo(void)
|
||||
Patch_Free(minimapinfo.minimap_pic);
|
||||
minimapinfo.minimap_pic = NULL;
|
||||
|
||||
lumpnum = W_CheckNumForName(va("%sR", G_BuildMapName(gamemap)));
|
||||
const char *mapname = G_BuildMapName(gamemap);
|
||||
|
||||
lumpnum = W_CheckNumForName(va("%sR", mapname));
|
||||
|
||||
if (lumpnum != LUMPERROR)
|
||||
minimapinfo.minimap_pic = W_CachePatchName(va("%sR", G_BuildMapName(gamemap)), PU_PATCH);
|
||||
minimapinfo.minimap_pic = W_CachePatchName(va("%sR", mapname), PU_PATCH);
|
||||
|
||||
minimapinfo.min_x = bsp->bbox[0][BOXLEFT];
|
||||
minimapinfo.max_x = bsp->bbox[0][BOXRIGHT];
|
||||
@@ -2567,14 +2739,14 @@ static void P_SetupPlayer(void)
|
||||
// Start players with pity shields if possible
|
||||
players[i].pity = -1;
|
||||
|
||||
players[i].mo = NULL;
|
||||
|
||||
if (!G_RaceGametype())
|
||||
{
|
||||
players[i].mo = NULL;
|
||||
G_DoReborn(i);
|
||||
}
|
||||
else // gametype is GT_COOP or GT_RACE
|
||||
{
|
||||
players[i].mo = NULL;
|
||||
G_SpawnPlayer(i, (players[i].starposttime));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -114,6 +114,9 @@ size_t P_PrecacheLevelFlats(void);
|
||||
|
||||
void P_AllocMapHeader(INT16 i);
|
||||
|
||||
void P_PrintCorruptMapWarnings(void);
|
||||
void P_FreeCorruptMapWarnings(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
+12
-9
@@ -889,7 +889,7 @@ static boolean PolyDoor(line_t *line)
|
||||
pdd.angle = line->angle; // angle of motion
|
||||
pdd.distance = sides[line->sidenum[0]].rowoffset;
|
||||
|
||||
if (line->sidenum[1] != 0xffff)
|
||||
if (line->sidenum[1] != NO_INDEX)
|
||||
pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics
|
||||
else
|
||||
pdd.delay = 0;
|
||||
@@ -899,7 +899,7 @@ static boolean PolyDoor(line_t *line)
|
||||
pdd.speed = sides[line->sidenum[0]].textureoffset >> FRACBITS; // angular speed
|
||||
pdd.distance = sides[line->sidenum[0]].rowoffset >> FRACBITS; // angular distance
|
||||
|
||||
if (line->sidenum[1] != 0xffff)
|
||||
if (line->sidenum[1] != NO_INDEX)
|
||||
pdd.delay = sides[line->sidenum[1]].textureoffset >> FRACBITS; // delay in tics
|
||||
else
|
||||
pdd.delay = 0;
|
||||
@@ -1989,8 +1989,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
INT32 position = (INT32)max(sides[line->sidenum[0]].midtexture, 0);
|
||||
UINT32 prefadems = (UINT32)max(sides[line->sidenum[0]].textureoffset >> FRACBITS, 0);
|
||||
UINT32 postfadems = (UINT32)max(sides[line->sidenum[0]].rowoffset >> FRACBITS, 0);
|
||||
UINT8 fadetarget = (UINT8)max((line->sidenum[1] != 0xffff) ? sides[line->sidenum[1]].textureoffset >> FRACBITS : 0, 0);
|
||||
INT16 fadesource = (INT16)max((line->sidenum[1] != 0xffff) ? sides[line->sidenum[1]].rowoffset >> FRACBITS : -1, -1);
|
||||
UINT8 fadetarget = (UINT8)max((line->sidenum[1] != NO_INDEX) ? sides[line->sidenum[1]].textureoffset >> FRACBITS : 0, 0);
|
||||
INT16 fadesource = (INT16)max((line->sidenum[1] != NO_INDEX) ? sides[line->sidenum[1]].rowoffset >> FRACBITS : -1, -1);
|
||||
|
||||
// Seek offset from current song position
|
||||
if (line->flags & ML_EFFECT1)
|
||||
@@ -2504,7 +2504,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
|
||||
var1 = sides[line->sidenum[0]].toptexture; //(line->dx>>FRACBITS)-1;
|
||||
|
||||
if (line->sidenum[1] != 0xffff && line->flags & ML_BLOCKMONSTERS) // read power from back sidedef
|
||||
if (line->sidenum[1] != NO_INDEX && line->flags & ML_BLOCKMONSTERS) // read power from back sidedef
|
||||
var2 = sides[line->sidenum[1]].toptexture;
|
||||
else if (line->flags & ML_NOCLIMB) // 'Infinite'
|
||||
var2 = UINT16_MAX;
|
||||
@@ -2633,7 +2633,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
if (always || this->bottomtexture)
|
||||
this->bottomtexture = set->bottomtexture;
|
||||
|
||||
if (lines[linenum].sidenum[1] == 0xffff)
|
||||
if (lines[linenum].sidenum[1] == NO_INDEX)
|
||||
continue; // One-sided stops here.
|
||||
|
||||
// Back side
|
||||
@@ -2682,7 +2682,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
sector_t *sec;
|
||||
mobj_t *thing;
|
||||
|
||||
if (line->sidenum[1] != 0xffff)
|
||||
if (line->sidenum[1] != NO_INDEX)
|
||||
state = (statenum_t)sides[line->sidenum[1]].toptexture;
|
||||
|
||||
while ((secnum = P_FindSectorFromLineTag(line, secnum)) >= 0)
|
||||
@@ -4609,11 +4609,13 @@ void P_UpdateSpecials(void)
|
||||
// POINT LIMIT
|
||||
P_CheckPointLimit();
|
||||
|
||||
#ifdef COMPAT_VANILLA
|
||||
// Dynamic slopeness
|
||||
// we run this here only when not joined midrace
|
||||
// for vanilla compat reasons :chaosleep:
|
||||
if (!midgamejoin)
|
||||
P_RunDynamicSlopes();
|
||||
#endif
|
||||
|
||||
P_UpdateAnimFlats();
|
||||
}
|
||||
@@ -5484,6 +5486,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
if ((lines[i].flags & (ML_NOSONIC|ML_NOTAILS)) != (ML_NOSONIC|ML_NOTAILS)) // If you can do something...
|
||||
{
|
||||
angle_t flatangle = InvAngle(lines[i].angle);
|
||||
|
||||
fixed_t xoffs;
|
||||
fixed_t yoffs;
|
||||
|
||||
@@ -6056,7 +6059,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
break;
|
||||
|
||||
case 259: // Make-Your-Own FOF!
|
||||
if (lines[i].sidenum[1] != 0xffff)
|
||||
if (lines[i].sidenum[1] != NO_INDEX)
|
||||
{
|
||||
UINT8 *data;
|
||||
UINT16 b;
|
||||
@@ -6785,7 +6788,7 @@ static void P_SpawnScrollers(void)
|
||||
case 506:
|
||||
s = lines[i].sidenum[1];
|
||||
|
||||
if (s != 0xffff)
|
||||
if (s != NO_INDEX)
|
||||
Add_Scroller(sc_side, -sides[s].textureoffset, sides[s].rowoffset, -1, lines[i].sidenum[0], accel, 0);
|
||||
else
|
||||
CONS_Debug(DBG_GAMELOGIC, "Line special 506 (line #%s) missing 2nd side!\n", sizeu1(i));
|
||||
|
||||
@@ -646,7 +646,9 @@ void P_Ticker(boolean run)
|
||||
if (run)
|
||||
{
|
||||
// Dynamic slopeness
|
||||
#ifdef COMPAT_VANILLA
|
||||
if (midgamejoin) // only run here if we joined midgame to fix some desynchs
|
||||
#endif
|
||||
P_RunDynamicSlopes();
|
||||
|
||||
PS_START_TIMING(ps_thinkertime);
|
||||
|
||||
+1
-1
@@ -3739,7 +3739,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
||||
fixed_t f1, f2;
|
||||
|
||||
// We probably shouldn't move the camera if there is no player or player mobj somehow
|
||||
if (!player || !player->mo)
|
||||
if (!player || P_MobjWasRemoved(player->mo))
|
||||
return true;
|
||||
|
||||
// This can happen when joining
|
||||
|
||||
+1
-1
@@ -430,7 +430,7 @@ typedef struct line_s
|
||||
INT16 tag;
|
||||
|
||||
// Visual appearance: sidedefs.
|
||||
UINT16 sidenum[2]; // sidenum[1] will be 0xffff if one-sided
|
||||
UINT16 sidenum[2]; // sidenum[1] will be NO_INDEX if one-sided
|
||||
fixed_t alpha; // translucency
|
||||
UINT8 blendmode; // blendmode
|
||||
|
||||
|
||||
+1
-1
@@ -289,7 +289,7 @@ void R_ParseSPRTINFOLump(UINT16 wadNum, UINT16 lumpNum)
|
||||
sprinfoLumpLength = W_LumpLengthPwad(wadNum, lumpNum);
|
||||
sprinfoText = (char *)Z_Malloc((sprinfoLumpLength+1)*sizeof(char),PU_STATIC,NULL);
|
||||
// Now move the contents of the lump into this new location.
|
||||
memmove(sprinfoText,sprinfoLump,sprinfoLumpLength);
|
||||
memmove(sprinfoText, sprinfoLump, sprinfoLumpLength);
|
||||
// Make damn well sure the last character in our new memory location is \0.
|
||||
sprinfoText[sprinfoLumpLength] = '\0';
|
||||
// Finally, free up the memory from the first data load, because we really
|
||||
|
||||
+19
-14
@@ -311,6 +311,7 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
|
||||
{
|
||||
rw_scalestep = drawseg->scalestep;
|
||||
spryscale = drawseg->scale1 + (x1 - drawseg->x1)*rw_scalestep;
|
||||
|
||||
if (dc->numlights)
|
||||
{ // reset all lights to their starting heights
|
||||
for (i = 0; i < dc->numlights; i++)
|
||||
@@ -435,6 +436,7 @@ static void R_RenderMaskedSegLoop(drawcolumndata_t* dc, drawseg_t *drawseg, INT3
|
||||
windowtop = windowbottom + 1;
|
||||
set_colormap_below_light();
|
||||
}
|
||||
|
||||
windowbottom = realbot;
|
||||
if (windowtop < windowbottom)
|
||||
colfunc_2s(dc, col);
|
||||
@@ -2204,7 +2206,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
topremap = (encoremap && !(curline->linedef->flags & ML_TFERLINE));
|
||||
|
||||
if ((linedef->flags & (ML_DONTPEGTOP) && (linedef->flags & ML_DONTPEGBOTTOM))
|
||||
&& linedef->sidenum[1] != 0xffff)
|
||||
&& linedef->sidenum[1] != NO_INDEX)
|
||||
{
|
||||
// Special case... use offsets from 2nd side but only if it has a texture.
|
||||
side_t *def = &sides[linedef->sidenum[1]];
|
||||
@@ -2615,8 +2617,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
|
||||
auto set_topstep_normal = [&]
|
||||
{
|
||||
topstep = -FixedMul (rw_scalestep, worldtop);
|
||||
topfrac = (centeryfrac>>4) - FixedMul (worldtop, rw_scale);
|
||||
topstep = -FixedMul(rw_scalestep, worldtop);
|
||||
topfrac = (centeryfrac>>4) - FixedMul(worldtop, rw_scale);
|
||||
};
|
||||
|
||||
// untextured seg
|
||||
@@ -2625,7 +2627,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
const bool tophigh = (worldhigh <= worldtop && worldhighslope <= worldtopslope);
|
||||
|
||||
// if we cant see the goddamn skyplane, well there wont be any skybox
|
||||
// we could kill skyVisible instead, but i want to keep the performance improvemnts it yields
|
||||
// we could kill skyVisible instead, but i want to keep the performance improvements it yields
|
||||
// so we do this absolute trash
|
||||
if ((tophigh
|
||||
&& (frontsector->floorpic != skyflatnum && frontsector->ceilingpic != skyflatnum)) // try to guess if its a "window"
|
||||
@@ -2637,14 +2639,16 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
// this is an attempt to fix issues with textureless single sided lines drawing nothing where they should just draw sky instead
|
||||
if (tophigh && !backsector && frontsector->ceilingpic == skyflatnum)
|
||||
{
|
||||
topstep = -FixedMul (rw_scalestep, worldbottom);
|
||||
topfrac = (centeryfrac>>4) - FixedMul (worldbottom, rw_scale);
|
||||
|
||||
// account for slopes to try and get rid of sharp edges from the black void
|
||||
if (frontsector->f_slope || (backsector && backsector->f_slope))
|
||||
{
|
||||
topstep = -FixedMul (rw_scalestep, worldbottomslope);
|
||||
topfrac = (centeryfrac>>4) - FixedMul (worldbottomslope, rw_scale);
|
||||
topstep = -FixedMul(rw_scalestep, worldbottomslope);
|
||||
topfrac = (centeryfrac>>4) - FixedMul(worldbottomslope, rw_scale);
|
||||
}
|
||||
else
|
||||
{
|
||||
topstep = -FixedMul(rw_scalestep, worldbottom);
|
||||
topfrac = (centeryfrac>>4) - FixedMul(worldbottom, rw_scale);
|
||||
}
|
||||
}
|
||||
else
|
||||
@@ -2653,18 +2657,18 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
else
|
||||
set_topstep_normal();
|
||||
|
||||
bottomstep = -FixedMul (rw_scalestep, worldbottom);
|
||||
bottomfrac = (centeryfrac>>4) - FixedMul (worldbottom, rw_scale);
|
||||
bottomstep = -FixedMul(rw_scalestep, worldbottom);
|
||||
bottomfrac = (centeryfrac>>4) - FixedMul(worldbottom, rw_scale);
|
||||
|
||||
if (frontsector->c_slope)
|
||||
{
|
||||
fixed_t topfracend = (centeryfrac>>4) - FixedMul (worldtopslope, ds_p->scale2);
|
||||
fixed_t topfracend = (centeryfrac>>4) - FixedMul(worldtopslope, ds_p->scale2);
|
||||
topstep = (topfracend-topfrac)/(range);
|
||||
}
|
||||
|
||||
if (frontsector->f_slope)
|
||||
{
|
||||
fixed_t bottomfracend = (centeryfrac>>4) - FixedMul (worldbottomslope, ds_p->scale2);
|
||||
fixed_t bottomfracend = (centeryfrac>>4) - FixedMul(worldbottomslope, ds_p->scale2);
|
||||
bottomstep = (bottomfracend-bottomfrac)/(range);
|
||||
}
|
||||
}
|
||||
@@ -2782,7 +2786,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
|
||||
if (bottomtexture)
|
||||
{
|
||||
fixed_t bottomfracend = (centeryfrac>>4) - FixedMul (worldlowslope, ds_p->scale2);
|
||||
fixed_t bottomfracend = (centeryfrac>>4) - FixedMul(worldlowslope, ds_p->scale2);
|
||||
|
||||
pixlow = (centeryfrac>>4) - FixedMul (worldlow, rw_scale);
|
||||
pixlowstep = (bottomfracend-pixlow)/(range);
|
||||
@@ -3045,6 +3049,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
ds_p->silhouette |= SIL_BOTTOM;
|
||||
ds_p->bsilheight = backsector->f_slope ? INT32_MAX : backsector->floorheight;
|
||||
}
|
||||
|
||||
if (!(ds_p->silhouette & SIL_TOP))
|
||||
{
|
||||
ds_p->silhouette |= SIL_TOP;
|
||||
|
||||
+1
-1
@@ -712,7 +712,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
// skip to end of this skin's frames
|
||||
lastlump = lump;
|
||||
|
||||
while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname,4)==0)
|
||||
while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname, 4) == 0)
|
||||
lastlump++;
|
||||
|
||||
// allocate (or replace) sprite frames, and set spritedef
|
||||
|
||||
+1
-1
@@ -131,7 +131,7 @@ void R_AddWallSplat(line_t *wallline, INT16 sectorside, const char *patchname, f
|
||||
// set the splat
|
||||
splat->patch = W_GetNumForName(patchname);
|
||||
sectorside ^= 1;
|
||||
if (wallline->sidenum[sectorside] != 0xffff)
|
||||
if (wallline->sidenum[sectorside] != NO_INDEX)
|
||||
{
|
||||
backsector = sides[wallline->sidenum[sectorside]].sector;
|
||||
|
||||
|
||||
+36
-28
@@ -182,15 +182,14 @@ 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);
|
||||
// Let's not complain about multiple L/R rotations. It's not worth the effort.
|
||||
|
||||
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))
|
||||
@@ -233,6 +232,7 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
|
||||
// when using sprites in pwad : the lumppat points the new graphics
|
||||
sprtemp[frame].lumppat[rotation] = lumppat;
|
||||
sprtemp[frame].lumpid[rotation] = lumpid;
|
||||
|
||||
if (flipped)
|
||||
sprtemp[frame].flip |= (1<<rotation);
|
||||
else
|
||||
@@ -261,9 +261,11 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
|
||||
softwarepatch_t patch;
|
||||
UINT8 numadded = 0;
|
||||
|
||||
memset(sprtemp,0xFF, sizeof (sprtemp));
|
||||
memset(sprtemp, 0xFF, sizeof(sprtemp));
|
||||
maxframe = (size_t)-1;
|
||||
|
||||
spritename = sprname;
|
||||
|
||||
// are we 'patching' a sprite already loaded ?
|
||||
// if so, it might patch only certain frames, not all
|
||||
if (spritedef->numframes) // (then spriteframes is not null)
|
||||
@@ -289,7 +291,7 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
|
||||
|
||||
if (frame >= 64 || !(R_ValidSpriteAngle(rotation))) // Give an actual NAME error -_-...
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum,l));
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum, l));
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -315,6 +317,15 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
|
||||
{
|
||||
frame = R_Char2Frame(lumpinfo[l].name[6]);
|
||||
rotation = (UINT8)(lumpinfo[l].name[7] - '0');
|
||||
|
||||
/*
|
||||
if (frame >= 64 || !(R_ValidSpriteAngle(rotation))) // 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);
|
||||
}
|
||||
|
||||
@@ -363,30 +374,32 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
|
||||
switch (sprtemp[frame].rotate)
|
||||
{
|
||||
case SRF_NONE:
|
||||
// no rotations were found for that frame at all
|
||||
I_Error("R_AddSingleSpriteDef: No patches found for %.4s frame %c", sprname, R_Frame2Char(frame));
|
||||
break;
|
||||
// no rotations were found for that frame at all
|
||||
I_Error("R_AddSingleSpriteDef: No patches found for %.4s frame %c", sprname, R_Frame2Char(frame));
|
||||
break;
|
||||
|
||||
case SRF_SINGLE:
|
||||
// only the first rotation is needed
|
||||
break;
|
||||
// only the first rotation is needed
|
||||
break;
|
||||
|
||||
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 %s frame %c is missing rotations",
|
||||
sprname, R_Frame2Char(frame));
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
// must have all 8 frames
|
||||
for (rotation = 0; rotation < 8; 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));
|
||||
break;
|
||||
// must have all 8 frames
|
||||
for (rotation = 0; rotation < 8; 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));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -394,7 +407,6 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
|
||||
if (spritedef->numframes && // has been allocated
|
||||
spritedef->numframes < maxframe) // more frames are defined ?
|
||||
{
|
||||
|
||||
Z_Free(spritedef->spriteframes);
|
||||
spritedef->spriteframes = NULL;
|
||||
}
|
||||
@@ -451,12 +463,10 @@ void R_AddSpriteDefs(UINT16 wadnum)
|
||||
//
|
||||
for (i = 0; i < numsprites; i++)
|
||||
{
|
||||
spritename = sprnames[i];
|
||||
|
||||
if (spritename[4] && wadnum >= (UINT16)spritename[4])
|
||||
if (sprnames[i][4] && wadnum >= (UINT16)sprnames[i][4])
|
||||
continue;
|
||||
|
||||
if (R_AddSingleSpriteDef(spritename, &sprites[i], wadnum, start, end))
|
||||
if (R_AddSingleSpriteDef(sprnames[i], &sprites[i], wadnum, start, end))
|
||||
{
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
@@ -464,9 +474,7 @@ void R_AddSpriteDefs(UINT16 wadnum)
|
||||
#endif
|
||||
// if a new sprite was added (not just replaced)
|
||||
addsprites++;
|
||||
#ifndef ZDEBUG
|
||||
CONS_Debug(DBG_SETUP, "sprite %s set in pwad %d\n", spritename, wadnum);
|
||||
#endif
|
||||
CONS_Debug(DBG_SETUP, "sprite %s set in pwad %d\n", sprnames[i], wadnum);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -937,6 +937,7 @@ static boolean S_AdjustSoundParams(const mobj_t *listener, const mobj_t *source,
|
||||
listener_t listensource;
|
||||
INT32 i;
|
||||
|
||||
// e6y
|
||||
if (!listener)
|
||||
return false;
|
||||
|
||||
|
||||
Reference in new issue
Block a user