Merge branch 'Saturn-Next' into unglobsavep
This commit is contained in:
commit
86ea7dde40
42 files changed
+2102
-1841
No files matched your search
@@ -28,6 +28,7 @@ LOCAL_SRC_FILES := am_map.c \
|
||||
m_cheat.c \
|
||||
m_fixed.c \
|
||||
m_menu.c \
|
||||
m_textinput.c \
|
||||
m_misc.c \
|
||||
m_queue.c \
|
||||
m_random.c \
|
||||
|
||||
+553
-551
File diff suppressed because it is too large.
Load diff
+7
-6
@@ -213,9 +213,9 @@ DOSATURNSYNCH=1
|
||||
ifndef NOSATURNJOIN
|
||||
DOSATURNJOIN=1
|
||||
endif
|
||||
#ifndef NOSATURNPAK
|
||||
#DOSATURNPAK=1
|
||||
#endif
|
||||
ifndef NOSATURNPAK
|
||||
DOSATURNPAK=1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
@@ -404,9 +404,9 @@ OPTS+=-DDOSATURNSYNCH
|
||||
ifndef NOSATURNJOIN
|
||||
OPTS+=-DDOSATURNJOIN
|
||||
endif
|
||||
#ifndef NOSATURNPAK
|
||||
#OPTS+=-DDOSATURNPAK
|
||||
#endif
|
||||
ifndef NOSATURNPAK
|
||||
OPTS+=-DDOSATURNPAK
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
@@ -529,6 +529,7 @@ OBJS:=$(i_main_o) \
|
||||
$(OBJDIR)/m_fixed.o \
|
||||
$(OBJDIR)/m_menu.o \
|
||||
$(OBJDIR)/m_misc.o \
|
||||
$(OBJDIR)/m_textinput.o \
|
||||
$(OBJDIR)/m_perfstats.o \
|
||||
$(OBJDIR)/m_random.o \
|
||||
$(OBJDIR)/m_queue.o \
|
||||
|
||||
+48
-348
@@ -32,6 +32,7 @@
|
||||
#include "i_threads.h"
|
||||
#include "d_main.h"
|
||||
#include "m_menu.h"
|
||||
#include "m_textinput.h"
|
||||
#include "filesrch.h"
|
||||
|
||||
#ifdef HWRENDER
|
||||
@@ -97,9 +98,7 @@ static char inputlines[32][CON_MAXPROMPTCHARS]; // hold last 32 prompt lines
|
||||
|
||||
static INT32 inputline; // current input line number
|
||||
static INT32 inputhist; // line number of history input line to restore
|
||||
static size_t input_cur; // position of cursor in line
|
||||
static size_t input_sel; // position of selection marker (I.E.: anything between this and input_cur is "selected")
|
||||
static size_t input_len; // length of current line, used to bound cursor and such
|
||||
static textinput_t input;
|
||||
// notice: input does NOT include the "$" at the start of the line. - 11/3/16
|
||||
|
||||
// protos.
|
||||
@@ -458,7 +457,8 @@ static void CON_InputInit(void)
|
||||
// prepare the first prompt line
|
||||
memset(inputlines, 0, sizeof (inputlines));
|
||||
inputline = 0;
|
||||
input_cur = input_sel = input_len = 0;
|
||||
|
||||
M_TextInputInit(&input, inputlines[inputline], CON_MAXPROMPTCHARS);
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
@@ -802,178 +802,6 @@ void CON_Ticker(void)
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
//
|
||||
// ----
|
||||
//
|
||||
// Shortcuts for adding and deleting characters, strings, and sections
|
||||
// Necessary due to moving cursor
|
||||
//
|
||||
|
||||
static void CON_InputClear(void)
|
||||
{
|
||||
Lock_state();
|
||||
|
||||
memset(inputlines[inputline], 0, CON_MAXPROMPTCHARS);
|
||||
input_cur = input_sel = input_len = 0;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputSetString(const char *c)
|
||||
{
|
||||
Lock_state();
|
||||
|
||||
memset(inputlines[inputline], 0, CON_MAXPROMPTCHARS);
|
||||
strcpy(inputlines[inputline], c);
|
||||
input_cur = input_sel = input_len = strlen(c);
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputAddString(const char *c)
|
||||
{
|
||||
size_t csize = strlen(c);
|
||||
|
||||
Lock_state();
|
||||
|
||||
if (input_len + csize > CON_MAXPROMPTCHARS-1)
|
||||
{
|
||||
Unlock_state();
|
||||
return;
|
||||
}
|
||||
if (input_cur != input_len)
|
||||
memmove(&inputlines[inputline][input_cur+csize], &inputlines[inputline][input_cur], input_len-input_cur);
|
||||
memcpy(&inputlines[inputline][input_cur], c, csize);
|
||||
input_len += csize;
|
||||
input_sel = (input_cur += csize);
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputDel(size_t start, size_t end)
|
||||
{
|
||||
size_t len;
|
||||
|
||||
Lock_state();
|
||||
|
||||
len = (end - start);
|
||||
|
||||
if (end != input_len)
|
||||
memmove(&inputlines[inputline][start], &inputlines[inputline][end], input_len-end);
|
||||
memset(&inputlines[inputline][input_len - len], 0, len);
|
||||
|
||||
input_len -= len;
|
||||
|
||||
if (input_sel >= end)
|
||||
input_sel -= len;
|
||||
else if (input_sel > start)
|
||||
input_sel = start;
|
||||
|
||||
if (input_cur >= end)
|
||||
input_cur -= len;
|
||||
else if (input_cur > start)
|
||||
input_cur = start;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputDelSelection(void)
|
||||
{
|
||||
size_t start, end;
|
||||
|
||||
Lock_state();
|
||||
|
||||
if (input_cur > input_sel)
|
||||
{
|
||||
start = input_sel;
|
||||
end = input_cur;
|
||||
}
|
||||
else
|
||||
{
|
||||
start = input_cur;
|
||||
end = input_sel;
|
||||
}
|
||||
|
||||
CON_InputDel(start, end);
|
||||
|
||||
input_sel = input_cur = start;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_ToWordEnd(boolean move_sel)
|
||||
{
|
||||
Lock_state();
|
||||
|
||||
// Skip spaces
|
||||
while (input_cur < input_len && isspace(inputlines[inputline][input_cur]))
|
||||
++input_cur;
|
||||
|
||||
// Skip word
|
||||
while (input_cur < input_len && !isspace(inputlines[inputline][input_cur]))
|
||||
++input_cur;
|
||||
|
||||
if (move_sel) input_sel = input_cur;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_ToWordBegin(boolean move_sel)
|
||||
{
|
||||
Lock_state();
|
||||
|
||||
// Hack, always move back 1 character if possible so if we press ctrl-left at a word beginning
|
||||
// we move to previous word
|
||||
if (input_cur) --input_cur;
|
||||
|
||||
// Skip spaces
|
||||
while (input_cur && isspace(inputlines[inputline][input_cur]))
|
||||
--input_cur;
|
||||
|
||||
// Skip word
|
||||
while (input_cur && !isspace(inputlines[inputline][input_cur]))
|
||||
--input_cur;
|
||||
|
||||
// Unless we reached beginning of line, we're pointing at a space before word, so move cursor
|
||||
// forward to fix that
|
||||
if (input_cur) ++input_cur;
|
||||
|
||||
if (move_sel) input_sel = input_cur;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputAddChar(char c)
|
||||
{
|
||||
if (input_len >= CON_MAXPROMPTCHARS-1)
|
||||
return;
|
||||
|
||||
Lock_state();
|
||||
|
||||
if (input_cur != input_len)
|
||||
memmove(&inputlines[inputline][input_cur+1], &inputlines[inputline][input_cur], input_len-input_cur);
|
||||
inputlines[inputline][input_cur++] = c;
|
||||
inputlines[inputline][++input_len] = 0;
|
||||
input_sel = input_cur;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
static void CON_InputDelChar(void)
|
||||
{
|
||||
if (!input_cur)
|
||||
return;
|
||||
|
||||
Lock_state();
|
||||
|
||||
if (input_cur != input_len)
|
||||
memmove(&inputlines[inputline][input_cur-1], &inputlines[inputline][input_cur], input_len-input_cur);
|
||||
inputlines[inputline][--input_len] = 0;
|
||||
input_sel = --input_cur;
|
||||
|
||||
Unlock_state();
|
||||
}
|
||||
|
||||
//
|
||||
// ----
|
||||
//
|
||||
@@ -1054,6 +882,10 @@ boolean CON_Responder(event_t *ev)
|
||||
}
|
||||
}
|
||||
|
||||
Lock_state();
|
||||
M_TextInputHandle(&input, key);
|
||||
Unlock_state();
|
||||
|
||||
// Always eat ctrl/shift/alt if console open, so the menu doesn't get ideas
|
||||
if (key == KEY_LSHIFT || key == KEY_RSHIFT
|
||||
|| key == KEY_LCTRL || key == KEY_RCTRL
|
||||
@@ -1066,12 +898,11 @@ boolean CON_Responder(event_t *ev)
|
||||
// show all cvars/commands that match what we have inputted
|
||||
if (key == KEY_TAB)
|
||||
{
|
||||
|
||||
if (!completion[0])
|
||||
{
|
||||
if (!input_len || input_len >= 40 || strchr(inputlines[inputline], ' '))
|
||||
if (!input.length || input.length >= 40 || strchr(input.buffer, ' '))
|
||||
return true;
|
||||
strcpy(completion, inputlines[inputline]);
|
||||
strcpy(completion, input.buffer);
|
||||
comskips = varskips = 0;
|
||||
}
|
||||
|
||||
@@ -1092,74 +923,9 @@ boolean CON_Responder(event_t *ev)
|
||||
return true;
|
||||
}
|
||||
|
||||
if (key == 'x' || key == 'X')
|
||||
{
|
||||
if (input_sel > input_cur)
|
||||
I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
|
||||
else
|
||||
I_ClipboardCopy(&inputlines[inputline][input_sel], input_cur-input_sel);
|
||||
CON_InputDelSelection();
|
||||
// Those are already handled in M_TextInputHandle, but they do extra logic... Maybe textinput_t should have some sort of callbacks?
|
||||
if (key == 'x' || key == 'X' || key == 'v' || key == 'V')
|
||||
completion[0] = 0;
|
||||
return true;
|
||||
}
|
||||
else if (key == 'c' || key == 'C')
|
||||
{
|
||||
if (input_sel > input_cur)
|
||||
I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
|
||||
else
|
||||
I_ClipboardCopy(&inputlines[inputline][input_sel], input_cur-input_sel);
|
||||
return true;
|
||||
}
|
||||
else if (key == 'v' || key == 'V')
|
||||
{
|
||||
const char *paste = I_ClipboardPaste();
|
||||
if (input_sel != input_cur)
|
||||
CON_InputDelSelection();
|
||||
if (paste != NULL)
|
||||
CON_InputAddString(paste);
|
||||
completion[0] = 0;
|
||||
return true;
|
||||
}
|
||||
else if (key == 'w' || key == 'W')
|
||||
{
|
||||
size_t word_start, word_end, i;
|
||||
word_end = i = input_cur;
|
||||
|
||||
// Unless we're pointing at the beginning of line, decrement i so we only start
|
||||
// removing symbols that come before the cursor
|
||||
if (i) --i;
|
||||
|
||||
// We might be pointing to spaces, skip them first
|
||||
while (i && isspace(inputlines[inputline][i]))
|
||||
--i;
|
||||
|
||||
// Now skip the "word"
|
||||
while (i && !isspace(inputlines[inputline][i]))
|
||||
--i;
|
||||
|
||||
// Unless we reached beginning of line, i is pointing at first space that was found
|
||||
// before word start, and we don't want to remove it
|
||||
if (i) ++i;
|
||||
|
||||
word_start = i;
|
||||
|
||||
if (word_start != word_end)
|
||||
CON_InputDel(word_start, word_end);
|
||||
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_RIGHTARROW)
|
||||
CON_ToWordEnd(!shiftdown);
|
||||
else if (key == KEY_LEFTARROW)
|
||||
CON_ToWordBegin(!shiftdown);
|
||||
|
||||
// Select all
|
||||
if (key == 'a' || key == 'A')
|
||||
{
|
||||
input_sel = 0;
|
||||
input_cur = input_len;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ...why shouldn't it eat the key? if it doesn't, it just means you
|
||||
// can control Sonic from the console, which is silly
|
||||
@@ -1174,9 +940,9 @@ boolean CON_Responder(event_t *ev)
|
||||
// remember typing for several completions (a-la-4dos)
|
||||
if (!completion[0])
|
||||
{
|
||||
if (!input_len || input_len >= 40 || strchr(inputlines[inputline], ' '))
|
||||
if (!input.length || input.length >= 40 || strchr(input.buffer, ' '))
|
||||
return true;
|
||||
strcpy(completion, inputlines[inputline]);
|
||||
strcpy(completion, input.buffer);
|
||||
comskips = varskips = 0;
|
||||
}
|
||||
else
|
||||
@@ -1207,7 +973,11 @@ boolean CON_Responder(event_t *ev)
|
||||
cmd = CV_CompleteVar(completion, varskips);
|
||||
|
||||
if (cmd)
|
||||
CON_InputSetString(va("%s ", cmd));
|
||||
{
|
||||
Lock_state();
|
||||
M_TextInputSetString(&input, va("%s ", cmd));
|
||||
Unlock_state();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (comskips > 0)
|
||||
@@ -1233,37 +1003,6 @@ boolean CON_Responder(event_t *ev)
|
||||
return true;
|
||||
}
|
||||
|
||||
if (key == KEY_LEFTARROW)
|
||||
{
|
||||
if (input_cur != 0)
|
||||
--input_cur;
|
||||
if (!shiftdown)
|
||||
input_sel = input_cur;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_RIGHTARROW)
|
||||
{
|
||||
if (input_cur < input_len)
|
||||
++input_cur;
|
||||
if (!shiftdown)
|
||||
input_sel = input_cur;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_HOME)
|
||||
{
|
||||
input_cur = 0;
|
||||
if (!shiftdown)
|
||||
input_sel = input_cur;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_END)
|
||||
{
|
||||
input_cur = input_len;
|
||||
if (!shiftdown)
|
||||
input_sel = input_cur;
|
||||
return true;
|
||||
}
|
||||
|
||||
// At this point we're messing with input
|
||||
// Clear completion
|
||||
completion[0] = 0;
|
||||
@@ -1271,45 +1010,29 @@ boolean CON_Responder(event_t *ev)
|
||||
// command enter
|
||||
if (key == KEY_ENTER)
|
||||
{
|
||||
if (!input_len)
|
||||
if (!input.length)
|
||||
return true;
|
||||
|
||||
// push the command
|
||||
COM_BufAddText(inputlines[inputline]);
|
||||
COM_BufAddText(input.buffer);
|
||||
COM_BufAddText("\n");
|
||||
|
||||
CONS_Printf("\x86""%c""\x80""%s\n", CON_PROMPTCHAR, inputlines[inputline]);
|
||||
|
||||
Lock_state();
|
||||
|
||||
// Only add command to history if it differs from previous one
|
||||
if (strcmp(inputlines[inputline], inputlines[(inputline-1) & 31]))
|
||||
if (strcmp(input.buffer, inputlines[(inputline-1) & 31]))
|
||||
{
|
||||
inputline = (inputline+1) & 31;
|
||||
M_TextInputInit(&input, inputlines[inputline], CON_MAXPROMPTCHARS);
|
||||
}
|
||||
|
||||
inputhist = inputline;
|
||||
CON_InputClear();
|
||||
M_TextInputClear(&input);
|
||||
|
||||
return true;
|
||||
}
|
||||
Unlock_state();
|
||||
|
||||
// backspace and delete command prompt
|
||||
if (input_sel != input_cur)
|
||||
{
|
||||
if (key == KEY_BACKSPACE || key == KEY_DEL)
|
||||
{
|
||||
CON_InputDelSelection();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (key == KEY_BACKSPACE)
|
||||
{
|
||||
CON_InputDelChar();
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_DEL)
|
||||
{
|
||||
if (input_cur == input_len)
|
||||
return true;
|
||||
++input_cur;
|
||||
CON_InputDelChar();
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1326,7 +1049,9 @@ boolean CON_Responder(event_t *ev)
|
||||
if (inputhist == inputline)
|
||||
inputhist = (inputline + 1) & 31;
|
||||
|
||||
CON_InputSetString(inputlines[inputhist]);
|
||||
Lock_state();
|
||||
M_TextInputSetString(&input, inputlines[inputhist]);
|
||||
Unlock_state();
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1340,41 +1065,16 @@ boolean CON_Responder(event_t *ev)
|
||||
while (inputhist != inputline && !inputlines[inputhist][0]);
|
||||
|
||||
// back to currentline
|
||||
Lock_state();
|
||||
if (inputhist == inputline)
|
||||
CON_InputClear();
|
||||
M_TextInputClear(&input);
|
||||
else
|
||||
CON_InputSetString(inputlines[inputhist]);
|
||||
M_TextInputSetString(&input, inputlines[inputhist]);
|
||||
Unlock_state();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// allow people to use keypad in console (good for typing IP addresses) - Calum
|
||||
if (key >= KEY_KEYPAD7 && key <= KEY_KPADDEL)
|
||||
{
|
||||
char keypad_translation[] = {'7','8','9','-',
|
||||
'4','5','6','+',
|
||||
'1','2','3',
|
||||
'0','.'};
|
||||
|
||||
key = keypad_translation[key - KEY_KEYPAD7];
|
||||
}
|
||||
else if (key == KEY_KPADSLASH)
|
||||
key = '/';
|
||||
|
||||
// same capslock code as hu_stuff.c's HU_responder. Check there for details.
|
||||
key = CON_ShiftChar(key);
|
||||
|
||||
// enter a char into the command prompt
|
||||
if (key < 32 || key > 127)
|
||||
return true;
|
||||
|
||||
// add key to cmd line here
|
||||
if (key >= 'A' && key <= 'Z' && !(shiftdown ^ capslock)) //this is only really necessary for dedicated servers
|
||||
key = key + 'a' - 'A';
|
||||
|
||||
if (input_sel != input_cur)
|
||||
CON_InputDelSelection();
|
||||
CON_InputAddChar(key);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1656,16 +1356,16 @@ static void CON_DrawInput(void)
|
||||
|
||||
clen = con_width-13;
|
||||
|
||||
if (input_len <= clen)
|
||||
if (input.length <= clen)
|
||||
{
|
||||
c = 0;
|
||||
clen = input_len;
|
||||
clen = input.length;
|
||||
}
|
||||
else // input line scrolls left if it gets too long
|
||||
{
|
||||
clen -= 2; // There will always be some extra truncation -- but where is what we'll find out
|
||||
|
||||
if (input_cur <= clen/2)
|
||||
if (input.cursor <= clen/2)
|
||||
{
|
||||
// Close enough to right edge to show all
|
||||
c = 0;
|
||||
@@ -1676,15 +1376,15 @@ static void CON_DrawInput(void)
|
||||
{
|
||||
// Cursor in the middle (or right side) of input
|
||||
// Move over for the ellipsis
|
||||
c = input_cur - (clen/2) + 2;
|
||||
c = input.cursor - (clen/2) + 2;
|
||||
x += charwidth*2;
|
||||
lellip = 1;
|
||||
|
||||
if (c + clen >= input_len)
|
||||
if (c + clen >= input.length)
|
||||
{
|
||||
// Cursor in the right side of input
|
||||
// We were too far over, so move back
|
||||
c = input_len - clen;
|
||||
c = input.length - clen;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1698,7 +1398,7 @@ static void CON_DrawInput(void)
|
||||
if (lellip)
|
||||
{
|
||||
x -= charwidth*3;
|
||||
if (input_sel < c)
|
||||
if (input.select < c)
|
||||
V_DrawFill(x, y, charwidth*3, (10 * con_scalefactor), 107 | V_NOSCALESTART);
|
||||
for (i = 0; i < 3; ++i, x += charwidth)
|
||||
V_DrawCharacter(x, y, '.' | cv_constextsize.value | V_GRAYMAP | V_NOSCALESTART, !cv_allcaps.value);
|
||||
@@ -1708,7 +1408,7 @@ static void CON_DrawInput(void)
|
||||
|
||||
for (cend = c + clen; c < cend; ++c, x += charwidth)
|
||||
{
|
||||
if ((input_sel > c && input_cur <= c) || (input_sel <= c && input_cur > c))
|
||||
if ((input.select > c && input.cursor <= c) || (input.select <= c && input.cursor > c))
|
||||
{
|
||||
V_DrawFill(x, y, charwidth, (10 * con_scalefactor), 107 | V_NOSCALESTART);
|
||||
V_DrawCharacter(x, y, p[c] | cv_constextsize.value | V_YELLOWMAP | V_NOSCALESTART, !cv_allcaps.value);
|
||||
@@ -1716,14 +1416,14 @@ static void CON_DrawInput(void)
|
||||
else
|
||||
V_DrawCharacter(x, y, p[c] | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
|
||||
if (c == input_cur && con_tick >= 4)
|
||||
if (c == input.cursor && con_tick >= 4)
|
||||
V_DrawCharacter(x, y + (con_scalefactor*2), '_' | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
}
|
||||
if (cend == input_cur && con_tick >= 4)
|
||||
if (cend == input.cursor && con_tick >= 4)
|
||||
V_DrawCharacter(x, y + (con_scalefactor*2), '_' | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
if (rellip)
|
||||
{
|
||||
if (input_sel > cend)
|
||||
if (input.select > cend)
|
||||
V_DrawFill(x, y, charwidth*3, (10 * con_scalefactor), 107 | V_NOSCALESTART);
|
||||
for (i = 0; i < 3; ++i, x += charwidth)
|
||||
V_DrawCharacter(x, y, '.' | cv_constextsize.value | V_GRAYMAP | V_NOSCALESTART, !cv_allcaps.value);
|
||||
|
||||
+27
-31
@@ -5385,7 +5385,10 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
#ifdef SATURNSYNCH
|
||||
// this decreases by one point at twice the cooldown time (ex cooldown of 2 seconds means, this counter decreases by one every 4 seconds), pretty much there to prevent a resynch loop
|
||||
if ((gamestate_resend_counter[node] != 0) && (I_GetTime() % ((max(cv_resynchcooldown.value, 1) * TICRATE) *2) == 0))
|
||||
{
|
||||
gamestate_resend_counter[node]--;
|
||||
DEBFILE(va("gamestate counter %d for node %d\n", gamestate_resend_counter[node], netconsole));
|
||||
}
|
||||
|
||||
// Check player consistancy during the level
|
||||
if (((!can_receive_gamestate[node]) && realstart <= gametic && realstart > gametic - TICQUEUE+1 && gamestate == GS_LEVEL
|
||||
@@ -5394,6 +5397,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
&& !resendingsavegame[node] && savegameresendcooldown[node] <= I_GetTime()
|
||||
&& !SV_ResendingSavegameToAnyone()))
|
||||
{
|
||||
//#ifndef SATURNPAK // lug: keep this behaviour for v7.1 atleast
|
||||
// we need to send this so the client can tell us if it can receive the savegame
|
||||
netbuffer->packettype = PT_WILLRESENDGAMESTATE;
|
||||
HSendPacket(node, true, 0, 0);
|
||||
@@ -5405,13 +5409,28 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
SV_RequireResynch(node);
|
||||
resendingsavegame[node] = false;
|
||||
}
|
||||
/*#else
|
||||
if (can_receive_gamestate[node])
|
||||
{
|
||||
// Tell the client we are about to resend them the gamestate
|
||||
netbuffer->packettype = PT_WILLRESENDGAMESTATE;
|
||||
HSendPacket(node, true, 0, 0);
|
||||
|
||||
if ((!can_receive_gamestate[node] && cv_resynchattempts.value && resynch_score[node] <= (unsigned)cv_resynchattempts.value*250) || (can_receive_gamestate[node] && (gamestate_resend_counter[node] < cv_gamestateattempts.value)))
|
||||
resendingsavegame[node] = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
SV_RequireResynch(node);
|
||||
resendingsavegame[node] = false;
|
||||
}
|
||||
#endif*/
|
||||
|
||||
if ((!can_receive_gamestate[node] && (cv_resynchattempts.value && resynch_score[node] <= (unsigned)cv_resynchattempts.value*250)) || (can_receive_gamestate[node] && (gamestate_resend_counter[node] < cv_gamestateattempts.value)))
|
||||
{
|
||||
if (can_receive_gamestate[node] && resendingsavegame[node])
|
||||
{
|
||||
gamestate_resend_counter[node]++;
|
||||
DEBFILE(va("gamestate counter %d for player %d\n", gamestate_resend_counter[node], netconsole));
|
||||
DEBFILE(va("gamestate counter %d for node %d\n", gamestate_resend_counter[node], netconsole));
|
||||
}
|
||||
|
||||
if (cv_blamecfail.value)
|
||||
@@ -5435,6 +5454,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
netconsole, realstart, consistancy[realstart%TICQUEUE],
|
||||
SHORT(netbuffer->u.clientpak.consistancy)));
|
||||
gamestate_resend_counter[node] = 0;
|
||||
DEBFILE(va("gamestate counter %d for node %d\n", gamestate_resend_counter[node], netconsole));
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -5446,7 +5466,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
if (realstart <= gametic && realstart > gametic - TICQUEUE+1 && gamestate == GS_LEVEL
|
||||
&& consistancy[realstart%TICQUEUE] != SHORT(netbuffer->u.clientpak.consistancy))
|
||||
{
|
||||
SV_RequireResynch(node);
|
||||
SV_RequireResynch(node);
|
||||
|
||||
if (cv_resynchattempts.value && resynch_score[node] <= (unsigned)cv_resynchattempts.value*250)
|
||||
{
|
||||
@@ -5584,31 +5604,6 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
else
|
||||
buf[1] = KICK_MSG_PLAYER_QUIT;
|
||||
SendNetXCmd(XD_KICK, &buf, 2);
|
||||
//nodetoplayer[node] = -1;
|
||||
|
||||
/*if (nodetoplayer2[node] != -1 && nodetoplayer2[node] >= 0
|
||||
&& playeringame[(UINT8)nodetoplayer2[node]])
|
||||
{
|
||||
buf[0] = nodetoplayer2[node];
|
||||
SendNetXCmd(XD_KICK, &buf, 2);
|
||||
nodetoplayer2[node] = -1;
|
||||
}
|
||||
|
||||
if (nodetoplayer3[node] != -1 && nodetoplayer3[node] >= 0
|
||||
&& playeringame[(UINT8)nodetoplayer3[node]])
|
||||
{
|
||||
buf[0] = nodetoplayer3[node];
|
||||
SendNetXCmd(XD_KICK, &buf, 2);
|
||||
nodetoplayer3[node] = -1;
|
||||
}
|
||||
|
||||
if (nodetoplayer4[node] != -1 && nodetoplayer4[node] >= 0
|
||||
&& playeringame[(UINT8)nodetoplayer4[node]])
|
||||
{
|
||||
buf[0] = nodetoplayer4[node];
|
||||
SendNetXCmd(XD_KICK, &buf, 2);
|
||||
nodetoplayer4[node] = -1;
|
||||
}*/
|
||||
}
|
||||
Net_CloseConnection(node);
|
||||
nodeingame[node] = false;
|
||||
@@ -5797,8 +5792,9 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
#endif
|
||||
#ifdef SATURNPAK
|
||||
case PT_ISSATURN:
|
||||
//CONS_Printf("hi im on saturn%d\n", node);
|
||||
DEBFILE(va("hi im on saturn! node = %d\n", node));
|
||||
is_client_saturn[node] = true;
|
||||
can_receive_gamestate[node] = true;
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
@@ -6634,7 +6630,7 @@ void NetKeepAlive(void)
|
||||
#ifdef MASTERSERVER
|
||||
MasterClient_Ticker();
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef HOLEPUNCH
|
||||
if (netgame && serverrunning)
|
||||
{
|
||||
@@ -6745,7 +6741,7 @@ void NetUpdate(void)
|
||||
CL_SendClientCmd(); // send it
|
||||
|
||||
GetPackets(); // get packet from client or from server
|
||||
|
||||
|
||||
// client send the command after a receive of the server
|
||||
// the server send before because in single player is beter
|
||||
|
||||
|
||||
+1
-1
@@ -568,7 +568,7 @@ static boolean D_Display(void)
|
||||
V_DrawScaledPatch(viewwindowx + (BASEVIDWIDTH - SHORT(patch->width))/2, py, V_SNAPTOTOP, patch);
|
||||
}
|
||||
|
||||
if (demo.rewinding)
|
||||
if (rendermode == render_soft && demo.rewinding)
|
||||
V_DrawFadeScreen(TC_RAINBOW, (leveltime & 0x20) ? SKINCOLOR_PASTEL : SKINCOLOR_MOONSLAM);
|
||||
|
||||
// vid size change is now finished if it was on...
|
||||
|
||||
+6
-25
@@ -978,7 +978,6 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_audbuffersize);
|
||||
|
||||
// m_menu.c
|
||||
//CV_RegisterVar(&cv_compactscoreboard);
|
||||
CV_RegisterVar(&cv_chatheight);
|
||||
CV_RegisterVar(&cv_chatwidth);
|
||||
CV_RegisterVar(&cv_chattime);
|
||||
@@ -1090,20 +1089,12 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_controlperkey);
|
||||
CV_RegisterVar(&cv_turnsmooth);
|
||||
|
||||
CV_RegisterVar(&cv_rumble[0]);
|
||||
CV_RegisterVar(&cv_rumble[1]);
|
||||
CV_RegisterVar(&cv_rumble[2]);
|
||||
CV_RegisterVar(&cv_rumble[3]);
|
||||
|
||||
CV_RegisterVar(&cv_gamepadled[0]);
|
||||
CV_RegisterVar(&cv_gamepadled[1]);
|
||||
CV_RegisterVar(&cv_gamepadled[2]);
|
||||
CV_RegisterVar(&cv_gamepadled[3]);
|
||||
|
||||
CV_RegisterVar(&cv_ledpowerup[0]);
|
||||
CV_RegisterVar(&cv_ledpowerup[1]);
|
||||
CV_RegisterVar(&cv_ledpowerup[2]);
|
||||
CV_RegisterVar(&cv_ledpowerup[3]);
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
CV_RegisterVar(&cv_rumble[i]);
|
||||
CV_RegisterVar(&cv_gamepadled[i]);
|
||||
CV_RegisterVar(&cv_ledpowerup[i]);
|
||||
}
|
||||
|
||||
CV_RegisterVar(&cv_usemouse);
|
||||
CV_RegisterVar(&cv_usemouse2);
|
||||
@@ -1207,26 +1198,16 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_speed);
|
||||
CV_RegisterVar(&cv_opflags);
|
||||
CV_RegisterVar(&cv_mapthingnum);
|
||||
//CV_RegisterVar(&cv_grid);
|
||||
//CV_RegisterVar(&cv_snapto);
|
||||
|
||||
// add cheat commands
|
||||
COM_AddCommand("noclip", Command_CheatNoClip_f);
|
||||
COM_AddCommand("god", Command_CheatGod_f);
|
||||
COM_AddCommand("notarget", Command_CheatNoTarget_f);
|
||||
/*COM_AddCommand("getallemeralds", Command_Getallemeralds_f);
|
||||
COM_AddCommand("resetemeralds", Command_Resetemeralds_f);
|
||||
COM_AddCommand("setrings", Command_Setrings_f);
|
||||
COM_AddCommand("setlives", Command_Setlives_f);
|
||||
COM_AddCommand("setcontinues", Command_Setcontinues_f);*/
|
||||
COM_AddCommand("devmode", Command_Devmode_f);
|
||||
COM_AddCommand("savecheckpoint", Command_Savecheckpoint_f);
|
||||
COM_AddCommand("scale", Command_Scale_f);
|
||||
COM_AddCommand("gravflip", Command_Gravflip_f);
|
||||
COM_AddCommand("hurtme", Command_Hurtme_f);
|
||||
/*COM_AddCommand("jumptoaxis", Command_JumpToAxis_f);
|
||||
COM_AddCommand("charability", Command_Charability_f);
|
||||
COM_AddCommand("charspeed", Command_Charspeed_f);*/
|
||||
COM_AddCommand("teleport", Command_Teleport_f);
|
||||
COM_AddCommand("rteleport", Command_RTeleport_f);
|
||||
COM_AddCommand("skynum", Command_Skynum_f);
|
||||
|
||||
+5
-10
@@ -127,13 +127,8 @@ extern char logfilename[1024];
|
||||
#else
|
||||
#define VERSION 1 // Game version
|
||||
#define SUBVERSION 6 // more precise version number
|
||||
#ifndef USE_FBO_OGL
|
||||
#define VERSIONSTRING "Saturn v7"
|
||||
#define VERSIONSTRINGW L"Saturn v7"
|
||||
#else
|
||||
#define VERSIONSTRING "Saturn v7 - FBO "
|
||||
#define VERSIONSTRINGW L"Saturn v7 - FBO"
|
||||
#endif
|
||||
#define VERSIONSTRING "Saturn v7.1"
|
||||
#define VERSIONSTRINGW L"Saturn v7.1"
|
||||
// Hey! If you change this, add 1 to the MODVERSION below! Otherwise we can't force updates!
|
||||
// And change CMakeLists.txt (not src/, but in root), for CMake users!
|
||||
// AND appveyor.yml, for the build bots!
|
||||
@@ -590,9 +585,9 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
|
||||
/// Server detection for if a connecting client is on Saturn.
|
||||
/// For stuff like extra synching, etc.
|
||||
//#ifdef DOSATURNPAK
|
||||
//#define SATURNPAK
|
||||
//#endif
|
||||
#ifdef DOSATURNPAK
|
||||
#define SATURNPAK
|
||||
#endif
|
||||
//-- <( ̄︶ ̄)> __
|
||||
#endif
|
||||
|
||||
|
||||
+13
-24
@@ -4379,6 +4379,7 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
|
||||
else
|
||||
{
|
||||
LUAh_MapChange(gamemap);
|
||||
S_CheckMap();
|
||||
G_DoLoadLevel(resetplayer);
|
||||
}
|
||||
|
||||
@@ -6385,8 +6386,18 @@ void G_BeginRecording(void)
|
||||
// Full replay title
|
||||
demobuf.p += 64;
|
||||
{
|
||||
char demotitlename[65];
|
||||
char *title = G_BuildMapTitle(gamemap);
|
||||
snprintf(demo.titlename, 64, "%s - %s", title, modeattacking ? "Time Attack" : connectedservername);
|
||||
|
||||
// Print to a separate temp buffer instead of demo.titlename, so we can use it in M_TextInputSetString
|
||||
snprintf(demotitlename, 64, "%s - %s", title, modeattacking ? "Time Attack" : connectedservername);
|
||||
|
||||
// Init just in case it isn't initialized already
|
||||
M_TextInputInit(&demo.titlenameinput, demo.titlename, sizeof(demo.titlename));
|
||||
|
||||
// This will indirectly assign to demo.titlename too
|
||||
M_TextInputSetString(&demo.titlenameinput, demotitlename);
|
||||
|
||||
Z_Free(title);
|
||||
}
|
||||
|
||||
@@ -8380,7 +8391,6 @@ void G_SaveDemo(void)
|
||||
|
||||
boolean G_DemoTitleResponder(event_t *ev)
|
||||
{
|
||||
size_t len;
|
||||
INT32 ch;
|
||||
|
||||
if (ev->type != ev_keydown)
|
||||
@@ -8401,28 +8411,7 @@ boolean G_DemoTitleResponder(event_t *ev)
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((ch >= HU_FONTSTART && ch <= HU_FONTEND && hu_font[ch-HU_FONTSTART])
|
||||
|| ch == ' ') // Allow spaces, of course
|
||||
{
|
||||
len = strlen(demo.titlename);
|
||||
if (len < 64)
|
||||
{
|
||||
demo.titlename[len+1] = 0;
|
||||
demo.titlename[len] = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(ch) : CON_ShiftChar(ch);
|
||||
}
|
||||
}
|
||||
else if (ch == KEY_BACKSPACE)
|
||||
{
|
||||
if (shiftdown)
|
||||
memset(demo.titlename, 0, sizeof(demo.titlename));
|
||||
else
|
||||
{
|
||||
len = strlen(demo.titlename);
|
||||
|
||||
if (len > 0)
|
||||
demo.titlename[len-1] = 0;
|
||||
}
|
||||
}
|
||||
M_TextInputHandle(&demo.titlenameinput, ch);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
+4
-10
@@ -18,6 +18,7 @@
|
||||
#include "doomstat.h"
|
||||
#include "d_event.h"
|
||||
#include "p_saveg.h"
|
||||
#include "m_textinput.h"
|
||||
|
||||
extern char gamedatafilename[64];
|
||||
extern char timeattackfolder[64];
|
||||
@@ -45,6 +46,7 @@ extern consvar_t cv_recordmultiplayerdemos, cv_netdemosyncquality, cv_maxdemosiz
|
||||
// Publicly-accessible demo vars
|
||||
struct demovars_s {
|
||||
char titlename[65];
|
||||
textinput_t titlenameinput;
|
||||
boolean recording, playback, timing;
|
||||
UINT16 version; // Current file format of the demo being played
|
||||
boolean title; // Title Screen demo can be cancelled by any key
|
||||
@@ -418,19 +420,9 @@ void G_SetGamestate(gamestate_t newstate);
|
||||
|
||||
// Gamedata record shit
|
||||
void G_AllocMainRecordData(INT16 i);
|
||||
//void G_AllocNightsRecordData(INT16 i);
|
||||
void G_ClearRecords(void);
|
||||
|
||||
//UINT32 G_GetBestScore(INT16 map);
|
||||
tic_t G_GetBestTime(INT16 map);
|
||||
//tic_t G_GetBestLap(INT16 map);
|
||||
//UINT16 G_GetBestRings(INT16 map);
|
||||
//UINT32 G_GetBestNightsScore(INT16 map, UINT8 mare);
|
||||
//tic_t G_GetBestNightsTime(INT16 map, UINT8 mare);
|
||||
//UINT8 G_GetBestNightsGrade(INT16 map, UINT8 mare);
|
||||
|
||||
//void G_AddTempNightsRecords(UINT32 pscore, tic_t ptime, UINT8 mare);
|
||||
//void G_SetNightsRecords(void);
|
||||
|
||||
FUNCMATH INT32 G_TicsToHours(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToMinutes(tic_t tics, boolean full);
|
||||
@@ -438,6 +430,8 @@ FUNCMATH INT32 G_TicsToSeconds(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToCentiseconds(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToMilliseconds(tic_t tics);
|
||||
|
||||
boolean K_DirectorIsPlayerAlone(void); // idk where else to put this lol
|
||||
|
||||
// Don't split up TOL handling
|
||||
INT16 G_TOLFlag(INT32 pgametype);
|
||||
|
||||
|
||||
@@ -156,7 +156,7 @@ typedef struct
|
||||
boolean mirrorflip; // Encore Mode with Flipcam
|
||||
#endif
|
||||
boolean shearing; // 14042019
|
||||
angle_t viewaiming; // 17052019
|
||||
float viewaiming; // 17052019
|
||||
} FTransform;
|
||||
|
||||
// Transformed vector, as passed to HWR API
|
||||
|
||||
+25
-19
@@ -309,9 +309,10 @@ FTransform atransform;
|
||||
// Float variants of viewx, viewy, viewz, etc.
|
||||
static float gr_viewx, gr_viewy, gr_viewz;
|
||||
float gr_viewsin, gr_viewcos;
|
||||
static float gr_viewludsin, gr_viewludcos;
|
||||
|
||||
static angle_t gr_aimingangle;
|
||||
static float gr_viewludsin, gr_viewludcos;
|
||||
static void HWR_SetTransformAiming(FTransform *trans);
|
||||
|
||||
// ==========================================================================
|
||||
// Visual portals (attr. Hannu Hanhi)
|
||||
@@ -651,7 +652,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope)
|
||||
|
||||
// HWR_RenderPlane
|
||||
// Render a floor or ceiling convex polygon
|
||||
void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
|
||||
static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
|
||||
{
|
||||
FSurfaceInfo Surf;
|
||||
FOutVector *v3d;
|
||||
@@ -5130,15 +5131,12 @@ void HWR_DrawSkyBackground(float fpov)
|
||||
|
||||
//04/01/2000: Hurdler: added for T&L
|
||||
// It should replace all other gr_viewxxx when finished
|
||||
if (!atransform.shearing)
|
||||
dometransform.anglex = (float)(aimingangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
HWR_SetTransformAiming(&dometransform);
|
||||
dometransform.angley = (float)((viewangle-ANGLE_270)>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
|
||||
dometransform.flip = atransform.flip;
|
||||
dometransform.mirror = atransform.mirror;
|
||||
dometransform.mirrorflip = atransform.mirrorflip;
|
||||
dometransform.shearing = atransform.shearing;
|
||||
dometransform.viewaiming = atransform.viewaiming;
|
||||
|
||||
dometransform.scalex = 1;
|
||||
dometransform.scaley = (float)vid.width/vid.height;
|
||||
@@ -5199,6 +5197,25 @@ void HWR_SetViewSize(void)
|
||||
HWD.pfnFlushScreenTextures();
|
||||
}
|
||||
|
||||
// Set view aiming, for the sky dome, the skybox,
|
||||
// and the normal view, all with a single function.
|
||||
static void HWR_SetTransformAiming(FTransform *trans)
|
||||
{
|
||||
if (cv_grshearing.value)
|
||||
{
|
||||
fixed_t fixedaiming = AIMINGTODY(aimingangle);
|
||||
trans->viewaiming = FIXED_TO_FLOAT(fixedaiming);
|
||||
trans->shearing = true;
|
||||
gr_aimingangle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
trans->shearing = false;
|
||||
gr_aimingangle = aimingangle;
|
||||
}
|
||||
trans->anglex = (float)(gr_aimingangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
}
|
||||
|
||||
void HWR_SetTransform(float fpov, player_t *player)
|
||||
{
|
||||
postimg_t *postprocessor = &postimgtype[0];
|
||||
@@ -5221,23 +5238,12 @@ void HWR_SetTransform(float fpov, player_t *player)
|
||||
atransform.scaley = (float)vid.width/vid.height;
|
||||
atransform.scalez = 1;
|
||||
|
||||
// 14042019
|
||||
gr_aimingangle = aimingangle;
|
||||
atransform.shearing = false;
|
||||
atransform.viewaiming = aimingangle;
|
||||
|
||||
if (cv_grshearing.value)
|
||||
{
|
||||
gr_aimingangle = 0;
|
||||
atransform.shearing = true;
|
||||
}
|
||||
HWR_SetTransformAiming(&atransform);
|
||||
atransform.angley = (float)(viewangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
|
||||
gr_viewludsin = FIXED_TO_FLOAT(FINECOSINE(gr_aimingangle>>ANGLETOFINESHIFT));
|
||||
gr_viewludcos = FIXED_TO_FLOAT(-FINESINE(gr_aimingangle>>ANGLETOFINESHIFT));
|
||||
|
||||
atransform.anglex = (float)(gr_aimingangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
atransform.angley = (float)(viewangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
|
||||
|
||||
atransform.fovxangle = fpov; // Tails
|
||||
atransform.fovyangle = fpov; // Tails
|
||||
HWR_RollTransform(&atransform, viewroll);
|
||||
|
||||
@@ -116,7 +116,7 @@ void HWR_MakeScreenFinalTexture(void);
|
||||
void HWR_DrawScreenFinalTexture(INT32 width, INT32 height);
|
||||
|
||||
// hw_main.c: Planes
|
||||
void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap);
|
||||
//void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap);
|
||||
void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
|
||||
|
||||
void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, FBITFIELD blendmode, UINT8 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap);
|
||||
|
||||
@@ -2984,7 +2984,7 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
|
||||
// https://zdoom.org/wiki/Y-shearing
|
||||
if (shearing)
|
||||
{
|
||||
float dy = FIXED_TO_FLOAT(AIMINGTODY((stransform->viewaiming)) * 2)* ((float)vid.width / vid.height) / ((float)BASEVIDWIDTH / BASEVIDHEIGHT); //screen_width/BASEVIDWIDTH;
|
||||
float dy = stransform->viewaiming * 2;
|
||||
if (stransform->flip || stransform->mirrorflip)
|
||||
dy *= -1.0f;
|
||||
pglTranslatef(0.0f, -dy/BASEVIDHEIGHT, 0.0f);
|
||||
|
||||
+140
-255
@@ -49,6 +49,8 @@
|
||||
#include "s_sound.h" // song credits
|
||||
#include "k_kart.h"
|
||||
|
||||
#include "m_textinput.h"
|
||||
|
||||
#ifdef HWRENDER
|
||||
#include "hardware/hw_main.h"
|
||||
#endif
|
||||
@@ -86,8 +88,8 @@ patch_t *frameslash; // framerate stuff. Used in screen.c
|
||||
|
||||
static player_t *plr;
|
||||
boolean chat_on; // entering a chat message?
|
||||
static char w_chat[HU_MAXMSGLEN + 1];
|
||||
static size_t c_input = 0; // let's try to make the chat input less shitty.
|
||||
static char w_chat_buf[HU_MAXMSGLEN + 1];
|
||||
static textinput_t w_chat;
|
||||
static boolean headsupactive = false;
|
||||
boolean hu_showscores; // draw rankings
|
||||
static char hu_tick;
|
||||
@@ -1143,71 +1145,6 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
|
||||
#endif
|
||||
}
|
||||
|
||||
// Handles key input and string input
|
||||
//
|
||||
static inline boolean HU_keyInChatString(char *s, char ch)
|
||||
{
|
||||
size_t l;
|
||||
|
||||
if ((ch >= HU_FONTSTART && ch <= HU_FONTEND && hu_font[ch-HU_FONTSTART])
|
||||
|| ch == ' ') // Allow spaces, of course
|
||||
{
|
||||
l = strlen(s);
|
||||
if (l < HU_MAXMSGLEN - 1)
|
||||
{
|
||||
if (c_input >= strlen(s)) // don't do anything complicated
|
||||
{
|
||||
s[l++] = ch;
|
||||
s[l]=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// move everything past c_input for new characters:
|
||||
size_t m = HU_MAXMSGLEN-1;
|
||||
while (m>=c_input)
|
||||
{
|
||||
if (s[m])
|
||||
s[m+1] = (s[m]);
|
||||
if (m == 0) // prevent overflow
|
||||
break;
|
||||
m--;
|
||||
}
|
||||
s[c_input] = ch; // and replace this.
|
||||
}
|
||||
c_input++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
else if (ch == KEY_BACKSPACE)
|
||||
{
|
||||
size_t i = c_input;
|
||||
|
||||
if (c_input <= 0)
|
||||
return false;
|
||||
|
||||
if (!s[i-1])
|
||||
return false;
|
||||
|
||||
if (i >= strlen(s)-1)
|
||||
{
|
||||
s[strlen(s)-1] = 0;
|
||||
c_input--;
|
||||
return false;
|
||||
}
|
||||
|
||||
for (; (i < HU_MAXMSGLEN); i++)
|
||||
{
|
||||
s[i-1] = s[i];
|
||||
}
|
||||
c_input--;
|
||||
}
|
||||
else if (ch != KEY_ENTER)
|
||||
return false; // did not eat key
|
||||
|
||||
return true; // ate the key
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -1280,9 +1217,9 @@ static boolean HU_clearChatSpaces(void)
|
||||
char c; // current character we're iterating.
|
||||
boolean nothingbutspaces = true;
|
||||
|
||||
for (; i < strlen(w_chat); i++) // iterate through message and eradicate all spaces that don't belong.
|
||||
for (; i < strlen(w_chat_buf); i++) // iterate through message and eradicate all spaces that don't belong.
|
||||
{
|
||||
c = w_chat[i];
|
||||
c = w_chat_buf[i];
|
||||
if (!c)
|
||||
break; // if there's nothing, it's safe to assume our message has ended, so let's not waste any more time here.
|
||||
|
||||
@@ -1294,128 +1231,110 @@ static boolean HU_clearChatSpaces(void)
|
||||
return nothingbutspaces;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
static void HU_queueChatChar(INT32 c)
|
||||
static void HU_SendChatMessage(void)
|
||||
{
|
||||
// send automaticly the message (no more chat char)
|
||||
if (c == KEY_ENTER)
|
||||
char buf[2 + HU_MAXMSGLEN + 1];
|
||||
char *msg = &buf[2];
|
||||
size_t ci = 2;
|
||||
INT32 target = 0;
|
||||
char c;
|
||||
|
||||
if (HU_clearChatSpaces()) // Avoids being able to send empty messages, or something.
|
||||
return; // If this returns true, that means our message was NOTHING but spaces, so don't send it period.
|
||||
|
||||
do {
|
||||
c = w_chat_buf[-2+ci++];
|
||||
if (!c || (c >= ' ' && !(c & 0x80))) // copy printable characters and terminating '\0' only.
|
||||
buf[ci-1]=c;
|
||||
} while (c);
|
||||
|
||||
M_TextInputClear(&w_chat);
|
||||
|
||||
// last minute mute check
|
||||
if (CHAT_MUTE)
|
||||
{
|
||||
char buf[2 + HU_MAXMSGLEN + 1];
|
||||
char *msg = &buf[2];
|
||||
size_t i;
|
||||
size_t ci = 2;
|
||||
INT32 target = 0;
|
||||
HU_AddChatText(va("%s>ERROR: The chat is muted. You can't say anything.", "\x85"), false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (HU_clearChatSpaces()) // Avoids being able to send empty messages, or something.
|
||||
return; // If this returns true, that means our message was NOTHING but spaces, so don't send it period.
|
||||
if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
|
||||
{
|
||||
INT32 spc = 1; // used if nodenum[1] is a space.
|
||||
char *nodenum = (char*) malloc(3);
|
||||
const char *newmsg;
|
||||
|
||||
do {
|
||||
c = w_chat[-2+ci++];
|
||||
if (!c || (c >= ' ' && !(c & 0x80))) // copy printable characters and terminating '\0' only.
|
||||
buf[ci-1]=c;
|
||||
} while (c);
|
||||
i = 0;
|
||||
for (;(i<HU_MAXMSGLEN);i++)
|
||||
w_chat[i] = 0; // reset this.
|
||||
// what we're gonna do now is check if the node exists
|
||||
// with that logic, characters 4 and 5 are our numbers:
|
||||
|
||||
c_input = 0;
|
||||
|
||||
for (;(i<HU_MAXMSGLEN);i++)
|
||||
w_chat[i] = 0; // reset this.
|
||||
|
||||
c_input = 0;
|
||||
|
||||
// last minute mute check
|
||||
if (CHAT_MUTE)
|
||||
// teamtalk can't send PMs, just don't send it, else everyone would be able to see it, and no one wants to see your sex RP sicko.
|
||||
if (teamtalk)
|
||||
{
|
||||
HU_AddChatText(va("%s>ERROR: The chat is muted. You can't say anything.", "\x85"), false);
|
||||
HU_AddChatText(va("%sCannot send sayto in Say-Team.", "\x85"), false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
|
||||
memcpy(nodenum, msg+3, 2);
|
||||
nodenum[2] = '\0';
|
||||
|
||||
// check for undesirable characters in our "number"
|
||||
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
|
||||
{
|
||||
INT32 spc = 1; // used if nodenum[1] is a space.
|
||||
char *nodenum = (char*) malloc(3);
|
||||
const char *newmsg;
|
||||
|
||||
// what we're gonna do now is check if the node exists
|
||||
// with that logic, characters 4 and 5 are our numbers:
|
||||
|
||||
// teamtalk can't send PMs, just don't send it, else everyone would be able to see it, and no one wants to see your sex RP sicko.
|
||||
if (teamtalk)
|
||||
{
|
||||
HU_AddChatText(va("%sCannot send sayto in Say-Team.", "\x85"), false);
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(nodenum, msg+3, 2);
|
||||
nodenum[2] = '\0';
|
||||
|
||||
// check for undesirable characters in our "number"
|
||||
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
|
||||
{
|
||||
// check if nodenum[1] is a space
|
||||
if (nodenum[1] == ' ')
|
||||
spc = 0;
|
||||
// let it slide
|
||||
else
|
||||
{
|
||||
HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
|
||||
free(nodenum);
|
||||
return;
|
||||
}
|
||||
}
|
||||
// I'm very bad at C, I swear I am, additional checks eww!
|
||||
if (spc != 0)
|
||||
{
|
||||
if (msg[5] != ' ')
|
||||
{
|
||||
HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
|
||||
free(nodenum);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
target = atoi((const char*) nodenum); // turn that into a number
|
||||
free(nodenum);
|
||||
//CONS_Printf("%d\n", target);
|
||||
|
||||
// check for target player, if it doesn't exist then we can't send the message!
|
||||
if (target < MAXPLAYERS && playeringame[target]) // player exists
|
||||
target++; // even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
|
||||
// check if nodenum[1] is a space
|
||||
if (nodenum[1] == ' ')
|
||||
spc = 0;
|
||||
// let it slide
|
||||
else
|
||||
{
|
||||
HU_AddChatText(va("\x82NOTICE: \x80Player %d does not exist.", target), false); // same
|
||||
HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
|
||||
free(nodenum);
|
||||
return;
|
||||
}
|
||||
|
||||
// we need to get rid of the /pm<node>
|
||||
newmsg = msg+5+spc;
|
||||
strlcpy(msg, newmsg, HU_MAXMSGLEN + 1);
|
||||
}
|
||||
if (ci > 3) // don't send target+flags+empty message.
|
||||
// I'm very bad at C, I swear I am, additional checks eww!
|
||||
if (spc != 0)
|
||||
{
|
||||
if (teamtalk)
|
||||
buf[0] = -1; // target
|
||||
else
|
||||
buf[0] = target;
|
||||
|
||||
buf[1] = 0; // flags
|
||||
SendNetXCmd(XD_SAY, buf, 2 + strlen(&buf[2]) + 1);
|
||||
if (msg[5] != ' ')
|
||||
{
|
||||
HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
|
||||
free(nodenum);
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
|
||||
target = atoi((const char*) nodenum); // turn that into a number
|
||||
free(nodenum);
|
||||
//CONS_Printf("%d\n", target);
|
||||
|
||||
// check for target player, if it doesn't exist then we can't send the message!
|
||||
if (target < MAXPLAYERS && playeringame[target]) // player exists
|
||||
target++; // even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
|
||||
else
|
||||
{
|
||||
HU_AddChatText(va("\x82NOTICE: \x80Player %d does not exist.", target), false); // same
|
||||
return;
|
||||
}
|
||||
|
||||
// we need to get rid of the /pm<node>
|
||||
newmsg = msg+5+spc;
|
||||
strlcpy(msg, newmsg, HU_MAXMSGLEN + 1);
|
||||
}
|
||||
if (ci > 3) // don't send target+flags+empty message.
|
||||
{
|
||||
if (teamtalk)
|
||||
buf[0] = -1; // target
|
||||
else
|
||||
buf[0] = target;
|
||||
|
||||
buf[1] = 0; // flags
|
||||
SendNetXCmd(XD_SAY, buf, 2 + strlen(&buf[2]) + 1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void HU_clearChatChars(void)
|
||||
{
|
||||
size_t i = 0;
|
||||
for (;i<HU_MAXMSGLEN;i++)
|
||||
w_chat[i] = 0; // reset this.
|
||||
M_TextInputClear(&w_chat);
|
||||
chat_on = false;
|
||||
c_input = 0;
|
||||
}
|
||||
|
||||
#ifndef NONET
|
||||
@@ -1463,7 +1382,8 @@ boolean HU_Responder(event_t *ev)
|
||||
&& netgame && !OLD_MUTE) // check for old chat mute, still let the players open the chat incase they want to scroll otherwise.
|
||||
{
|
||||
chat_on = true;
|
||||
w_chat[0] = 0;
|
||||
w_chat_buf[0] = 0;
|
||||
M_TextInputInit(&w_chat, w_chat_buf, sizeof w_chat_buf);
|
||||
teamtalk = false;
|
||||
chat_scrollmedown = true;
|
||||
typelines = 1;
|
||||
@@ -1473,7 +1393,8 @@ boolean HU_Responder(event_t *ev)
|
||||
&& netgame && !OLD_MUTE)
|
||||
{
|
||||
chat_on = true;
|
||||
w_chat[0] = 0;
|
||||
w_chat_buf[0] = 0;
|
||||
M_TextInputInit(&w_chat, w_chat_buf, sizeof w_chat_buf);
|
||||
teamtalk = G_GametypeHasTeams(); // Don't teamtalk if we don't have teams.
|
||||
chat_scrollmedown = true;
|
||||
typelines = 1;
|
||||
@@ -1498,62 +1419,13 @@ boolean HU_Responder(event_t *ev)
|
||||
&& ev->data1 != gamecontrol[gc_talkkey][1]))
|
||||
return false;
|
||||
|
||||
c = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(c) : CON_ShiftChar(c);
|
||||
M_TextInputHandle(&w_chat, c);
|
||||
|
||||
// pasting. pasting is cool. chat is a bit limited, though :(
|
||||
if (((c == 'v' || c == 'V') && ctrldown) && !CHAT_MUTE)
|
||||
{
|
||||
const char *paste = I_ClipboardPaste();
|
||||
size_t chatlen;
|
||||
size_t pastelen;
|
||||
|
||||
// create a dummy string real quickly
|
||||
|
||||
if (paste == NULL)
|
||||
return true;
|
||||
|
||||
chatlen = strlen(w_chat);
|
||||
pastelen = strlen(paste);
|
||||
if (chatlen+pastelen > HU_MAXMSGLEN)
|
||||
return true; // we can't paste this!!
|
||||
|
||||
if (c_input >= strlen(w_chat)) // add it at the end of the string.
|
||||
{
|
||||
memcpy(&w_chat[chatlen], paste, pastelen); // copy all of that.
|
||||
c_input += pastelen;
|
||||
/*size_t i = 0;
|
||||
for (;i<pastelen;i++)
|
||||
{
|
||||
HU_queueChatChar(paste[i]); // queue it so that it's actually sent. (this chat write thing is REALLY messy.)
|
||||
}*/
|
||||
return true;
|
||||
}
|
||||
else // otherwise, we need to shift everything and make space, etc etc
|
||||
{
|
||||
size_t i = HU_MAXMSGLEN-1;
|
||||
while (i >= c_input)
|
||||
{
|
||||
if (w_chat[i])
|
||||
w_chat[i+pastelen] = w_chat[i];
|
||||
if (i == 0) // prevent overflow
|
||||
break;
|
||||
i--;
|
||||
}
|
||||
memcpy(&w_chat[c_input], paste, pastelen); // copy all of that.
|
||||
c_input += pastelen;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!CHAT_MUTE && HU_keyInChatString(w_chat,c))
|
||||
{
|
||||
HU_queueChatChar(c);
|
||||
}
|
||||
if (c == KEY_ENTER)
|
||||
{
|
||||
chat_on = false;
|
||||
c_input = 0; // reset input cursor
|
||||
chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
|
||||
HU_SendChatMessage();
|
||||
}
|
||||
else if (c == KEY_ESCAPE
|
||||
|| ((c == gamecontrol[gc_talkkey][0] || c == gamecontrol[gc_talkkey][1]
|
||||
@@ -1561,7 +1433,6 @@ boolean HU_Responder(event_t *ev)
|
||||
&& c >= KEY_MOUSE1)) // If it's not a keyboard key, then the chat button is used as a toggle.
|
||||
{
|
||||
chat_on = false;
|
||||
c_input = 0; // reset input cursor
|
||||
}
|
||||
else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0 && !OLDCHAT) // CHAT SCROLLING YAYS!
|
||||
{
|
||||
@@ -1575,10 +1446,6 @@ boolean HU_Responder(event_t *ev)
|
||||
justscrolleddown = true;
|
||||
chat_scrolltime = 4;
|
||||
}
|
||||
else if (c == KEY_LEFTARROW && c_input != 0 && !OLDCHAT) // i said go back
|
||||
c_input--;
|
||||
else if (c == KEY_RIGHTARROW && c_input < strlen(w_chat) && !OLDCHAT) // don't need to check for admin or w/e here since the chat won't ever contain anything if it's muted.
|
||||
c_input++;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
@@ -1932,8 +1799,9 @@ static void HU_DrawChat(void)
|
||||
INT32 charwidth = 4, charheight = 6;
|
||||
INT32 boxw = cv_chatwidth.value;
|
||||
INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
|
||||
UINT32 i = 0, saylen = strlen(w_chat); // You learn new things everyday!
|
||||
UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
|
||||
INT32 cflag = 0;
|
||||
size_t select_start = 0, select_end = 0;
|
||||
const char *ntalk = "Say: ", *ttalk = "Team: ";
|
||||
const char *talk = ntalk;
|
||||
const char *mute = "Chat has been muted.";
|
||||
@@ -1995,13 +1863,19 @@ static void HU_DrawChat(void)
|
||||
i = 0;
|
||||
typelines = 1;
|
||||
|
||||
if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
|
||||
V_DrawChatCharacter(chatx + 2 + c, y+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);
|
||||
if ((w_chat.cursor == 0 || w_chat.length == 0) && hu_tick < 4)
|
||||
V_DrawChatCharacter(chatx+2+c+charwidth*w_chat.cursor, y+1, '_'|V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);
|
||||
|
||||
while (w_chat[i])
|
||||
if (w_chat.select != w_chat.cursor)
|
||||
{
|
||||
select_start = min(w_chat.select, w_chat.cursor);
|
||||
select_end = max(w_chat.select, w_chat.cursor);
|
||||
}
|
||||
|
||||
while (w_chat_buf[i])
|
||||
{
|
||||
boolean skippedline = false;
|
||||
if (c_input == (i+1))
|
||||
if (w_chat.cursor == (i+1))
|
||||
{
|
||||
INT32 cursorx = (c+charwidth < boxw-charwidth) ? (chatx + 2 + c+charwidth) : (chatx+1); // we may have to go down.
|
||||
INT32 cursory = (cursorx != chatx+1) ? (y) : (y+charheight);
|
||||
@@ -2016,10 +1890,14 @@ static void HU_DrawChat(void)
|
||||
}
|
||||
|
||||
//Hurdler: isn't it better like that?
|
||||
if (w_chat[i] < HU_FONTSTART)
|
||||
++i;
|
||||
else
|
||||
V_DrawChatCharacter(chatx + c + 2, y, w_chat[i++] | V_SNAPTOBOTTOM|V_SNAPTOLEFT | t, !cv_allcaps.value, NULL);
|
||||
if (w_chat_buf[i] >= HU_FONTSTART)
|
||||
V_DrawChatCharacter(chatx + c + 2, y, w_chat_buf[i] | V_SNAPTOBOTTOM|V_SNAPTOLEFT | t, !cv_allcaps.value, NULL);
|
||||
|
||||
// Draw selection
|
||||
if (i >= select_start && i < select_end)
|
||||
V_DrawFill(chatx + c + 2, y-1, charwidth, charheight, 103|V_TRANSLUCENT|V_SNAPTOBOTTOM|V_SNAPTOLEFT|t);
|
||||
|
||||
++i;
|
||||
|
||||
c += charwidth;
|
||||
if (c > boxw-(charwidth*2) && !skippedline)
|
||||
@@ -2031,7 +1909,7 @@ static void HU_DrawChat(void)
|
||||
}
|
||||
|
||||
// handle /pm list. It's messy, horrible and I don't care.
|
||||
if (strnicmp(w_chat, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
|
||||
if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
|
||||
{
|
||||
INT32 count = 0;
|
||||
INT32 p_dispy = chaty - charheight -1;
|
||||
@@ -2051,38 +1929,38 @@ static void HU_DrawChat(void)
|
||||
{
|
||||
|
||||
// filter: (code needs optimization pls help I'm bad with C)
|
||||
if (w_chat[3])
|
||||
if (w_chat_buf[3])
|
||||
{
|
||||
char *nodenum;
|
||||
UINT32 n;
|
||||
// right, that's half important: (w_chat[4] may be a space since /pm0 msg is perfectly acceptable!)
|
||||
if ( ( ((w_chat[3] != 0) && ((w_chat[3] < '0') || (w_chat[3] > '9'))) || ((w_chat[4] != 0) && (((w_chat[4] < '0') || (w_chat[4] > '9'))))) && (w_chat[4] != ' '))
|
||||
// right, that's half important: (w_chat_buf[4] may be a space since /pm0 msg is perfectly acceptable!)
|
||||
if ( ( ((w_chat_buf[3] != 0) && ((w_chat_buf[3] < '0') || (w_chat_buf[3] > '9'))) || ((w_chat_buf[4] != 0) && (((w_chat_buf[4] < '0') || (w_chat_buf[4] > '9'))))) && (w_chat_buf[4] != ' '))
|
||||
break;
|
||||
|
||||
|
||||
nodenum = (char*) malloc(3);
|
||||
memcpy(nodenum, w_chat+3, 2);
|
||||
memcpy(nodenum, w_chat_buf+3, 2);
|
||||
nodenum[2] = '\0';
|
||||
n = atoi((const char*) nodenum); // turn that into a number
|
||||
free(nodenum);
|
||||
// special cases:
|
||||
|
||||
if ((n == 0) && !(w_chat[4] == '0'))
|
||||
if ((n == 0) && !(w_chat_buf[4] == '0'))
|
||||
{
|
||||
if (!(i<10))
|
||||
continue;
|
||||
}
|
||||
else if ((n == 1) && !(w_chat[3] == '0'))
|
||||
else if ((n == 1) && !(w_chat_buf[3] == '0'))
|
||||
{
|
||||
if (!((i == 1) || ((i >= 10) && (i <= 19))))
|
||||
continue;
|
||||
}
|
||||
else if ((n == 2) && !(w_chat[3] == '0'))
|
||||
else if ((n == 2) && !(w_chat_buf[3] == '0'))
|
||||
{
|
||||
if (!((i == 2) || ((i >= 20) && (i <= 29))))
|
||||
continue;
|
||||
}
|
||||
else if ((n == 3) && !(w_chat[3] == '0'))
|
||||
else if ((n == 3) && !(w_chat_buf[3] == '0'))
|
||||
{
|
||||
if (!((i == 3) || ((i >= 30) && (i <= 31))))
|
||||
continue;
|
||||
@@ -2121,6 +1999,7 @@ static void HU_DrawChat_Old(void)
|
||||
size_t i = 0;
|
||||
const char *ntalk = "Say: ", *ttalk = "Say-Team: ";
|
||||
const char *talk = ntalk;
|
||||
size_t select_start = 0, select_end = 0;
|
||||
INT32 charwidth = 8 * con_scalefactor; //SHORT(hu_font['A'-HU_FONTSTART]->width) * con_scalefactor;
|
||||
INT32 charheight = 8 * con_scalefactor; //SHORT(hu_font['A'-HU_FONTSTART]->height) * con_scalefactor;
|
||||
if (teamtalk)
|
||||
@@ -2149,14 +2028,19 @@ static void HU_DrawChat_Old(void)
|
||||
c += charwidth;
|
||||
}
|
||||
|
||||
if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
|
||||
V_DrawCharacter(HU_INPUTX+c, y+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
|
||||
if ((w_chat.cursor == 0 || w_chat.length == 0) && hu_tick < 4)
|
||||
V_DrawCharacter(HU_INPUTX+c+charwidth*w_chat.cursor, y+2*con_scalefactor, '_'|cv_constextsize.value|V_NOSCALESTART|t, !cv_allcaps.value);
|
||||
|
||||
if (w_chat.select != w_chat.cursor)
|
||||
{
|
||||
select_start = min(w_chat.select, w_chat.cursor);
|
||||
select_end = max(w_chat.select, w_chat.cursor);
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while (w_chat[i])
|
||||
while (w_chat_buf[i])
|
||||
{
|
||||
|
||||
if (c_input == (i+1) && hu_tick < 4)
|
||||
if (w_chat.cursor == (i+1) && hu_tick < 4)
|
||||
{
|
||||
INT32 cursorx = (HU_INPUTX+c+charwidth < vid.width) ? (HU_INPUTX + c + charwidth) : (HU_INPUTX); // we may have to go down.
|
||||
INT32 cursory = (cursorx != HU_INPUTX) ? (y) : (y+charheight);
|
||||
@@ -2164,17 +2048,18 @@ static void HU_DrawChat_Old(void)
|
||||
}
|
||||
|
||||
//Hurdler: isn't it better like that?
|
||||
if (w_chat[i] < HU_FONTSTART)
|
||||
{
|
||||
++i;
|
||||
//charwidth = 4 * con_scalefactor;
|
||||
}
|
||||
else
|
||||
if (w_chat_buf[i] >= HU_FONTSTART)
|
||||
{
|
||||
//charwidth = SHORT(hu_font[w_chat[i]-HU_FONTSTART]->width) * con_scalefactor;
|
||||
V_DrawCharacter(HU_INPUTX + c, y, w_chat[i++] | cv_constextsize.value | V_NOSCALESTART | t, !cv_allcaps.value);
|
||||
V_DrawCharacter(HU_INPUTX + c, y, w_chat_buf[i] | cv_constextsize.value | V_NOSCALESTART | t, !cv_allcaps.value);
|
||||
}
|
||||
|
||||
// Draw selection
|
||||
if (i >= select_start && i < select_end)
|
||||
V_DrawFill(HU_INPUTX + c, y, charwidth, charheight, 103|V_TRANSLUCENT|cv_constextsize.value|V_NOSCALESTART|t);
|
||||
|
||||
++i;
|
||||
|
||||
c += charwidth;
|
||||
if (c >= vid.width)
|
||||
{
|
||||
|
||||
+20
-1
@@ -38,6 +38,25 @@ struct directorinfo
|
||||
INT32 boredom[MAXPLAYERS]; // how long has a given position had no credible attackers?
|
||||
} directorinfo;
|
||||
|
||||
boolean K_DirectorIsPlayerAlone(void)
|
||||
{
|
||||
UINT8 pingame = 0;
|
||||
|
||||
// Gotta check how many players are active at this moment.
|
||||
for (UINT8 i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i] || players[i].spectator)
|
||||
continue;
|
||||
|
||||
pingame++;
|
||||
|
||||
if (pingame >= 2) // we dont need to check further
|
||||
break;
|
||||
}
|
||||
|
||||
return (pingame <= 1);
|
||||
}
|
||||
|
||||
static inline boolean race_rules(void)
|
||||
{
|
||||
return gametype == GT_RACE;
|
||||
@@ -50,7 +69,7 @@ static fixed_t ScaleFromMap(fixed_t n, fixed_t scale)
|
||||
|
||||
static boolean K_DirectorIsEnabled(void)
|
||||
{
|
||||
return cv_director.value && !splitscreen && (gamestate == GS_LEVEL && (((stplyr && !stplyr->spectator) && (!playeringame[consoleplayer] || players[consoleplayer].spectator)) || (demo.playback && !demo.freecam && (!demo.title || !modeattacking))));
|
||||
return cv_director.value && !splitscreen && (gamestate == GS_LEVEL && (((stplyr && !stplyr->spectator) && (!playeringame[consoleplayer] || players[consoleplayer].spectator)) || (demo.playback && !demo.freecam && (!demo.title || !modeattacking))) && !K_DirectorIsPlayerAlone());
|
||||
}
|
||||
|
||||
void K_InitDirector(void)
|
||||
|
||||
+3
-9
@@ -5359,12 +5359,9 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
|
||||
// Handle invincibility sfx
|
||||
K_UpdateInvincibilitySounds(player); // Also thanks, VAda!
|
||||
|
||||
// Plays the music after the starting countdown.
|
||||
if (P_IsLocalPlayer(player) && leveltime == (starttime + (TICRATE/2)))
|
||||
{
|
||||
S_ChangeMusic(mapmusname, mapmusflags, true);
|
||||
S_ShowMusicCredit();
|
||||
}
|
||||
// Plays the music during and after the starting countdown.
|
||||
if (P_IsLocalPlayer(player))
|
||||
S_StartMapMusic(false);
|
||||
}
|
||||
|
||||
void K_KartPlayerAfterThink(player_t *player)
|
||||
@@ -6552,10 +6549,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
|
||||
if ((leveltime == starttime-(3*TICRATE)) || (leveltime == starttime-(2*TICRATE)) || (leveltime == starttime-TICRATE))
|
||||
S_StartSound(NULL, sfx_s3ka7);
|
||||
if (leveltime == starttime)
|
||||
{
|
||||
S_StartSound(NULL, sfx_s3kad);
|
||||
S_StopMusic(); // The GO! sound stops the level start ambience
|
||||
}
|
||||
}
|
||||
|
||||
// Start charging once you're given the opportunity.
|
||||
|
||||
@@ -81,6 +81,9 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
|
||||
lua_pushstring(gL, buf);
|
||||
}
|
||||
LUA_Call(gL, (int)argc, 0, 1); // argc is 1-based, so this will cover the player we passed too.
|
||||
|
||||
lua_pop(gL, 1); // Pop LUA_GetErrorMessage (lua_pcall doesn't pop it)
|
||||
|
||||
return;
|
||||
|
||||
deny:
|
||||
@@ -143,7 +146,7 @@ void COM_Lua_f(void)
|
||||
if (netgame && !( flags & COM_LOCAL ))/* don't send local commands */
|
||||
{ // Send the command through the network
|
||||
UINT8 argc;
|
||||
lua_pop(gL, 1); // pop command info table
|
||||
lua_pop(gL, 2); // pop command info table and LUA_GetErrorMessage
|
||||
|
||||
if (flags & COM_ADMIN && !server && !IsPlayerAdmin(playernum)) // flag 1: only server/admin can use this command.
|
||||
{
|
||||
@@ -182,6 +185,8 @@ void COM_Lua_f(void)
|
||||
for (i = 1; i < COM_Argc(); i++)
|
||||
lua_pushstring(gL, COM_Argv(i));
|
||||
LUA_Call(gL, (int)COM_Argc(), 0, 1); // COM_Argc is 1-based, so this will cover the player we passed too.
|
||||
|
||||
lua_pop(gL, 1); // Pop LUA_GetErrorMessage (lua_pcall doesn't pop it)
|
||||
}
|
||||
|
||||
// Wrapper for COM_AddCommand
|
||||
|
||||
+7
-2
@@ -1268,8 +1268,13 @@ void LUA_Step(void)
|
||||
{
|
||||
if (!gL)
|
||||
return;
|
||||
lua_settop(gL, 0);
|
||||
lua_gc(gL, LUA_GCSTEP, 1);
|
||||
|
||||
if (lua_gettop(gL) != 0)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "Eek, there is garbage on lua stack!\n");
|
||||
lua_settop(gL, 0);
|
||||
lua_gc(gL, LUA_GCSTEP, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void LUA_Archive(savebuffer_t *save, boolean network)
|
||||
|
||||
+202
-187
@@ -30,6 +30,7 @@
|
||||
#include "g_game.h"
|
||||
#include "g_input.h"
|
||||
#include "m_argv.h"
|
||||
#include "m_textinput.h"
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
@@ -159,6 +160,9 @@ boolean fromlevelselect = false;
|
||||
|
||||
boolean menu_text_input = false;
|
||||
|
||||
char menu_text_input_buf[MAXSTRINGLENGTH];
|
||||
static textinput_t menuinput;
|
||||
|
||||
static INT32 coolalphatimer = 9;
|
||||
|
||||
typedef enum
|
||||
@@ -245,6 +249,7 @@ menu_t SR_MainDef, SR_UnlockChecklistDef;
|
||||
|
||||
// Misc. Main Menu
|
||||
static void M_Options(INT32 choice);
|
||||
static void M_Multiplayer(INT32 choice);
|
||||
static void M_LocalSkinMenu(INT32 choice);
|
||||
static void M_LocalSkinChange(INT32 choice);
|
||||
static void M_Manual(INT32 choice);
|
||||
@@ -591,7 +596,7 @@ static menuitem_t MainMenu[] =
|
||||
{
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Extras", &SR_MainDef, 76},
|
||||
{IT_CALL |IT_STRING, NULL, "Time Attack", M_TimeAttack, 84},
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Multiplayer", &MP_MainDef, 92},
|
||||
{IT_CALL |IT_STRING, NULL, "Multiplayer", M_Multiplayer, 92},
|
||||
{IT_CALL |IT_STRING, NULL, "Options", M_Options, 100},
|
||||
{IT_CALL |IT_STRING, NULL, "Addons", M_Addons, 108},
|
||||
{IT_CALL |IT_STRING, NULL, "Quit Game", M_QuitSRB2, 116},
|
||||
@@ -1653,21 +1658,25 @@ static const char* OP_SoundTooltips[] =
|
||||
static menuitem_t OP_SoundAdvancedMenu[] =
|
||||
{
|
||||
#ifdef HAVE_OPENMPT
|
||||
{IT_HEADER, NULL, "Tracker Module Options", NULL, 10},
|
||||
{IT_HEADER, NULL, "Tracker Module Options", NULL, 0},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Instrument Filter", &cv_modfilter, 22},
|
||||
{IT_STRING | IT_CVAR, NULL, "Amiga Resampler", &cv_amigafilter, 42},
|
||||
{IT_STRING | IT_CVAR, NULL, "Instrument Filter", &cv_modfilter, 20},
|
||||
{IT_STRING | IT_CVAR, NULL, "Amiga Resampler", &cv_amigafilter, 30},
|
||||
#if OPENMPT_API_VERSION_MAJOR < 1 && OPENMPT_API_VERSION_MINOR > 4
|
||||
{IT_STRING | IT_CVAR, NULL, "Amiga Type", &cv_amigatype, 62},
|
||||
{IT_STRING | IT_CVAR, NULL, "Amiga Type", &cv_amigatype, 40},
|
||||
#endif
|
||||
{IT_STRING | IT_CVAR, NULL, "Stereo Seperation", &cv_stereosep, 82},
|
||||
{IT_STRING | IT_CVAR, NULL, "Stereo Seperation", &cv_stereosep, 50},
|
||||
#endif
|
||||
{IT_HEADER, NULL, "Misc", NULL, 105},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Grow Music", &cv_growmusic, 117},
|
||||
{IT_STRING | IT_CVAR, NULL, "Invulnerability Music", &cv_supermusic, 127},
|
||||
{IT_HEADER, NULL, "Misc", NULL, 70},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Audio Buffer Size", &cv_audbuffersize, 147},
|
||||
{IT_STRING | IT_CVAR, NULL, "Grow Music", &cv_growmusic, 90},
|
||||
{IT_STRING | IT_CVAR, NULL, "Invulnerability Music", &cv_supermusic, 100},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Keep Map Music", &cv_keepmusic, 120},
|
||||
{IT_STRING | IT_CVAR, NULL, "Skip Intro Music", &cv_skipintromusic, 130},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Audio Buffer Size", &cv_audbuffersize, 150},
|
||||
};
|
||||
|
||||
static const char* OP_SoundAdvancedTooltips[] =
|
||||
@@ -1685,6 +1694,8 @@ static const char* OP_SoundAdvancedTooltips[] =
|
||||
NULL,
|
||||
"Should the Grow music be on or off?",
|
||||
"Should the Invulnerability music be on or off?",
|
||||
"Should music be kept when restarting the map?",
|
||||
"Should the Intro fanfare be skipped\nand map music be played on map start?",
|
||||
"Size of the Audio Buffer\nreducing it will result in less sound latency\nbut may cause issues such as crackling or distorted Sound.",
|
||||
};
|
||||
|
||||
@@ -3500,46 +3511,15 @@ static void M_ChangeCvar(INT32 choice)
|
||||
static boolean M_ChangeStringCvar(INT32 choice)
|
||||
{
|
||||
consvar_t *cv = (consvar_t *)currentMenu->menuitems[itemOn].itemaction;
|
||||
char buf[MAXSTRINGLENGTH];
|
||||
size_t len;
|
||||
|
||||
choice = M_ShiftChar(choice);
|
||||
|
||||
switch (choice)
|
||||
if (M_TextInputHandle(&menuinput, choice))
|
||||
{
|
||||
case KEY_BACKSPACE:
|
||||
len = strlen(cv->string);
|
||||
if (len > 0)
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
M_Memcpy(buf, cv->string, len);
|
||||
buf[len-1] = 0;
|
||||
CV_Set(cv, buf);
|
||||
}
|
||||
return true;
|
||||
case KEY_DEL:
|
||||
if (cv->string[0])
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
CV_Set(cv, "");
|
||||
}
|
||||
return true;
|
||||
default:
|
||||
if ((cv_keyboardlayout.value != 3 && choice >= 32 && choice <= 127) || (cv_keyboardlayout.value == 3 && choice >= 32 && choice <= 141))
|
||||
{
|
||||
len = strlen(cv->string);
|
||||
if (len < MAXSTRINGLENGTH - 1)
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
M_Memcpy(buf, cv->string, len);
|
||||
buf[len++] = (char)choice;
|
||||
buf[len] = 0;
|
||||
CV_Set(cv, buf);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
CV_Set(cv, menuinput.buffer);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -3556,6 +3536,21 @@ static void M_ResetCvars(void)
|
||||
}
|
||||
}
|
||||
|
||||
// If current menu item is IT_CV_STRING, setup menuinput
|
||||
static void M_CheckStringItem(void)
|
||||
{
|
||||
if (itemOn < currentMenu->numitems && (currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_STRING)
|
||||
{
|
||||
consvar_t *cv = (consvar_t *)currentMenu->menuitems[itemOn].itemaction;
|
||||
|
||||
// Just in case
|
||||
memset(menu_text_input_buf, 0, sizeof menu_text_input_buf);
|
||||
M_TextInputInit(&menuinput, menu_text_input_buf, sizeof menu_text_input_buf);
|
||||
|
||||
M_TextInputSetString(&menuinput, cv->string);
|
||||
}
|
||||
}
|
||||
|
||||
static void M_NextOpt(void)
|
||||
{
|
||||
INT16 oldItemOn = itemOn; // prevent infinite loop
|
||||
@@ -3567,6 +3562,8 @@ static void M_NextOpt(void)
|
||||
else
|
||||
itemOn++;
|
||||
} while (oldItemOn != itemOn && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_SPACE);
|
||||
|
||||
M_CheckStringItem();
|
||||
}
|
||||
|
||||
static void M_PrevOpt(void)
|
||||
@@ -3580,6 +3577,8 @@ static void M_PrevOpt(void)
|
||||
else
|
||||
itemOn--;
|
||||
} while (oldItemOn != itemOn && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_SPACE);
|
||||
|
||||
M_CheckStringItem();
|
||||
}
|
||||
|
||||
// lock out further input in a tic when important buttons are pressed
|
||||
@@ -3940,7 +3939,6 @@ boolean M_Responder(event_t *ev)
|
||||
if ((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_STRING)
|
||||
{
|
||||
menu_text_input = true;
|
||||
ch = M_ShiftChar(ch);
|
||||
if (M_ChangeStringCvar(ch))
|
||||
return true;
|
||||
else
|
||||
@@ -4601,6 +4599,8 @@ void M_SetupNextMenu(menu_t *menudef)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
M_CheckStringItem();
|
||||
}
|
||||
|
||||
//
|
||||
@@ -4940,6 +4940,33 @@ void M_DrawTextBoxFlags(INT32 x, INT32 y, INT32 width, INT32 boxlines, INT32 fla
|
||||
V_DrawFill(x+5, y+5, width*8+6, boxlines*8+6, 239|flags);
|
||||
}
|
||||
|
||||
void M_DrawTextInput(INT32 x, INT32 y, textinput_t *input, INT32 flags)
|
||||
{
|
||||
INT32 skullx = x;
|
||||
|
||||
V_DrawString(x, y, V_ALLOWLOWERCASE|flags, input->buffer);
|
||||
|
||||
// draw text cursor for name
|
||||
if (input->length)
|
||||
skullx = x+V_SubStringWidth(input->buffer, input->cursor, V_ALLOWLOWERCASE);
|
||||
|
||||
if (skullAnimCounter < 4) // blink cursor
|
||||
V_DrawCharacter(skullx, y+3, '_'|flags, false);
|
||||
|
||||
// draw selection
|
||||
if (input->select != input->cursor)
|
||||
{
|
||||
size_t start = min(input->select, input->cursor);
|
||||
size_t end = max(input->select, input->cursor);
|
||||
|
||||
size_t len = end - start;
|
||||
|
||||
INT32 startx = V_SubStringWidth(input->buffer, start, V_ALLOWLOWERCASE);
|
||||
|
||||
V_DrawFill(x+startx, y, V_SubStringWidth(input->buffer+start, len, V_ALLOWLOWERCASE), 8, 103|V_TRANSLUCENT|flags);
|
||||
}
|
||||
}
|
||||
|
||||
// horizontally centered text
|
||||
static void M_CentreText(INT32 y, const char *string)
|
||||
{
|
||||
@@ -5141,10 +5168,12 @@ static void M_DrawGenericMenu(void)
|
||||
break;
|
||||
case IT_CV_STRING:
|
||||
M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
if (skullAnimCounter < 4 && i == itemOn)
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(cv->string, 0), y + 12,
|
||||
'_' | 0x80, false);
|
||||
|
||||
if (itemOn == i)
|
||||
M_DrawTextInput(x + 8, y + 12, &menuinput, 0);
|
||||
else
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
|
||||
y += 16;
|
||||
break;
|
||||
default:
|
||||
@@ -5328,10 +5357,12 @@ static void M_DrawGenericScrollMenu(void)
|
||||
if (y + 12 > (currentMenu->y + 2*scrollareaheight))
|
||||
break;
|
||||
M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
|
||||
V_DrawString(x + 8, y + 12, lowercase, cv->string);
|
||||
if (skullAnimCounter < 4 && i == itemOn)
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(cv->string, 0), y + 12,
|
||||
'_' | 0x80, false);
|
||||
|
||||
if (itemOn == i)
|
||||
M_DrawTextInput(x + 8, y + 12, &menuinput, 0);
|
||||
else
|
||||
V_DrawString(x + 8, y + 12, lowercase, cv->string);
|
||||
|
||||
break;
|
||||
default:
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH - x, y,
|
||||
@@ -5467,10 +5498,12 @@ static void M_DrawCenteredMenu(void)
|
||||
break;
|
||||
case IT_CV_STRING:
|
||||
M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
if (skullAnimCounter < 4 && i == itemOn)
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(cv->string, 0), y + 12,
|
||||
'_' | 0x80, false);
|
||||
|
||||
if (itemOn == i)
|
||||
M_DrawTextInput(x + 8, y + 12, &menuinput, 0);
|
||||
else
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
|
||||
y += 16;
|
||||
break;
|
||||
default:
|
||||
@@ -6646,11 +6679,11 @@ I_mutex replayquerymutex;
|
||||
|
||||
|
||||
#define MAXREPLAYQUERY 40
|
||||
char replayqueryinput[MAXREPLAYQUERY+1]; // The input typed
|
||||
size_t replayquerypos = 0; // Position in input window
|
||||
static char replayqueryinput_buffer[MAXREPLAYQUERY+1]; // The input typed
|
||||
static textinput_t replayqueryinput;
|
||||
|
||||
size_t replayqueryfound = 0; // Number of checked replay entries
|
||||
size_t replayquerycheck = 0; // Index of next replay entry to check in demolist_all
|
||||
static size_t replayqueryfound = 0; // Number of checked replay entries
|
||||
static size_t replayquerycheck = 0; // Index of next replay entry to check in demolist_all
|
||||
|
||||
#define DF_ENCORE 0x40
|
||||
static INT16 replayScrollTitle = 0;
|
||||
@@ -6705,8 +6738,8 @@ static void LoadReplayNames(void)
|
||||
|
||||
static void ResetReplayQuery(void)
|
||||
{
|
||||
memset(replayqueryinput, 0, MAXREPLAYQUERY);
|
||||
replayquerypos = 0;
|
||||
memset(replayqueryinput_buffer, 0, MAXREPLAYQUERY);
|
||||
M_TextInputInit(&replayqueryinput, replayqueryinput_buffer, MAXREPLAYQUERY);
|
||||
|
||||
replayqueryfound = 0;
|
||||
replayquerycheck = 0;
|
||||
@@ -6730,7 +6763,7 @@ static void M_HutCheckReplays(size_t maxnum)
|
||||
return;
|
||||
|
||||
// If we don't have any query, just copy all demos and consider them checked
|
||||
if (replayquerypos == 0)
|
||||
if (replayqueryinput.length == 0)
|
||||
{
|
||||
// Mark as done
|
||||
replayqueryfound = replayquerycheck = sizedirmenu;
|
||||
@@ -6754,7 +6787,7 @@ static void M_HutCheckReplays(size_t maxnum)
|
||||
case MD_NOTLOADED:
|
||||
case MD_OUTDATED:
|
||||
case MD_LOADED:
|
||||
if (demolist_all[replayquerycheck].title[0] && strcasestr(demolist_all[replayquerycheck].title, replayqueryinput) != NULL)
|
||||
if (demolist_all[replayquerycheck].title[0] && strcasestr(demolist_all[replayquerycheck].title, replayqueryinput.buffer) != NULL)
|
||||
AddCheckedReplay(); // It matches, add it!
|
||||
else
|
||||
replayquerycheck++; // Doesn't match, moving on...
|
||||
@@ -6853,41 +6886,23 @@ void M_ReplayHut(INT32 choice)
|
||||
|
||||
static boolean M_HandleReplayHutQuery(INT32 choice)
|
||||
{
|
||||
switch (choice)
|
||||
// Yea gonna copy buffer and check if it changed, thats better than checking for specific keys i think
|
||||
char tmp[MAXREPLAYQUERY+1];
|
||||
memcpy(tmp, replayqueryinput_buffer, MAXREPLAYQUERY+1);
|
||||
|
||||
if (M_TextInputHandle(&replayqueryinput, choice))
|
||||
{
|
||||
case KEY_BACKSPACE:
|
||||
if (replayquerypos == 0)
|
||||
break;
|
||||
|
||||
S_StartSound(NULL,sfx_menu1);
|
||||
|
||||
replayquerypos--;
|
||||
replayqueryinput[replayquerypos] = 0;
|
||||
S_StartSound(NULL,sfx_menu1);
|
||||
|
||||
// Restart search only if we actually modified input and not just moved in it
|
||||
if (memcmp(tmp, replayqueryinput_buffer, MAXREPLAYQUERY+1))
|
||||
{
|
||||
preparefilemenu(false, true);
|
||||
dir_on[menudepthleft] = 0;
|
||||
PrepReplayList(false);
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
default:
|
||||
if (choice < 32 || choice > 127)
|
||||
break;
|
||||
|
||||
if (replayquerypos < MAXREPLAYQUERY)
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1);
|
||||
|
||||
replayqueryinput[replayquerypos] = choice;
|
||||
replayqueryinput[replayquerypos+1] = 0;
|
||||
++replayquerypos;
|
||||
|
||||
preparefilemenu(false, true);
|
||||
dir_on[menudepthleft] = 0;
|
||||
PrepReplayList(false);
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -7318,15 +7333,11 @@ static void M_DrawReplayHut(void)
|
||||
// Draw search query
|
||||
M_DrawTextBoxFlags(x, 200 - 22, MAXREPLAYQUERY, 1, V_SNAPTOBOTTOM);
|
||||
|
||||
if (replayquerypos)
|
||||
V_DrawString(x + 8, 200 - 14, V_ALLOWLOWERCASE|V_SNAPTOBOTTOM, replayqueryinput);
|
||||
if (replayqueryinput.length)
|
||||
M_DrawTextInput(x + 8, 200 - 14, &replayqueryinput, V_SNAPTOBOTTOM);
|
||||
else
|
||||
V_DrawString(x + 8, 200 - 14, V_ALLOWLOWERCASE|V_SNAPTOBOTTOM, "\x86Type to search...");
|
||||
|
||||
// draw text cursor for name
|
||||
if (replayquerypos && skullAnimCounter < 4) // blink cursor
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(replayqueryinput, V_ALLOWLOWERCASE), 200 - 14, '_'|V_SNAPTOBOTTOM, false);
|
||||
|
||||
if (replaynamesloaded && replayquerycheck < sizedirmenu)
|
||||
V_DrawString(x + 8, 200 - 30, V_ALLOWLOWERCASE|V_SNAPTOBOTTOM, va("Searching %u/%u...", (unsigned)replayquerycheck, (unsigned)sizedirmenu));
|
||||
}
|
||||
@@ -8904,9 +8915,11 @@ void M_DrawTimeAttackMenu(void)
|
||||
if (currentMenu->menuitems[i].status & IT_CV_STRING)
|
||||
{
|
||||
M_DrawTextBox(x + 32, y - 8, MAXPLAYERNAME, 1);
|
||||
V_DrawString(x + 40, y, V_ALLOWLOWERCASE, cv->string);
|
||||
if (itemOn == i && skullAnimCounter < 4) // blink cursor
|
||||
V_DrawCharacter(x + 40 + V_StringWidth(cv->string, V_ALLOWLOWERCASE), y, '_',false);
|
||||
|
||||
if (itemOn != i)
|
||||
V_DrawString(x + 40, y, V_ALLOWLOWERCASE, cv->string);
|
||||
else
|
||||
M_DrawTextInput(x + 40, y, &menuinput, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -9978,16 +9991,19 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
|
||||
patch_t *PictureOfLevel;
|
||||
INT32 x, y, w, i, oldval, trans, dupadjust = ((vid.width/vid.dupx) - BASEVIDWIDTH)>>1;
|
||||
|
||||
char encoretoggle[32] = {0};
|
||||
const char *item1 = gamecontrol[gc_fire][0] != 0 ? G_KeynumToString(gamecontrol[gc_fire][0]) : NULL;
|
||||
const char *item2 = gamecontrol[gc_fire][1] != 0 ? G_KeynumToString(gamecontrol[gc_fire][1]) : NULL;
|
||||
if (levellistmode != LLM_RECORDATTACK) // so it doesent show in record attack menu
|
||||
{
|
||||
char encoretoggle[32] = {0};
|
||||
const char *item1 = gamecontrol[gc_fire][0] != 0 ? G_KeynumToString(gamecontrol[gc_fire][0]) : NULL;
|
||||
const char *item2 = gamecontrol[gc_fire][1] != 0 ? G_KeynumToString(gamecontrol[gc_fire][1]) : NULL;
|
||||
|
||||
if (item1 != NULL && item2 != NULL)
|
||||
snprintf(encoretoggle, 32, "%s/%s: Toggle Encore", item1, item2);
|
||||
else
|
||||
snprintf(encoretoggle, 32, "%s: Toggle Encore", item1 != NULL ? item1 : item2 != NULL ? item2 : "Item");
|
||||
if (item1 != NULL && item2 != NULL)
|
||||
snprintf(encoretoggle, 32, "%s/%s: Toggle Encore", item1, item2);
|
||||
else
|
||||
snprintf(encoretoggle, 32, "%s: Toggle Encore", item1 != NULL ? item1 : item2 != NULL ? item2 : "Item");
|
||||
|
||||
V_DrawThinString(1, BASEVIDHEIGHT-8-1, V_SNAPTOLEFT|V_SNAPTOBOTTOM|V_TRANSLUCENT|V_ALLOWLOWERCASE, encoretoggle);
|
||||
V_DrawThinString(1, BASEVIDHEIGHT-8-1, V_SNAPTOLEFT|V_SNAPTOBOTTOM|V_TRANSLUCENT|V_ALLOWLOWERCASE, encoretoggle);
|
||||
}
|
||||
|
||||
// A 160x100 image of the level as entry MAPxxP
|
||||
if (cv_nextmap.value)
|
||||
@@ -10183,7 +10199,19 @@ static void M_StartServerMenu(INT32 choice)
|
||||
// ==============
|
||||
|
||||
static char setupm_ip[28];
|
||||
static textinput_t setupm_input_ip;
|
||||
#endif
|
||||
|
||||
void M_Multiplayer(INT32 choice)
|
||||
{
|
||||
(void)choice;
|
||||
#ifndef NONET
|
||||
memset(setupm_ip, 0, 28);
|
||||
M_TextInputInit(&setupm_input_ip, setupm_ip, 28);
|
||||
#endif
|
||||
M_SetupNextMenu(&MP_MainDef);
|
||||
}
|
||||
|
||||
static UINT8 setupm_pselect = 1;
|
||||
|
||||
// Draw the funky Connect IP menu. Tails 11-19-2002
|
||||
@@ -10217,12 +10245,10 @@ Update the maxplayers label...
|
||||
V_DrawFill(x+5, y+4+5, /*16*8 + 6,*/ BASEVIDWIDTH - 2*(x+5), 8+6, 239);
|
||||
|
||||
// draw name string
|
||||
V_DrawString(x+8,y+12, V_ALLOWLOWERCASE, setupm_ip);
|
||||
|
||||
// draw text cursor for name
|
||||
if (itemOn == 9
|
||||
&& skullAnimCounter < 4) //blink cursor
|
||||
V_DrawCharacter(x+8+V_StringWidth(setupm_ip, V_ALLOWLOWERCASE),y+12,'_',false);
|
||||
if (itemOn != 9)
|
||||
V_DrawString(x+8,y+12, V_ALLOWLOWERCASE, setupm_ip);
|
||||
else
|
||||
M_DrawTextInput(x+8, y+12, &setupm_input_ip, 0);
|
||||
#endif
|
||||
|
||||
// character bar, ripped off the color bar :V
|
||||
@@ -10410,7 +10436,6 @@ static void M_ConnectLastServer(INT32 choice)
|
||||
// Tails 11-19-2002
|
||||
static void M_HandleConnectIP(INT32 choice)
|
||||
{
|
||||
size_t l;
|
||||
boolean exitmenu = false; // exit to previous menu and send name change
|
||||
|
||||
switch (choice)
|
||||
@@ -10435,41 +10460,21 @@ static void M_HandleConnectIP(INT32 choice)
|
||||
exitmenu = true;
|
||||
break;
|
||||
|
||||
case KEY_LEFTARROW:
|
||||
case KEY_RIGHTARROW:
|
||||
case KEY_BACKSPACE:
|
||||
if ((l = strlen(setupm_ip)) != 0)
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_ip[l-1] = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case KEY_DEL:
|
||||
if (setupm_ip[0])
|
||||
{
|
||||
if (M_TextInputHandle(&setupm_input_ip, choice))
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_ip[0] = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
l = strlen(setupm_ip);
|
||||
if (l >= 28-1)
|
||||
break;
|
||||
|
||||
// Rudimentary number and period enforcing - also allows letters so hostnames can be used instead
|
||||
if ((choice >= '-' && choice <= ':') || (choice >= 'A' && choice <= 'Z') || (choice >= 'a' && choice <= 'z'))
|
||||
if ((choice >= '-' && choice <= ':') || (choice >= 'A' && choice <= 'Z') || (choice >= 'a' && choice <= 'z')
|
||||
|| (choice >= 199 && choice <= 211 && choice != 202 && choice != 206)) //numpad too!
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_ip[l] = (char)choice;
|
||||
setupm_ip[l+1] = 0;
|
||||
}
|
||||
else if (choice >= 199 && choice <= 211 && choice != 202 && choice != 206) //numpad too!
|
||||
{
|
||||
char keypad_translation[] = {'7','8','9','-','4','5','6','+','1','2','3','0','.'};
|
||||
choice = keypad_translation[choice - 199];
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_ip[l] = (char)choice;
|
||||
setupm_ip[l+1] = 0;
|
||||
if (M_TextInputHandle(&setupm_input_ip, choice))
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
}
|
||||
break;
|
||||
}
|
||||
@@ -10494,14 +10499,15 @@ static state_t *multi_state;
|
||||
|
||||
// this is set before entering the MultiPlayer setup menu,
|
||||
// for either player 1 or 2
|
||||
static char setupm_name[MAXPLAYERNAME+1];
|
||||
static player_t *setupm_player;
|
||||
static consvar_t *setupm_cvskin;
|
||||
static consvar_t *setupm_cvcolor;
|
||||
static consvar_t *setupm_cvname;
|
||||
static UINT8 setupm_skinxpos;
|
||||
static INT32 setupm_fakeskin;
|
||||
static INT32 setupm_fakecolor;
|
||||
static char setupm_name[MAXPLAYERNAME+1];
|
||||
static textinput_t setupm_input;
|
||||
static player_t *setupm_player;
|
||||
static consvar_t *setupm_cvskin;
|
||||
static consvar_t *setupm_cvcolor;
|
||||
static consvar_t *setupm_cvname;
|
||||
static UINT8 setupm_skinxpos;
|
||||
static INT32 setupm_fakeskin;
|
||||
static INT32 setupm_fakecolor;
|
||||
|
||||
//variables used for other skin select menus
|
||||
static UINT8 setupm_skinypos;
|
||||
@@ -10577,11 +10583,11 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
}
|
||||
|
||||
M_DrawTextBox(mx + 32, my - 8 + nameboxaddy, MAXPLAYERNAME, 1);
|
||||
V_DrawString(mx + 40, my + nameboxaddy, V_ALLOWLOWERCASE, setupm_name);
|
||||
|
||||
// draw text cursor for name
|
||||
if (!itemOn && skullAnimCounter < 4) // blink cursor
|
||||
V_DrawCharacter(mx + 40 + V_StringWidth(setupm_name, V_ALLOWLOWERCASE), my + nameboxaddy, '_', false);
|
||||
if (itemOn != 0)
|
||||
V_DrawString(mx + 40, my + nameboxaddy, V_ALLOWLOWERCASE, setupm_input.buffer);
|
||||
else
|
||||
M_DrawTextInput(mx + 40, my + nameboxaddy, &setupm_input, 0);
|
||||
|
||||
// draw skin string
|
||||
st = V_StringWidth(skins[setupm_fakeskin].realname, 0);
|
||||
@@ -11180,7 +11186,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
// Handle 1P/2P MP Setup
|
||||
static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
{
|
||||
size_t l;
|
||||
boolean exitmenu = false; // exit to previous menu and send name change
|
||||
|
||||
if ((choice == gamecontrol[gc_fire][0] || choice == gamecontrol[gc_fire][1]) && itemOn == 2)
|
||||
@@ -11302,7 +11307,12 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
break;
|
||||
|
||||
case KEY_LEFTARROW:
|
||||
if (cv_skinselectmenu.value == SKINMENUTYPE_2D && itemOn == 1)
|
||||
if (itemOn == 0)
|
||||
{
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
}
|
||||
else if (cv_skinselectmenu.value == SKINMENUTYPE_2D && itemOn == 1)
|
||||
{
|
||||
if (setupm_skinlockedselect)
|
||||
{
|
||||
@@ -11356,7 +11366,12 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
break;
|
||||
|
||||
case KEY_RIGHTARROW:
|
||||
if (cv_skinselectmenu.value == SKINMENUTYPE_2D && itemOn == 1)
|
||||
if (itemOn == 0)
|
||||
{
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
}
|
||||
else if (cv_skinselectmenu.value == SKINMENUTYPE_2D && itemOn == 1)
|
||||
{
|
||||
if (setupm_skinlockedselect)
|
||||
{
|
||||
@@ -11387,7 +11402,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
}
|
||||
else if (cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED){
|
||||
if (setupm_skinselect >= ((setupm_skinypos-1)+SKINGRIDHEIGHT)*8+24 && setupm_skinypos < (ROUNDSKINSUPTO8/8)-SKINGRIDHEIGHT+24)
|
||||
setupm_skinypos++;
|
||||
setupm_skinypos++;
|
||||
}
|
||||
}
|
||||
else
|
||||
@@ -11425,11 +11440,8 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
BREAKWHENLOCKED
|
||||
if (itemOn == 0)
|
||||
{
|
||||
if ((l = strlen(setupm_name))!=0)
|
||||
{
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_name[l-1] =0;
|
||||
}
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
}
|
||||
else if ((cv_skinselectmenu.value == SKINMENUTYPE_GRID || cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED) && itemOn == 1)
|
||||
{
|
||||
@@ -11454,10 +11466,10 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
case KEY_DEL:
|
||||
if (cv_skinselectmenu.value)
|
||||
BREAKWHENLOCKED
|
||||
if (itemOn == 0 && (l = strlen(setupm_name))!=0)
|
||||
if (itemOn == 0)
|
||||
{
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_name[0] = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -11494,17 +11506,10 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
break;
|
||||
|
||||
default:
|
||||
if (choice < 32 || choice > 127)
|
||||
break;
|
||||
if (itemOn == 0)
|
||||
{
|
||||
l = strlen(setupm_name);
|
||||
if (l < MAXPLAYERNAME)
|
||||
{
|
||||
if (M_TextInputHandle(&setupm_input, choice))
|
||||
S_StartSound(NULL,sfx_menu1); // Tails
|
||||
setupm_name[l] =(char)choice;
|
||||
setupm_name[l+1] =0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
@@ -11569,7 +11574,9 @@ static void M_SetupMultiPlayer(INT32 choice)
|
||||
|
||||
multi_state = cv_skinselectspin.value == SKINSELECTSPIN_PAIN ? &states[S_KART_PAIN] : &states[mobjinfo[MT_PLAYER].seestate];
|
||||
multi_tics = multi_state->tics*FRACUNIT;
|
||||
strcpy(setupm_name, cv_playername.string);
|
||||
|
||||
M_TextInputInit(&setupm_input, setupm_name, sizeof(setupm_name));
|
||||
M_TextInputSetString(&setupm_input, cv_playername.string);
|
||||
|
||||
// set for player 1
|
||||
setupm_player = &players[consoleplayer];
|
||||
@@ -11611,7 +11618,9 @@ static void M_SetupMultiPlayer2(INT32 choice)
|
||||
|
||||
multi_state = cv_skinselectspin.value == SKINSELECTSPIN_PAIN ? &states[S_KART_PAIN] : &states[mobjinfo[MT_PLAYER].seestate];
|
||||
multi_tics = multi_state->tics*FRACUNIT;
|
||||
strcpy (setupm_name, cv_playername2.string);
|
||||
|
||||
M_TextInputInit(&setupm_input, setupm_name, sizeof(setupm_name));
|
||||
M_TextInputSetString(&setupm_input, cv_playername2.string);
|
||||
|
||||
// set for splitscreen secondary player
|
||||
setupm_player = &players[displayplayers[1]];
|
||||
@@ -11652,7 +11661,9 @@ static void M_SetupMultiPlayer3(INT32 choice)
|
||||
|
||||
multi_state = cv_skinselectspin.value == SKINSELECTSPIN_PAIN ? &states[S_KART_PAIN] : &states[mobjinfo[MT_PLAYER].seestate];
|
||||
multi_tics = multi_state->tics;
|
||||
strcpy(setupm_name, cv_playername3.string);
|
||||
|
||||
M_TextInputInit(&setupm_input, setupm_name, sizeof(setupm_name));
|
||||
M_TextInputSetString(&setupm_input, cv_playername3.string);
|
||||
|
||||
// set for splitscreen third player
|
||||
setupm_player = &players[displayplayers[2]];
|
||||
@@ -11693,7 +11704,9 @@ static void M_SetupMultiPlayer4(INT32 choice)
|
||||
|
||||
multi_state = cv_skinselectspin.value == SKINSELECTSPIN_PAIN ? &states[S_KART_PAIN] : &states[mobjinfo[MT_PLAYER].seestate];
|
||||
multi_tics = multi_state->tics;
|
||||
strcpy(setupm_name, cv_playername4.string);
|
||||
|
||||
M_TextInputInit(&setupm_input, setupm_name, sizeof(setupm_name));
|
||||
M_TextInputSetString(&setupm_input, cv_playername4.string);
|
||||
|
||||
// set for splitscreen fourth player
|
||||
setupm_player = &players[displayplayers[3]];
|
||||
@@ -12877,10 +12890,12 @@ static void M_DrawColorMenu(void)
|
||||
if (y + 12 > (currentMenu->y + 2*scrollareaheight))
|
||||
break;
|
||||
M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
if (skullAnimCounter < 4 && i == itemOn)
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(cv->string, 0), y + 12,
|
||||
'_' | 0x80, false);
|
||||
|
||||
if (itemOn == i)
|
||||
M_DrawTextInput(x + 8, y + 12, &menuinput, 0);
|
||||
else
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, cv->string);
|
||||
|
||||
y += 16;
|
||||
break;
|
||||
default:
|
||||
|
||||
@@ -64,6 +64,10 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines);
|
||||
// Same but with extra flags applied
|
||||
void M_DrawTextBoxFlags(INT32 x, INT32 y, INT32 width, INT32 boxlines, INT32 flags);
|
||||
|
||||
// Draw text input
|
||||
typedef struct textinput_s textinput_t;
|
||||
void M_DrawTextInput(INT32 x, INT32 y, textinput_t *input, INT32 flags);
|
||||
|
||||
// Used in d_netcmd to restart time attack
|
||||
void M_ModeAttackRetry(INT32 choice);
|
||||
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
#include "m_textinput.h"
|
||||
#include "i_system.h"
|
||||
#include "keys.h"
|
||||
#include "console.h"
|
||||
|
||||
static void M_TextInputDel(textinput_t *input, size_t start, size_t end)
|
||||
{
|
||||
size_t len;
|
||||
|
||||
len = (end - start);
|
||||
|
||||
if (end != input->length)
|
||||
memmove(&input->buffer[start], &input->buffer[end], input->length-end);
|
||||
memset(&input->buffer[input->length - len], 0, len);
|
||||
|
||||
input->length -= len;
|
||||
|
||||
if (input->select >= end)
|
||||
input->select -= len;
|
||||
else if (input->select > start)
|
||||
input->select = start;
|
||||
|
||||
if (input->cursor >= end)
|
||||
input->cursor -= len;
|
||||
else if (input->cursor > start)
|
||||
input->cursor = start;
|
||||
}
|
||||
|
||||
static void M_TextInputDelSelection(textinput_t *input)
|
||||
{
|
||||
size_t start, end;
|
||||
|
||||
if (input->cursor > input->select)
|
||||
{
|
||||
start = input->select;
|
||||
end = input->cursor;
|
||||
}
|
||||
else
|
||||
{
|
||||
start = input->cursor;
|
||||
end = input->select;
|
||||
}
|
||||
|
||||
M_TextInputDel(input, start, end);
|
||||
|
||||
input->select = input->cursor = start;
|
||||
}
|
||||
|
||||
static void M_TextInputAddString(textinput_t *input, const char *c)
|
||||
{
|
||||
size_t csize = strlen(c);
|
||||
|
||||
if (input->length + csize > input->buffer_size-1)
|
||||
return;
|
||||
|
||||
if (input->cursor != input->length)
|
||||
memmove(&input->buffer[input->cursor+csize], &input->buffer[input->cursor], input->length-input->cursor);
|
||||
memcpy(&input->buffer[input->cursor], c, csize);
|
||||
input->length += csize;
|
||||
input->select = (input->cursor += csize);
|
||||
input->buffer[input->length] = 0;
|
||||
}
|
||||
|
||||
static void M_TextInputAddChar(textinput_t *input, char c)
|
||||
{
|
||||
if (input->length >= input->buffer_size-1)
|
||||
return;
|
||||
|
||||
if (input->cursor != input->length)
|
||||
memmove(&input->buffer[input->cursor+1], &input->buffer[input->cursor], input->length-input->cursor);
|
||||
input->buffer[input->cursor++] = c;
|
||||
input->buffer[++input->length] = 0;
|
||||
input->select = input->cursor;
|
||||
}
|
||||
|
||||
static void M_TextInputDelChar(textinput_t *input)
|
||||
{
|
||||
if (!input->cursor)
|
||||
return;
|
||||
|
||||
if (input->cursor != input->length)
|
||||
memmove(&input->buffer[input->cursor-1], &input->buffer[input->cursor], input->length-input->cursor);
|
||||
input->buffer[--input->length] = 0;
|
||||
input->select = --input->cursor;
|
||||
}
|
||||
|
||||
static void M_TextInputToWordEnd(textinput_t *input, boolean move_sel)
|
||||
{
|
||||
// Skip spaces
|
||||
while (input->cursor < input->length && isspace(input->buffer[input->cursor]))
|
||||
++input->cursor;
|
||||
|
||||
// Skip word
|
||||
while (input->cursor < input->length && !isspace(input->buffer[input->cursor]))
|
||||
++input->cursor;
|
||||
|
||||
if (move_sel) input->select = input->cursor;
|
||||
}
|
||||
|
||||
static void M_TextInputToWordBegin(textinput_t *input, boolean move_sel)
|
||||
{
|
||||
// Hack, always move back 1 character if possible so if we press ctrl-left at a word beginning
|
||||
// we move to previous word
|
||||
if (input->cursor) --input->cursor;
|
||||
|
||||
// Skip spaces
|
||||
while (input->cursor && isspace(input->buffer[input->cursor]))
|
||||
--input->cursor;
|
||||
|
||||
// Skip word
|
||||
while (input->cursor && !isspace(input->buffer[input->cursor]))
|
||||
--input->cursor;
|
||||
|
||||
// Unless we reached beginning of line, we're pointing at a space before word, so move cursor
|
||||
// forward to fix that
|
||||
if (input->cursor) ++input->cursor;
|
||||
|
||||
if (move_sel) input->select = input->cursor;
|
||||
}
|
||||
|
||||
void M_TextInputInit(textinput_t *input, char *buffer, size_t buffer_size)
|
||||
{
|
||||
input->buffer = buffer;
|
||||
input->buffer_size = buffer_size;
|
||||
|
||||
M_TextInputClear(input);
|
||||
}
|
||||
|
||||
void M_TextInputClear(textinput_t *input)
|
||||
{
|
||||
input->cursor = 0;
|
||||
input->select = 0;
|
||||
input->length = 0;
|
||||
}
|
||||
|
||||
void M_TextInputSetString(textinput_t *input, const char *c)
|
||||
{
|
||||
memset(input->buffer, 0, input->buffer_size);
|
||||
strcpy(input->buffer, c);
|
||||
input->cursor = input->select = input->length = strlen(c);
|
||||
}
|
||||
|
||||
boolean M_TextInputHandle(textinput_t *input, INT32 key)
|
||||
{
|
||||
if (key == KEY_LSHIFT || key == KEY_RSHIFT
|
||||
|| key == KEY_LCTRL || key == KEY_RCTRL
|
||||
|| key == KEY_LALT || key == KEY_RALT)
|
||||
return false;
|
||||
|
||||
if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
|
||||
{
|
||||
if (key == 'x' || key == 'X')
|
||||
{
|
||||
if (input->select > input->cursor)
|
||||
I_ClipboardCopy(&input->buffer[input->cursor], input->select-input->cursor);
|
||||
else
|
||||
I_ClipboardCopy(&input->buffer[input->select], input->cursor-input->select);
|
||||
M_TextInputDelSelection(input);
|
||||
return true;
|
||||
}
|
||||
else if (key == 'c' || key == 'C')
|
||||
{
|
||||
if (input->select > input->cursor)
|
||||
I_ClipboardCopy(&input->buffer[input->cursor], input->select-input->cursor);
|
||||
else
|
||||
I_ClipboardCopy(&input->buffer[input->select], input->cursor-input->select);
|
||||
return true;
|
||||
}
|
||||
else if (key == 'v' || key == 'V')
|
||||
{
|
||||
const char *paste = I_ClipboardPaste();
|
||||
if (input->select != input->cursor)
|
||||
M_TextInputDelSelection(input);
|
||||
if (paste != NULL)
|
||||
M_TextInputAddString(input, paste);
|
||||
return true;
|
||||
}
|
||||
else if (key == 'w' || key == 'W')
|
||||
{
|
||||
size_t word_start, word_end, i;
|
||||
word_end = i = input->cursor;
|
||||
|
||||
// Unless we're pointing at the beginning of line, decrement i so we only start
|
||||
// removing symbols that come before the cursor
|
||||
if (i) --i;
|
||||
|
||||
// We might be pointing to spaces, skip them first
|
||||
while (i && isspace(input->buffer[i]))
|
||||
--i;
|
||||
|
||||
// Now skip the "word"
|
||||
while (i && !isspace(input->buffer[i]))
|
||||
--i;
|
||||
|
||||
// Unless we reached beginning of line, i is pointing at first space that was found
|
||||
// before word start, and we don't want to remove it
|
||||
if (i) ++i;
|
||||
|
||||
word_start = i;
|
||||
|
||||
if (word_start != word_end)
|
||||
M_TextInputDel(input, word_start, word_end);
|
||||
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_RIGHTARROW)
|
||||
M_TextInputToWordEnd(input, !shiftdown);
|
||||
else if (key == KEY_LEFTARROW)
|
||||
M_TextInputToWordBegin(input, !shiftdown);
|
||||
|
||||
// Select all
|
||||
if (key == 'a' || key == 'A')
|
||||
{
|
||||
input->select = 0;
|
||||
input->cursor = input->length;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ...why shouldn't it eat the key? if it doesn't, it just means you
|
||||
// can control Sonic from the console, which is silly
|
||||
return true;
|
||||
}
|
||||
|
||||
if (key == KEY_LEFTARROW)
|
||||
{
|
||||
if (input->cursor != 0)
|
||||
--input->cursor;
|
||||
if (!shiftdown)
|
||||
input->select = input->cursor;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_RIGHTARROW)
|
||||
{
|
||||
if (input->cursor < input->length)
|
||||
++input->cursor;
|
||||
if (!shiftdown)
|
||||
input->select = input->cursor;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_HOME)
|
||||
{
|
||||
input->cursor = 0;
|
||||
if (!shiftdown)
|
||||
input->select = input->cursor;
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_END)
|
||||
{
|
||||
input->cursor = input->length;
|
||||
if (!shiftdown)
|
||||
input->select = input->cursor;
|
||||
return true;
|
||||
}
|
||||
|
||||
// backspace and delete command prompt
|
||||
if (input->select != input->cursor)
|
||||
{
|
||||
if (key == KEY_BACKSPACE || key == KEY_DEL)
|
||||
{
|
||||
M_TextInputDelSelection(input);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (key == KEY_BACKSPACE)
|
||||
{
|
||||
M_TextInputDelChar(input);
|
||||
return true;
|
||||
}
|
||||
else if (key == KEY_DEL)
|
||||
{
|
||||
if (input->cursor == input->length)
|
||||
return true;
|
||||
++input->cursor;
|
||||
M_TextInputDelChar(input);
|
||||
return true;
|
||||
}
|
||||
|
||||
// allow people to use keypad in console (good for typing IP addresses) - Calum
|
||||
if (key >= KEY_KEYPAD7 && key <= KEY_KPADDEL)
|
||||
{
|
||||
char keypad_translation[] = {'7','8','9','-',
|
||||
'4','5','6','+',
|
||||
'1','2','3',
|
||||
'0','.'};
|
||||
|
||||
key = keypad_translation[key - KEY_KEYPAD7];
|
||||
}
|
||||
else if (key == KEY_KPADSLASH)
|
||||
key = '/';
|
||||
|
||||
// same capslock code as hu_stuff.c's HU_responder. Check there for details.
|
||||
key = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(key) : CON_ShiftChar(key);
|
||||
|
||||
// enter a char into the command prompt
|
||||
if (key < 32 || key > 127)
|
||||
return false;
|
||||
|
||||
if (input->select != input->cursor)
|
||||
M_TextInputDelSelection(input);
|
||||
M_TextInputAddChar(input, key);
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
#ifndef __M_TEXTINPUT__
|
||||
#define __M_TEXTINPUT__
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
typedef struct textinput_s {
|
||||
size_t cursor;
|
||||
size_t select;
|
||||
size_t length;
|
||||
|
||||
char *buffer;
|
||||
size_t buffer_size;
|
||||
} textinput_t;
|
||||
|
||||
void M_TextInputInit(textinput_t *input, char *buffer, size_t buffer_size);
|
||||
|
||||
void M_TextInputClear(textinput_t *input);
|
||||
|
||||
void M_TextInputSetString(textinput_t *input, const char *c);
|
||||
|
||||
boolean M_TextInputHandle(textinput_t *input, INT32 key);
|
||||
|
||||
#endif
|
||||
+27
-64
@@ -35,33 +35,23 @@ void P_ClosestPointOnLine(fixed_t x, fixed_t y, line_t *line, vertex_t *result)
|
||||
fixed_t dy = line->dy;
|
||||
|
||||
// Determine t (the length of the vector from �Line[0]� to �p�)
|
||||
fixed_t cx, cy;
|
||||
fixed_t vx, vy;
|
||||
fixed_t magnitude;
|
||||
fixed_t t;
|
||||
|
||||
//Sub (p, &Line[0], &c);
|
||||
cx = x - startx;
|
||||
cy = y - starty;
|
||||
|
||||
//Sub (&Line[1], &Line[0], &V);
|
||||
vx = dx;
|
||||
vy = dy;
|
||||
|
||||
//Normalize (&V, &V);
|
||||
magnitude = R_PointToDist2(line->v2->x, line->v2->y, startx, starty);
|
||||
vx = FixedDiv(vx, magnitude);
|
||||
vy = FixedDiv(vy, magnitude);
|
||||
dx = FixedDiv(dx, magnitude);
|
||||
dy = FixedDiv(dy, magnitude);
|
||||
|
||||
t = (FixedMul(vx, cx) + FixedMul(vy, cy));
|
||||
t = (FixedMul(dx, (x - startx)) + FixedMul(dy, (y - starty)));
|
||||
|
||||
// Return the point between �Line[0]� and �Line[1]�
|
||||
vx = FixedMul(vx, t);
|
||||
vy = FixedMul(vy, t);
|
||||
dx = FixedMul(dx, t);
|
||||
dy = FixedMul(dy, t);
|
||||
|
||||
//Add (&Line[0], &V, out);
|
||||
result->x = startx + vx;
|
||||
result->y = starty + vy;
|
||||
result->x = startx + dx;
|
||||
result->y = starty + dy;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -79,28 +69,15 @@ void P_ClosestPointOnLine3D(fixed_t x, fixed_t y, fixed_t z, line_t *line, verte
|
||||
fixed_t dz = line->v2->z - line->v1->z;
|
||||
|
||||
// Determine t (the length of the vector from �Line[0]� to �p�)
|
||||
fixed_t cx, cy, cz;
|
||||
fixed_t vx, vy, vz;
|
||||
fixed_t magnitude;
|
||||
fixed_t t;
|
||||
|
||||
//Sub (p, &Line[0], &c);
|
||||
cx = x - startx;
|
||||
cy = y - starty;
|
||||
cz = z - startz;
|
||||
|
||||
//Sub (&Line[1], &Line[0], &V);
|
||||
vx = dx;
|
||||
vy = dy;
|
||||
vz = dz;
|
||||
|
||||
//Normalize (&V, &V);
|
||||
magnitude = R_PointToDist2(0, line->v2->z, R_PointToDist2(line->v2->x, line->v2->y, startx, starty), startz);
|
||||
vx = FixedDiv(vx, magnitude);
|
||||
vy = FixedDiv(vy, magnitude);
|
||||
vz = FixedDiv(vz, magnitude);
|
||||
dx = FixedDiv(dx, magnitude);
|
||||
dy = FixedDiv(dy, magnitude);
|
||||
dz = FixedDiv(dz, magnitude);
|
||||
|
||||
t = (FixedMul(vx, cx) + FixedMul(vy, cy) + FixedMul(vz, cz));
|
||||
t = (FixedMul(dx, (x - startx)) + FixedMul(dy, (y - starty)) + FixedMul(dz, (z - startz)));
|
||||
|
||||
// Set closest point to the end if it extends past -Red
|
||||
if (t <= 0)
|
||||
@@ -119,14 +96,14 @@ void P_ClosestPointOnLine3D(fixed_t x, fixed_t y, fixed_t z, line_t *line, verte
|
||||
}
|
||||
|
||||
// Return the point between �Line[0]� and �Line[1]�
|
||||
vx = FixedMul(vx, t);
|
||||
vy = FixedMul(vy, t);
|
||||
vz = FixedMul(vz, t);
|
||||
dx = FixedMul(dx, t);
|
||||
dy = FixedMul(dy, t);
|
||||
dz = FixedMul(dz, t);
|
||||
|
||||
//Add (&Line[0], &V, out);
|
||||
result->x = startx + vx;
|
||||
result->y = starty + vy;
|
||||
result->z = startz + vz;
|
||||
result->x = startx + dx;
|
||||
result->y = starty + dy;
|
||||
result->z = startz + dz;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -136,21 +113,16 @@ void P_ClosestPointOnLine3D(fixed_t x, fixed_t y, fixed_t z, line_t *line, verte
|
||||
//
|
||||
INT32 P_PointOnLineSide(fixed_t x, fixed_t y, const line_t *line)
|
||||
{
|
||||
fixed_t dx, dy, left, right;
|
||||
|
||||
if (!line->dx)
|
||||
return x <= line->v1->x ? line->dy > 0 : line->dy < 0;
|
||||
|
||||
if (!line->dy)
|
||||
return y <= line->v1->y ? line->dx < 0 : line->dx > 0;
|
||||
|
||||
dx = (x - line->v1->x);
|
||||
dy = (y - line->v1->y);
|
||||
x -= line->v1->x;
|
||||
y -= line->v1->y;
|
||||
|
||||
left = FixedMul(line->dy>>FRACBITS, dx);
|
||||
right = FixedMul(dy, line->dx>>FRACBITS);
|
||||
|
||||
return right < left ? 0 : 1;
|
||||
return FixedMul(y, line->dx>>FRACBITS) < FixedMul(line->dy>>FRACBITS, x) ? 0 : 1;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -210,28 +182,22 @@ INT32 P_BoxOnLineSide(fixed_t *tmbox, const line_t *ld)
|
||||
//
|
||||
static INT32 P_PointOnDivlineSide(fixed_t x, fixed_t y, divline_t *line)
|
||||
{
|
||||
fixed_t dx, dy, left, right;
|
||||
|
||||
if (!line->dx)
|
||||
return x <= line->x ? line->dy > 0 : line->dy < 0;
|
||||
|
||||
if (!line->dy)
|
||||
return y <= line->y ? line->dx < 0 : line->dx > 0;
|
||||
|
||||
dx = (x - line->x);
|
||||
dy = (y - line->y);
|
||||
x -= line->x;
|
||||
y -= line->y;
|
||||
|
||||
// try to quickly decide by looking at sign bits
|
||||
if ((line->dy ^ line->dx ^ dx ^ dy) & 0x80000000)
|
||||
return ((line->dy ^ dx) & 0x80000000) ? 1 : 0;
|
||||
if ((line->dy ^ line->dx ^ x ^ y) & 0x80000000)
|
||||
return ((line->dy ^ x) & 0x80000000) ? 1 : 0;
|
||||
|
||||
left = FixedMul(line->dy>>8, dx>>8);
|
||||
right = FixedMul(dy>>8, line->dx>>8);
|
||||
|
||||
return right < left ? 0 : 1;
|
||||
return FixedMul(y>>8, line->dx>>8) < FixedMul(line->dy>>8, x>>8) ? 0 : 1;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_MakeDivline
|
||||
//
|
||||
@@ -250,17 +216,14 @@ void P_MakeDivline(line_t *li, divline_t *dl)
|
||||
//
|
||||
fixed_t P_InterceptVector(divline_t *v2, divline_t *v1)
|
||||
{
|
||||
fixed_t frac, num, den;
|
||||
fixed_t den;
|
||||
|
||||
den = FixedMul(v1->dy>>8, v2->dx) - FixedMul(v1->dx>>8, v2->dy);
|
||||
|
||||
if (!den)
|
||||
return 0;
|
||||
|
||||
num = FixedMul((v1->x - v2->x)>>8, v1->dy) + FixedMul((v2->y - v1->y)>>8, v1->dx);
|
||||
frac = FixedDiv(num, den);
|
||||
|
||||
return frac;
|
||||
return (FixedDiv(FixedMul((v1->x - v2->x)>>8, v1->dy) + FixedMul((v2->y - v1->y)>>8, v1->dx), den));
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
+1
-1
@@ -2683,7 +2683,7 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
// As oddly named as this is, this handles music only.
|
||||
// We should be fine starting it here.
|
||||
if (!reloadinggamestate)
|
||||
S_Start();
|
||||
S_InitMapMusic();
|
||||
|
||||
levelfadecol = (encoremode && !ranspecialwipe ? 122 : 120);
|
||||
|
||||
|
||||
+18
-3
@@ -99,6 +99,8 @@ typedef struct
|
||||
thinker_t **thinkers;
|
||||
} thinkerlist_t;
|
||||
|
||||
//static boolean fromlapexec = false;
|
||||
|
||||
static void P_SearchForDisableLinedefs(void);
|
||||
static void P_SpawnScrollers(void);
|
||||
static void P_SpawnFriction(void);
|
||||
@@ -1340,6 +1342,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
|
||||
fixed_t dist = P_AproxDistance(triggerline->dx, triggerline->dy)>>FRACBITS;
|
||||
size_t i, linecnt, sectori;
|
||||
INT16 specialtype = triggerline->special;
|
||||
//fromlapexec = false;
|
||||
|
||||
/////////////////////////////////////////////////
|
||||
// Distance-checking/sector trigger conditions //
|
||||
@@ -1461,6 +1464,8 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
|
||||
if (lap != (sides[triggerline->sidenum[0]].textureoffset >> FRACBITS))
|
||||
return false;
|
||||
}
|
||||
|
||||
//fromlapexec = true;
|
||||
}
|
||||
// If we were not triggered by a sector type especially for the purpose,
|
||||
// a Linedef Executor linedef trigger is not handling sector triggers properly, return.
|
||||
@@ -2113,12 +2118,12 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
return;
|
||||
|
||||
if (bot)
|
||||
P_Teleport(bot, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, (line->flags & ML_BLOCKMONSTERS) == 0, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
P_Teleport(bot, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, (line->flags & ML_BLOCKMONSTERS) == 0, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
if (line->flags & ML_BLOCKMONSTERS)
|
||||
P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, false, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, false, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
else
|
||||
{
|
||||
P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, true, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, true, (line->flags & ML_EFFECT4) == ML_EFFECT4);
|
||||
// Play the 'bowrwoosh!' sound
|
||||
S_StartSound(dest, sfx_mixup);
|
||||
}
|
||||
@@ -2127,6 +2132,12 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
break;
|
||||
|
||||
case 413: // Change music
|
||||
if (keepmusic && (leveltime <= MUSICSTARTTIME)) //why check for starttime? cause encore music Zzz...
|
||||
return;
|
||||
|
||||
//if (cv_ignoremusicchanges.value && (leveltime >= MUSICSTARTTIME) && !fromlapexec) // keep lap music intanct tho
|
||||
//return;
|
||||
|
||||
// console player only unless NOCLIMB is set
|
||||
if ((line->flags & ML_NOCLIMB) || (mo && mo->player && P_IsLocalPlayer(mo->player)))
|
||||
{
|
||||
@@ -2207,6 +2218,10 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
{
|
||||
INT32 sfxnum;
|
||||
|
||||
//dont play any funky sound intros that may interfere with the music
|
||||
if (skipintromus && (leveltime < MUSICSTARTTIME))
|
||||
return;
|
||||
|
||||
sfxnum = sides[line->sidenum[0]].toptexture; //P_AproxDistance(line->dx, line->dy)>>FRACBITS;
|
||||
|
||||
if (sfxnum == sfx_None)
|
||||
|
||||
+3
-4
@@ -742,9 +742,8 @@ void P_RestoreMusic(player_t *player)
|
||||
if (P_EndingMusic(player))
|
||||
return;
|
||||
|
||||
// Event - Level Start
|
||||
if (leveltime < (starttime + (TICRATE/2)))
|
||||
S_ChangeMusicInternal((encoremode ? "estart" : "kstart"), false); //S_StopMusic();
|
||||
if (leveltime < MUSICSTARTTIME)
|
||||
S_StartMapMusic(true);
|
||||
else // see also where time overs are handled - search for "lives = 2" in this file
|
||||
{
|
||||
INT32 wantedmus = 0; // 0 is level music, 1 is invincibility, 2 is grow
|
||||
@@ -1250,7 +1249,7 @@ void P_DoPlayerExit(player_t *player)
|
||||
player->exiting = raceexittime+2;
|
||||
K_KartUpdatePosition(player);
|
||||
|
||||
if (cv_kartvoices.value)
|
||||
if (!P_MobjWasRemoved(player->mo) && cv_kartvoices.value)
|
||||
{
|
||||
if (P_IsLocalPlayer(player))
|
||||
{
|
||||
|
||||
@@ -78,6 +78,7 @@ fixed_t dc_iscale, dc_texturemid;
|
||||
UINT8 dc_hires; // under MSVC boolean is a byte, while on other systems, it a bit,
|
||||
// soo lets make it a byte on all system for the ASM code
|
||||
UINT8 *dc_source;
|
||||
INT32 dc_sourcelength;
|
||||
|
||||
// -----------------------
|
||||
// translucency stuff here
|
||||
|
||||
@@ -62,6 +62,7 @@ extern lighttable_t *ds_colormap;
|
||||
extern fixed_t ds_xfrac, ds_yfrac, ds_xstep, ds_ystep;
|
||||
extern INT32 ds_waterofs, ds_bgofs;
|
||||
extern UINT8 *ds_source; // start of a 64*64 tile image
|
||||
extern INT32 dc_sourcelength;
|
||||
extern UINT8 *ds_transmap;
|
||||
|
||||
extern INT32 ds_bgofs;
|
||||
|
||||
+130
-34
@@ -28,6 +28,8 @@ void R_DrawColumn_8(void)
|
||||
register UINT8 *dest;
|
||||
register fixed_t frac;
|
||||
fixed_t fracstep;
|
||||
INT32 npow2min;
|
||||
INT32 npow2max;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
|
||||
@@ -51,13 +53,26 @@ void R_DrawColumn_8(void)
|
||||
fracstep = dc_iscale;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
|
||||
|
||||
// Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
|
||||
// This is as fast as it gets.
|
||||
{
|
||||
register const UINT8 *source = dc_source;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
@@ -74,7 +89,10 @@ void R_DrawColumn_8(void)
|
||||
// Re-map color indices from wall texture column
|
||||
// using a lighting/special effects LUT.
|
||||
// heightmask is the Tutti-Frutti fix
|
||||
*dest = colormap[source[frac>>FRACBITS]];
|
||||
|
||||
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
|
||||
// and a few bytes after as well
|
||||
*dest = colormap[source[CLAMP(frac>>FRACBITS, npow2min, npow2max)]];
|
||||
dest += vid.width;
|
||||
|
||||
// Avoid overflow.
|
||||
@@ -115,6 +133,8 @@ void R_Draw2sMultiPatchColumn_8(void)
|
||||
register UINT8 *dest;
|
||||
register fixed_t frac;
|
||||
fixed_t fracstep;
|
||||
INT32 npow2min;
|
||||
INT32 npow2max;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
|
||||
@@ -147,6 +167,20 @@ void R_Draw2sMultiPatchColumn_8(void)
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
register UINT8 val;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
@@ -163,7 +197,10 @@ void R_Draw2sMultiPatchColumn_8(void)
|
||||
// Re-map color indices from wall texture column
|
||||
// using a lighting/special effects LUT.
|
||||
// heightmask is the Tutti-Frutti fix
|
||||
val = source[frac>>FRACBITS];
|
||||
|
||||
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
|
||||
// and a few bytes after as well
|
||||
val = source[CLAMP(frac>>FRACBITS, npow2min, npow2max)];
|
||||
|
||||
if (val != TRANSPARENTPIXEL)
|
||||
{
|
||||
@@ -223,6 +260,8 @@ void R_Draw2sMultiPatchTranslucentColumn_8(void)
|
||||
register UINT8 *dest;
|
||||
register fixed_t frac;
|
||||
fixed_t fracstep;
|
||||
INT32 npow2min;
|
||||
INT32 npow2max;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
|
||||
@@ -256,6 +295,20 @@ void R_Draw2sMultiPatchTranslucentColumn_8(void)
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
register UINT8 val;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
@@ -272,7 +325,10 @@ void R_Draw2sMultiPatchTranslucentColumn_8(void)
|
||||
// Re-map color indices from wall texture column
|
||||
// using a lighting/special effects LUT.
|
||||
// heightmask is the Tutti-Frutti fix
|
||||
val = source[frac>>FRACBITS];
|
||||
|
||||
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
|
||||
// and a few bytes after as well
|
||||
val = source[CLAMP(frac>>FRACBITS, npow2min, npow2max)];
|
||||
|
||||
if (val != TRANSPARENTPIXEL)
|
||||
{
|
||||
@@ -376,6 +432,8 @@ void R_DrawTranslucentColumn_8(void)
|
||||
register INT32 count;
|
||||
register UINT8 *dest;
|
||||
register fixed_t frac, fracstep;
|
||||
INT32 npow2min;
|
||||
INT32 npow2max;
|
||||
|
||||
count = dc_yh - dc_yl + 1;
|
||||
|
||||
@@ -403,6 +461,20 @@ void R_DrawTranslucentColumn_8(void)
|
||||
register const UINT8 *transmap = dc_transmap;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight - 1;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
|
||||
if (dc_texheight & heightmask)
|
||||
{
|
||||
heightmask++;
|
||||
@@ -420,7 +492,11 @@ void R_DrawTranslucentColumn_8(void)
|
||||
// Re-map color indices from wall texture column
|
||||
// using a lighting/special effects LUT.
|
||||
// heightmask is the Tutti-Frutti fix
|
||||
*dest = *(transmap + (colormap[source[frac>>FRACBITS]]<<8) + (*dest));
|
||||
|
||||
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
|
||||
// and a few bytes after as well
|
||||
*dest = *(transmap + (colormap[source[CLAMP(frac>>FRACBITS, npow2min, npow2max)]]<<8) + (*dest));
|
||||
|
||||
dest += vid.width;
|
||||
|
||||
if ((frac += fracstep) >= heightmask)
|
||||
@@ -458,6 +534,8 @@ void R_DrawTranslatedTranslucentColumn_8(void)
|
||||
register INT32 count;
|
||||
register UINT8 *dest;
|
||||
register fixed_t frac, fracstep;
|
||||
INT32 npow2min;
|
||||
INT32 npow2max;
|
||||
|
||||
count = dc_yh - dc_yl + 1;
|
||||
|
||||
@@ -477,6 +555,20 @@ void R_DrawTranslatedTranslucentColumn_8(void)
|
||||
// This is as fast as it gets.
|
||||
{
|
||||
register INT32 heightmask = dc_texheight - 1;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
|
||||
if (dc_texheight & heightmask)
|
||||
{
|
||||
heightmask++;
|
||||
@@ -494,7 +586,10 @@ void R_DrawTranslatedTranslucentColumn_8(void)
|
||||
// Re-map color indices from wall texture column
|
||||
// using a lighting/special effects LUT.
|
||||
// heightmask is the Tutti-Frutti fix
|
||||
*dest = *(dc_transmap + (dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]]<<8) + (*dest));
|
||||
|
||||
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
|
||||
// and a few bytes after as well
|
||||
*dest = *(dc_transmap + (dc_colormap[dc_translation[dc_source[CLAMP(frac>>FRACBITS, npow2min, npow2max)]]]<<8) + (*dest));
|
||||
dest += vid.width;
|
||||
|
||||
if ((frac += fracstep) >= heightmask)
|
||||
@@ -586,14 +681,14 @@ void R_DrawSpan_8 (void)
|
||||
fixed_t xposition;
|
||||
fixed_t yposition;
|
||||
fixed_t xstep, ystep;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
|
||||
|
||||
size_t count = (ds_x2 - ds_x1 + 1);
|
||||
register size_t count = (ds_x2 - ds_x1 + 1);
|
||||
size_t i;
|
||||
|
||||
xposition = ds_xfrac; yposition = ds_yfrac;
|
||||
@@ -681,13 +776,13 @@ void R_DrawTiltedSpan_8(void)
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
double startz, startu, startv;
|
||||
double izstep, uzstep, vzstep;
|
||||
double endz, endu, endv;
|
||||
UINT32 stepu, stepv;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
|
||||
|
||||
@@ -822,13 +917,13 @@ void R_DrawTiltedTranslucentSpan_8(void)
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
double startz, startu, startv;
|
||||
double izstep, uzstep, vzstep;
|
||||
double endz, endu, endv;
|
||||
UINT32 stepu, stepv;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
|
||||
|
||||
@@ -964,14 +1059,14 @@ void R_DrawTiltedTranslucentWaterSpan_8(void)
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
UINT8 *dsrc;
|
||||
|
||||
double startz, startu, startv;
|
||||
double izstep, uzstep, vzstep;
|
||||
double endz, endu, endv;
|
||||
UINT32 stepu, stepv;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
|
||||
|
||||
@@ -1105,7 +1200,7 @@ void R_DrawTiltedSplat_8(void)
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
UINT8 val;
|
||||
|
||||
@@ -1113,7 +1208,7 @@ void R_DrawTiltedSplat_8(void)
|
||||
double izstep, uzstep, vzstep;
|
||||
double endz, endu, endv;
|
||||
UINT32 stepu, stepv;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
|
||||
|
||||
@@ -1257,13 +1352,13 @@ void R_DrawSplat_8 (void)
|
||||
UINT32 xposition;
|
||||
UINT32 yposition;
|
||||
UINT32 xstep, ystep;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
size_t count;
|
||||
register size_t count;
|
||||
size_t i;
|
||||
UINT32 val;
|
||||
|
||||
@@ -1327,13 +1422,13 @@ void R_DrawTranslucentSplat_8 (void)
|
||||
UINT32 xposition;
|
||||
UINT32 yposition;
|
||||
UINT32 xstep, ystep;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
size_t count;
|
||||
register size_t count;
|
||||
size_t i;
|
||||
UINT8 val;
|
||||
|
||||
@@ -1392,14 +1487,14 @@ void R_DrawTranslucentSpan_8 (void)
|
||||
fixed_t xposition;
|
||||
fixed_t yposition;
|
||||
fixed_t xstep, ystep;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
|
||||
|
||||
size_t count = (ds_x2 - ds_x1 + 1);
|
||||
register size_t count = (ds_x2 - ds_x1 + 1);
|
||||
size_t i;
|
||||
|
||||
xposition = ds_xfrac; yposition = ds_yfrac;
|
||||
@@ -1451,14 +1546,14 @@ void R_DrawTranslucentWaterSpan_8(void)
|
||||
UINT32 xposition;
|
||||
UINT32 yposition;
|
||||
UINT32 xstep, ystep;
|
||||
UINT32 bit;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
UINT8 *dsrc;
|
||||
|
||||
size_t count;
|
||||
register size_t count;
|
||||
size_t i;
|
||||
|
||||
// SoM: we only need 6 bits for the integer part (0 thru 63) so the rest
|
||||
@@ -1510,9 +1605,9 @@ void R_DrawTranslucentWaterSpan_8(void)
|
||||
void R_DrawFogSpan_8(void)
|
||||
{
|
||||
UINT8 *colormap;
|
||||
UINT8 *dest;
|
||||
register UINT8 *dest;
|
||||
|
||||
size_t count;
|
||||
register size_t count;
|
||||
|
||||
colormap = ds_colormap;
|
||||
//dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
@@ -1543,8 +1638,8 @@ void R_DrawFogSpan_8(void)
|
||||
*/
|
||||
void R_DrawFogColumn_8(void)
|
||||
{
|
||||
INT32 count;
|
||||
UINT8 *dest;
|
||||
register INT32 count;
|
||||
register UINT8 *dest;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
|
||||
@@ -1579,7 +1674,8 @@ void R_DrawFogColumn_8(void)
|
||||
*/
|
||||
void R_DrawColumnShadowed_8(void)
|
||||
{
|
||||
INT32 count, realyh, i, height, bheight = 0, solid = 0;
|
||||
register INT32 count;
|
||||
INT32 realyh, i, height, bheight = 0, solid = 0;
|
||||
|
||||
realyh = dc_yh;
|
||||
|
||||
|
||||
+67
-82
@@ -325,29 +325,6 @@ PUREFUNC INT32 R_PointOnSide(fixed_t x, fixed_t y, const node_t *restrict node)
|
||||
(~mask & (FixedMul(y, node->dx>>FRACBITS) >= FixedMul(node->dy>>FRACBITS, x)));
|
||||
}
|
||||
|
||||
// killough 5/2/98: reformatted
|
||||
PUREFUNC INT32 R_PointOnSegSide(fixed_t x, fixed_t y, const seg_t *line)
|
||||
{
|
||||
fixed_t lx = line->v1->x;
|
||||
fixed_t ly = line->v1->y;
|
||||
fixed_t ldx = line->v2->x - lx;
|
||||
fixed_t ldy = line->v2->y - ly;
|
||||
|
||||
if (!ldx)
|
||||
return x <= lx ? ldy > 0 : ldy < 0;
|
||||
|
||||
if (!ldy)
|
||||
return y <= ly ? ldx < 0 : ldx > 0;
|
||||
|
||||
x -= lx;
|
||||
y -= ly;
|
||||
|
||||
// Try to quickly decide by looking at sign bits.
|
||||
if ((ldy ^ ldx ^ x ^ y) < 0)
|
||||
return (ldy ^ x) < 0; // (left is negative)
|
||||
return FixedMul(y, ldx>>FRACBITS) >= FixedMul(ldy>>FRACBITS, x);
|
||||
}
|
||||
|
||||
//
|
||||
// R_PointToAngle
|
||||
// To get a global angle from cartesian coordinates,
|
||||
@@ -1356,31 +1333,7 @@ void R_SkyboxFrame(player_t *player)
|
||||
else
|
||||
newview->sector = R_PointInSubsector(newview->x, newview->y)->sector;
|
||||
|
||||
// newview->sin = FINESINE(viewangle>>ANGLETOFINESHIFT);
|
||||
// newview->cos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
|
||||
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? demo.playback ? rendertimefrac_unpaused : rendertimefrac : FRACUNIT, false);
|
||||
}
|
||||
|
||||
static void
|
||||
R_SetupCommonFrame
|
||||
( player_t * player,
|
||||
subsector_t * subsector)
|
||||
{
|
||||
newview->player = player;
|
||||
|
||||
newview->x += quake.x;
|
||||
newview->y += quake.y;
|
||||
newview->z += quake.z;
|
||||
|
||||
newview->roll = R_ViewRollAngle(player);
|
||||
|
||||
if (subsector)
|
||||
newview->sector = subsector->sector;
|
||||
else
|
||||
newview->sector = R_PointInSubsector(newview->x, newview->y)->sector;
|
||||
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? demo.playback ? rendertimefrac_unpaused : rendertimefrac : FRACUNIT, false);
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? (demo.playback && demo.freecam) ? rendertimefrac_unpaused : rendertimefrac : FRACUNIT, false);
|
||||
}
|
||||
|
||||
void R_SetupFrame(player_t *player, boolean skybox)
|
||||
@@ -1388,33 +1341,50 @@ void R_SetupFrame(player_t *player, boolean skybox)
|
||||
camera_t *thiscam;
|
||||
boolean chasecam = false;
|
||||
|
||||
#define SETUPCAM(num, var, context)\
|
||||
thiscam = &camera[num];\
|
||||
chasecam = (var.value != 0);\
|
||||
R_SetViewContext(context);\
|
||||
if (thiscam->reset)\
|
||||
{\
|
||||
R_ResetViewInterpolation(num+1);\
|
||||
thiscam->reset = false;\
|
||||
}
|
||||
|
||||
if (splitscreen > 2 && player == &players[displayplayers[3]])
|
||||
{
|
||||
SETUPCAM(3, cv_chasecam4, VIEWCONTEXT_PLAYER4)
|
||||
thiscam = &camera[3];
|
||||
chasecam = (cv_chasecam4.value != 0);
|
||||
R_SetViewContext(VIEWCONTEXT_PLAYER4);
|
||||
if (thiscam->reset)
|
||||
{
|
||||
R_ResetViewInterpolation(4);
|
||||
thiscam->reset = false;
|
||||
}
|
||||
}
|
||||
else if (splitscreen > 1 && player == &players[displayplayers[2]])
|
||||
{
|
||||
SETUPCAM(2, cv_chasecam3, VIEWCONTEXT_PLAYER3)
|
||||
thiscam = &camera[2];
|
||||
chasecam = (cv_chasecam3.value != 0);
|
||||
R_SetViewContext(VIEWCONTEXT_PLAYER3);
|
||||
if (thiscam->reset)
|
||||
{
|
||||
R_ResetViewInterpolation(3);
|
||||
thiscam->reset = false;
|
||||
}
|
||||
}
|
||||
else if (splitscreen && player == &players[displayplayers[1]])
|
||||
{
|
||||
SETUPCAM(1, cv_chasecam2, VIEWCONTEXT_PLAYER2)
|
||||
thiscam = &camera[1];
|
||||
chasecam = (cv_chasecam2.value != 0);
|
||||
R_SetViewContext(VIEWCONTEXT_PLAYER2);
|
||||
if (thiscam->reset)
|
||||
{
|
||||
R_ResetViewInterpolation(2);
|
||||
thiscam->reset = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
SETUPCAM(0, cv_chasecam, VIEWCONTEXT_PLAYER1)
|
||||
thiscam = &camera[0];
|
||||
chasecam = (cv_chasecam.value != 0);
|
||||
R_SetViewContext(VIEWCONTEXT_PLAYER1);
|
||||
if (thiscam->reset)
|
||||
{
|
||||
R_ResetViewInterpolation(1);
|
||||
thiscam->reset = false;
|
||||
}
|
||||
}
|
||||
#undef SETUPCAM
|
||||
|
||||
if (player->spectator) // no spectator chasecam
|
||||
chasecam = false; // force chasecam off
|
||||
@@ -1435,38 +1405,24 @@ void R_SetupFrame(player_t *player, boolean skybox)
|
||||
{
|
||||
viewmobj = player->awayviewmobj; // should be a MT_ALTVIEWMAN
|
||||
I_Assert(viewmobj != NULL);
|
||||
|
||||
newview->x = viewmobj->x;
|
||||
newview->y = viewmobj->y;
|
||||
newview->z = viewmobj->z + 20*FRACUNIT;
|
||||
|
||||
newview->aim = player->awayviewaiming;
|
||||
newview->angle = viewmobj->angle;
|
||||
|
||||
R_SetupCommonFrame(player, viewmobj->subsector);
|
||||
}
|
||||
else if (!player->spectator && (thiscam && chasecam)) // use outside cam view
|
||||
{
|
||||
viewmobj = NULL;
|
||||
|
||||
newview->x = thiscam->x;
|
||||
newview->y = thiscam->y;
|
||||
newview->z = thiscam->z + (thiscam->height>>1);
|
||||
|
||||
newview->aim = thiscam->aiming;
|
||||
newview->angle = thiscam->angle;
|
||||
|
||||
R_SetupCommonFrame(player, thiscam->subsector);
|
||||
}
|
||||
else // use the player's eyes view
|
||||
{
|
||||
newview->z = player->viewz;
|
||||
|
||||
viewmobj = player->mo;
|
||||
I_Assert(viewmobj != NULL);
|
||||
|
||||
newview->x = viewmobj->x;
|
||||
newview->y = viewmobj->y;
|
||||
newview->z = player->viewz;
|
||||
|
||||
newview->aim = player->aiming;
|
||||
newview->angle = viewmobj->angle;
|
||||
|
||||
@@ -1491,9 +1447,38 @@ void R_SetupFrame(player_t *player, boolean skybox)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
R_SetupCommonFrame(player, viewmobj->subsector);
|
||||
}
|
||||
newview->roll = R_ViewRollAngle(player);
|
||||
newview->z += quake.z;
|
||||
|
||||
newview->player = player;
|
||||
|
||||
if ((thiscam && chasecam) && !player->awayviewtics && !player->spectator)
|
||||
{
|
||||
newview->x = thiscam->x;
|
||||
newview->y = thiscam->y;
|
||||
newview->x += quake.x;
|
||||
newview->y += quake.y;
|
||||
|
||||
if (thiscam->subsector && thiscam->subsector->sector)
|
||||
newview->sector = thiscam->subsector->sector;
|
||||
else
|
||||
newview->sector = R_PointInSubsector(newview->x, newview->y)->sector;
|
||||
}
|
||||
else
|
||||
{
|
||||
newview->x = viewmobj->x;
|
||||
newview->y = viewmobj->y;
|
||||
newview->x += quake.x;
|
||||
newview->y += quake.y;
|
||||
|
||||
if (!P_MobjWasRemoved(viewmobj) && viewmobj->subsector && thiscam && thiscam->subsector->sector)
|
||||
newview->sector = viewmobj->subsector->sector;
|
||||
else
|
||||
newview->sector = R_PointInSubsector(newview->x, newview->y)->sector;
|
||||
}
|
||||
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? (demo.playback && demo.freecam) ? rendertimefrac_unpaused : rendertimefrac : FRACUNIT, false);
|
||||
}
|
||||
|
||||
#define ANGLED_PORTALS
|
||||
@@ -1698,7 +1683,7 @@ void R_RenderPlayerView(player_t *player)
|
||||
else
|
||||
{
|
||||
portalclipstart = 0;
|
||||
portalclipend = viewwidth-1;
|
||||
portalclipend = viewwidth;
|
||||
R_ClearClipSegs();
|
||||
}
|
||||
R_ClearDrawSegs();
|
||||
|
||||
+12
-1
@@ -73,7 +73,18 @@ extern lighttable_t *zlight[LIGHTLEVELS][MAXLIGHTZ];
|
||||
|
||||
// Utility functions.
|
||||
INT32 R_PointOnSide(fixed_t x, fixed_t y, const node_t *node);
|
||||
INT32 R_PointOnSegSide(fixed_t x, fixed_t y, const seg_t *line);
|
||||
|
||||
FUNCINLINE static ATTRINLINE PUREFUNC INT32 R_PointOnSegSide(fixed_t x, fixed_t y, const seg_t *line)
|
||||
{
|
||||
fixed_t lx = line->v1->x;
|
||||
fixed_t ly = line->v1->y;
|
||||
fixed_t ldx = line->v2->x - lx;
|
||||
fixed_t ldy = line->v2->y - ly;
|
||||
|
||||
// heavily optimized version of R_PointOnSide, stolen from GZDoom.
|
||||
return (INT64)(y - ly) * ldx + (INT64)(lx - x) * ldy > 0;
|
||||
}
|
||||
|
||||
angle_t R_PointToAngle(fixed_t x, fixed_t y);
|
||||
angle_t R_PointToAngle64(INT64 x, INT64 y);
|
||||
angle_t R_PointToAngle2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1);
|
||||
|
||||
+15
-5
@@ -275,6 +275,7 @@ static void R_Render2sidedMultiPatchColumn(column_t *column)
|
||||
if (dc_yl <= dc_yh && dc_yh < vid.height && dc_yh > 0)
|
||||
{
|
||||
dc_source = (UINT8 *)column + 3;
|
||||
dc_sourcelength = 0;
|
||||
|
||||
if (colfunc == wallcolfunc)
|
||||
twosmultipatchfunc();
|
||||
@@ -1446,6 +1447,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_texturemid = rw_midtexturemid;
|
||||
dc_source = R_GetColumn(midtexture,texturecolumn);
|
||||
dc_texheight = textureheight[midtexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
colfunc();
|
||||
|
||||
// dont draw anything more for this column, since
|
||||
@@ -1493,6 +1495,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_texturemid = rw_toptexturemid;
|
||||
dc_source = R_GetColumn(toptexture,texturecolumn);
|
||||
dc_texheight = textureheight[toptexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
colfunc();
|
||||
ceilingclip[rw_x] = (INT16)mid;
|
||||
}
|
||||
@@ -1530,6 +1533,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_source = R_GetColumn(bottomtexture,
|
||||
texturecolumn);
|
||||
dc_texheight = textureheight[bottomtexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
colfunc();
|
||||
floorclip[rw_x] = (INT16)mid;
|
||||
}
|
||||
@@ -1605,6 +1609,12 @@ static INT64 R_CalcSegDist(seg_t* seg, INT64 x2, INT64 y2)
|
||||
}
|
||||
}
|
||||
|
||||
static inline INT32 get_flat_tex (INT32 texnum)
|
||||
{
|
||||
texnum = R_GetTextureNum(texnum);
|
||||
return textures[texnum]->holes ? 0 : texnum; // R_DrawWallColumn cannot render holey textures
|
||||
}
|
||||
|
||||
//
|
||||
// R_StoreWallRange
|
||||
// A wall segment will be drawn
|
||||
@@ -1862,7 +1872,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
{
|
||||
fixed_t texheight;
|
||||
// single sided line
|
||||
midtexture = R_GetTextureNum(sidedef->midtexture);
|
||||
midtexture = get_flat_tex(sidedef->midtexture);
|
||||
texheight = textureheight[midtexture];
|
||||
// a single sided line is terminal, so it must mark ends
|
||||
markfloor = markceiling = true;
|
||||
@@ -2045,15 +2055,15 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
{
|
||||
// Special case... use offsets from 2nd side but only if it has a texture.
|
||||
side_t *def = &sides[linedef->sidenum[1]];
|
||||
toptexture = R_GetTextureNum(def->toptexture);
|
||||
toptexture = get_flat_tex(def->toptexture);
|
||||
|
||||
if (!toptexture) //Second side has no texture, use the first side's instead.
|
||||
toptexture = R_GetTextureNum(sidedef->toptexture);
|
||||
toptexture = get_flat_tex(sidedef->toptexture);
|
||||
texheight = textureheight[toptexture];
|
||||
}
|
||||
else
|
||||
{
|
||||
toptexture = R_GetTextureNum(sidedef->toptexture);
|
||||
toptexture = get_flat_tex(sidedef->toptexture);
|
||||
texheight = textureheight[toptexture];
|
||||
}
|
||||
if (!(linedef->flags & ML_EFFECT1)) { // Ignore slopes for lower/upper textures unless flag is checked
|
||||
@@ -2078,7 +2088,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
if (worldlow > worldbottom || worldlowslope > worldbottomslope) // Only if VISIBLE!!!
|
||||
{
|
||||
// bottom texture
|
||||
bottomtexture = R_GetTextureNum(sidedef->bottomtexture);
|
||||
bottomtexture = get_flat_tex(sidedef->bottomtexture);
|
||||
|
||||
if (!(linedef->flags & ML_EFFECT1)) { // Ignore slopes for lower/upper textures unless flag is checked
|
||||
if (linedef->flags & ML_DONTPEGBOTTOM)
|
||||
|
||||
+35
-43
@@ -43,7 +43,7 @@ CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2];
|
||||
|
||||
static void R_InitSkins(void);
|
||||
|
||||
#define MINZ (FRACUNIT*4)
|
||||
#define MINZ (FRACUNIT*16)
|
||||
#define BASEYCENTER (BASEVIDHEIGHT/2)
|
||||
|
||||
typedef struct
|
||||
@@ -583,6 +583,9 @@ void R_DrawMaskedColumn(column_t *column)
|
||||
|
||||
basetexturemid = dc_texturemid;
|
||||
|
||||
if (!column || column == 0)
|
||||
return;
|
||||
|
||||
for (; column->topdelta != 0xff ;)
|
||||
{
|
||||
// calculate unclipped screen coordinates
|
||||
@@ -609,6 +612,7 @@ void R_DrawMaskedColumn(column_t *column)
|
||||
dc_yh = mfloorclip[dc_x]-1;
|
||||
if (dc_yl <= mceilingclip[dc_x])
|
||||
dc_yl = mceilingclip[dc_x]+1;
|
||||
|
||||
if (dc_yl < 0)
|
||||
dc_yl = 0;
|
||||
if (dc_yh >= vid.height)
|
||||
@@ -617,6 +621,7 @@ void R_DrawMaskedColumn(column_t *column)
|
||||
if (dc_yl <= dc_yh && dc_yh > 0 && column->length != 0)
|
||||
{
|
||||
dc_source = (UINT8 *)column + 3;
|
||||
dc_sourcelength = column->length;
|
||||
dc_texturemid = basetexturemid - (topdelta<<FRACBITS);
|
||||
|
||||
// Drawn by R_DrawColumn.
|
||||
@@ -625,6 +630,10 @@ void R_DrawMaskedColumn(column_t *column)
|
||||
// quick fix... something more proper should be done!!!
|
||||
if (ylookup[dc_yl])
|
||||
colfunc();
|
||||
#ifdef PARANOIA
|
||||
else
|
||||
I_Error("R_DrawMaskedColumn: Invalid ylookup for dc_yl %d", dc->yl);
|
||||
#endif
|
||||
}
|
||||
column = (column_t *)((UINT8 *)column + column->length + 4);
|
||||
}
|
||||
@@ -677,6 +686,7 @@ static void R_DrawFlippedMaskedColumn(column_t *column)
|
||||
if (dc_yl <= dc_yh && dc_yh > 0 && column->length != 0)
|
||||
{
|
||||
dc_source = ZZ_Alloc(column->length);
|
||||
dc_sourcelength = column->length;
|
||||
for (s = (UINT8 *)column+2+column->length, d = dc_source; d < dc_source+column->length; --s)
|
||||
*d++ = *s;
|
||||
dc_texturemid = basetexturemid - (topdelta<<FRACBITS);
|
||||
@@ -794,7 +804,7 @@ static void R_DrawVisSprite(vissprite_t *vis)
|
||||
dc_colormap += COLORMAP_REMAPOFFSET;
|
||||
|
||||
dc_texturemid = vis->texturemid;
|
||||
dc_texheight = 0;
|
||||
dc_texheight = SHORT(patch->height);
|
||||
|
||||
frac = vis->startfrac;
|
||||
windowtop = windowbottom = sprbotscreen = INT32_MAX;
|
||||
@@ -803,8 +813,10 @@ static void R_DrawVisSprite(vissprite_t *vis)
|
||||
this_scale = FixedMul(this_scale, ((skin_t *)vis->mobj->localskin)->highresscale);
|
||||
else if (vis->mobj->skin && ((skin_t *)vis->mobj->skin)->flags & SF_HIRES)
|
||||
this_scale = FixedMul(this_scale, ((skin_t *)vis->mobj->skin)->highresscale);
|
||||
|
||||
if (this_scale <= 0)
|
||||
this_scale = 1;
|
||||
|
||||
if (this_scale != FRACUNIT)
|
||||
{
|
||||
if (!vis->isScaled)
|
||||
@@ -837,22 +849,15 @@ static void R_DrawVisSprite(vissprite_t *vis)
|
||||
if (vis->x2 >= vid.width)
|
||||
vis->x2 = vid.width-1;
|
||||
|
||||
// Something is occasionally setting 1px-wide sprites whose frac is exactly the width of the sprite, causing crashes due to
|
||||
// accessing invalid column info. Until the cause is found, let's try to correct those manually...
|
||||
{
|
||||
fixed_t temp = ((frac + vis->xiscale*(vis->x2-vis->x1))>>FRACBITS) - SHORT(patch->width);
|
||||
if (temp > 0)
|
||||
vis->x2 -= temp;
|
||||
}
|
||||
|
||||
localcolfunc = (vis->vflip) ? R_DrawFlippedMaskedColumn : R_DrawMaskedColumn;
|
||||
lengthcol = patch->height;
|
||||
lengthcol = SHORT(patch->height);
|
||||
|
||||
// Split drawing loops for paper and non-paper to reduce conditional checks per sprite
|
||||
if (vis->scalestep)
|
||||
{
|
||||
fixed_t horzscale = FixedMul(vis->spritexscale, this_scale);
|
||||
fixed_t scalestep = FixedMul(vis->scalestep, vis->spriteyscale);
|
||||
|
||||
pwidth = SHORT(patch->width);
|
||||
|
||||
// Papersprite drawing loop
|
||||
@@ -877,12 +882,10 @@ static void R_DrawVisSprite(vissprite_t *vis)
|
||||
}
|
||||
else
|
||||
{
|
||||
pwidth = SHORT(patch->width);
|
||||
|
||||
// Non-paper drawing loop
|
||||
for (dc_x = vis->x1; dc_x <= vis->x2; dc_x++, frac += vis->xiscale)
|
||||
{
|
||||
texturecolumn = CLAMP(frac >> FRACBITS, 0, pwidth - 1);
|
||||
{
|
||||
texturecolumn = CLAMP(frac >> FRACBITS, 0, SHORT(patch->width) - 1);
|
||||
column = (column_t *)((UINT8 *)patch + LONG(patch->columnofs[texturecolumn]));
|
||||
|
||||
localcolfunc (column);
|
||||
@@ -928,7 +931,7 @@ static void R_DrawPrecipitationVisSprite(vissprite_t *vis)
|
||||
|
||||
dc_iscale = FixedDiv(FRACUNIT, vis->scale);
|
||||
dc_texturemid = FixedDiv(vis->texturemid, this_scale);
|
||||
dc_texheight = 0;
|
||||
dc_texheight = SHORT(patch->height);
|
||||
|
||||
frac = vis->startfrac;
|
||||
spryscale = vis->scale;
|
||||
@@ -943,7 +946,14 @@ static void R_DrawPrecipitationVisSprite(vissprite_t *vis)
|
||||
|
||||
for (dc_x = vis->x1; dc_x <= vis->x2; dc_x++, frac += vis->xiscale)
|
||||
{
|
||||
texturecolumn = CLAMP(frac >> FRACBITS, 0, SHORT(patch->width) - 1);
|
||||
texturecolumn = frac>>FRACBITS;
|
||||
|
||||
if (texturecolumn < 0 || texturecolumn >= patch->width)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "R_DrawPrecipitationSpriteRange: bad texturecolumn\n");
|
||||
break;
|
||||
}
|
||||
|
||||
column = (column_t *)((UINT8 *)patch + LONG(patch->columnofs[texturecolumn]));
|
||||
|
||||
R_DrawMaskedColumn(column);
|
||||
@@ -1530,7 +1540,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
// PORTAL SPRITE CLIPPING
|
||||
if (portalrender && portalclipline)
|
||||
{
|
||||
if (x2 < portalclipstart || x1 > portalclipend)
|
||||
if (x2 < portalclipstart || x1 >= portalclipend)
|
||||
return;
|
||||
|
||||
if (P_PointOnLineSide(interp.x, interp.y, portalclipline) != 0)
|
||||
@@ -1623,17 +1633,8 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
|
||||
vis->mobj = thing; // Easy access! Tails 06-07-2002
|
||||
|
||||
vis->x1 = x1 < 0 ? 0 : x1;
|
||||
vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;
|
||||
|
||||
// PORTAL SEMI-CLIPPING
|
||||
if (portalrender && portalclipline)
|
||||
{
|
||||
if (vis->x1 < portalclipstart)
|
||||
vis->x1 = portalclipstart;
|
||||
if (vis->x2 > portalclipend)
|
||||
vis->x2 = portalclipend;
|
||||
}
|
||||
vis->x1 = x1 < portalclipstart ? portalclipstart : x1;
|
||||
vis->x2 = x2 >= portalclipend ? portalclipend-1 : x2;
|
||||
|
||||
vis->sector = thing->subsector->sector;
|
||||
vis->szt = (INT16)((centeryfrac - FixedMul(vis->gzt - viewz, sortscale))>>FRACBITS);
|
||||
@@ -1843,7 +1844,7 @@ static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
|
||||
// PORTAL SPRITE CLIPPING
|
||||
if (portalrender && portalclipline)
|
||||
{
|
||||
if (x2 < portalclipstart || x1 > portalclipend)
|
||||
if (x2 < portalclipstart || x1 >= portalclipend)
|
||||
return;
|
||||
|
||||
if (P_PointOnLineSide(interp.x, interp.y, portalclipline) != 0)
|
||||
@@ -1877,17 +1878,8 @@ static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
|
||||
vis->scalestep = 0;
|
||||
vis->paperdistance = 0;
|
||||
|
||||
vis->x1 = x1 < 0 ? 0 : x1;
|
||||
vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;
|
||||
|
||||
// PORTAL SEMI-CLIPPING
|
||||
if (portalrender && portalclipline)
|
||||
{
|
||||
if (vis->x1 < portalclipstart)
|
||||
vis->x1 = portalclipstart;
|
||||
if (vis->x2 > portalclipend)
|
||||
vis->x2 = portalclipend;
|
||||
}
|
||||
vis->x1 = x1 < portalclipstart ? portalclipstart : x1;
|
||||
vis->x2 = x2 >= portalclipend ? portalclipend-1 : x2;
|
||||
|
||||
vis->xscale = xscale; //SoM: 4/17/2000
|
||||
vis->sector = thing->subsector->sector;
|
||||
@@ -2450,8 +2442,8 @@ static boolean R_CheckSpriteVisible(vissprite_t *spr, INT32 x1, INT32 x2)
|
||||
INT16 sz = spr->sz;
|
||||
INT16 szt = spr->szt;
|
||||
|
||||
fixed_t texturemid, yscale, scalestep = spr->scalestep;
|
||||
INT32 height;
|
||||
fixed_t texturemid = 0, yscale = 0, scalestep = spr->scalestep; // "= 0" pleases the compiler
|
||||
INT32 height = 0;
|
||||
|
||||
if (scalestep)
|
||||
{
|
||||
|
||||
@@ -55,6 +55,7 @@ extern fixed_t sprtopscreen;
|
||||
extern fixed_t sprbotscreen;
|
||||
extern fixed_t windowtop;
|
||||
extern fixed_t windowbottom;
|
||||
extern INT32 lengthcol;
|
||||
|
||||
fixed_t R_GetShadowZ(mobj_t *thing, pslope_t **shadowslope);
|
||||
|
||||
|
||||
+135
-6
@@ -11,6 +11,7 @@
|
||||
/// \file s_sound.c
|
||||
/// \brief System-independent sound and music routines
|
||||
|
||||
#include "d_netcmd.h"
|
||||
#include "doomdef.h"
|
||||
#include "doomstat.h"
|
||||
#include "command.h"
|
||||
@@ -118,6 +119,14 @@ consvar_t cv_resume = {"resume", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0
|
||||
consvar_t cv_fading = {"fading", "Off", CV_SAVE|CV_CALL, CV_OnOff, Bird_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_birdmusic = {"birdmusicstuff", "No", CV_SAVE|CV_CALL, CV_YesNo, Bird_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
|
||||
consvar_t cv_keepmusic = {"keepmusic", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_skipintromusic = {"skipintromusic", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
//consvar_t cv_ignoremusicchanges = {"ignoremusicchanges", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
boolean keepmusic = false;
|
||||
static void S_CheckEventMus(const char *newmus);
|
||||
|
||||
#ifdef HAVE_OPENMPT
|
||||
openmpt_module *openmpt_mhandle = NULL;
|
||||
|
||||
@@ -297,6 +306,10 @@ void S_RegisterSoundStuff(void)
|
||||
CV_RegisterVar(&cv_birdmusic);
|
||||
// bird music stuff end
|
||||
|
||||
CV_RegisterVar(&cv_keepmusic);
|
||||
CV_RegisterVar(&cv_skipintromusic);
|
||||
//CV_RegisterVar(&cv_ignoremusicchanges);
|
||||
|
||||
COM_AddCommand("tunes", Command_Tunes_f);
|
||||
COM_AddCommand("restartaudio", Command_RestartAudio_f);
|
||||
COM_AddCommand("restartmusic", Command_RestartMusic_f);
|
||||
@@ -1960,6 +1973,8 @@ void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32
|
||||
|
||||
strncpy(newmusic, mmusic, 6);
|
||||
|
||||
S_CheckEventMus(newmusic);
|
||||
|
||||
if (LUAh_MusicChange(music_name, newmusic, &mflags, &looping, &position, &prefadems, &fadeinms))
|
||||
return;
|
||||
|
||||
@@ -2151,13 +2166,92 @@ boolean S_FadeOutStopMusic(UINT32 ms)
|
||||
/// Init & Others
|
||||
/// ------------------------
|
||||
|
||||
/*static boolean S_KeepMusic(void)
|
||||
{
|
||||
//if (!cv_keepmusic.value)
|
||||
//return false;
|
||||
|
||||
// should i compare songs or maps?
|
||||
static char oldmusname[7] = "";
|
||||
|
||||
if (strcmp(music_name, mapmusname) != 0)
|
||||
return false;
|
||||
|
||||
if (strcmp(oldmusname, mapmusname) == 0)
|
||||
return true;
|
||||
|
||||
strncpy(oldmusname, mapmusname, 7);
|
||||
oldmusname[6] = '\0';
|
||||
|
||||
return false;
|
||||
}*/
|
||||
|
||||
static INT16 oldmap = 0;
|
||||
static boolean oldencore = false;
|
||||
static boolean skipmusic = false;
|
||||
boolean skipintromus = false;
|
||||
|
||||
static const char *musicexception_list[16] = {
|
||||
"vote", "voteea", "voteeb", "racent", "krwin",
|
||||
"krok", "krlose", "krfail", "kbwin", "kbok",
|
||||
"kblose", "kstart", "estart", "wait2j", "CHRSHP",
|
||||
"CHRSHF"
|
||||
};
|
||||
|
||||
//checks for any kind of event music like intermission, vote etc.
|
||||
//always runs when musicchange gets invoked
|
||||
static void S_CheckEventMus(const char *newmus)
|
||||
{
|
||||
skipmusic = false;
|
||||
|
||||
if (!cv_keepmusic.value)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < 16; i++)
|
||||
if (stricmp(music_name, musicexception_list[i]) == 0 || stricmp(newmus, musicexception_list[i]) == 0) // weird? sure! but were lucky enough newmus reflects whats being replaced
|
||||
{
|
||||
skipmusic = true;
|
||||
break;
|
||||
}
|
||||
|
||||
//CONS_Printf("musname = %s\n", music_name);
|
||||
//CONS_Printf("newmus = %s\n", newmus);
|
||||
//CONS_Printf("newmus = %d\n", skipmusic);
|
||||
}
|
||||
|
||||
//this one compares map and encoremode instead of the music itself
|
||||
//makes tunes work and stuff
|
||||
void S_CheckMap(void)
|
||||
{
|
||||
if (!cv_keepmusic.value)
|
||||
{
|
||||
keepmusic = false;
|
||||
return;
|
||||
}
|
||||
|
||||
keepmusic = (!skipmusic && gamestate == GS_LEVEL && oldmap == gamemap && oldencore == encoremode);
|
||||
|
||||
oldencore = encoremode;
|
||||
oldmap = gamemap;
|
||||
}
|
||||
|
||||
//
|
||||
// Per level startup code.
|
||||
// Kills playing sounds at start of level,
|
||||
// determines music if any, changes music.
|
||||
//
|
||||
void S_Start(void)
|
||||
void S_InitMapMusic(void)
|
||||
{
|
||||
if (!cv_skipintromusic.value)
|
||||
skipintromus = false;
|
||||
else
|
||||
{
|
||||
char *maptitle = G_BuildMapTitle(gamemap);
|
||||
skipintromus = cv_skipintromusic.value && stricmp(maptitle, "Wandering Falls") != 0; // thanks diggle!
|
||||
if (maptitle)
|
||||
Z_Free(maptitle);
|
||||
}
|
||||
|
||||
if (mapmusflags & MUSIC_RELOADRESET)
|
||||
{
|
||||
strncpy(mapmusname, mapheaderinfo[gamemap-1]->musname, 7);
|
||||
@@ -2167,13 +2261,48 @@ void S_Start(void)
|
||||
mapmusresume = 0;
|
||||
}
|
||||
|
||||
//if (cv_resetmusic.value) // Starting ambience should always be restarted
|
||||
S_StopMusic();
|
||||
if (keepmusic)
|
||||
return;
|
||||
|
||||
if (leveltime < (starttime + (TICRATE/2))) // SRB2Kart
|
||||
S_ChangeMusicEx((encoremode ? "estart" : "kstart"), 0, false, mapmusposition, 0, 0);
|
||||
else
|
||||
// Starting ambience should always be restarted
|
||||
// lug: but not when we keep the map music lol
|
||||
S_StopMusic();
|
||||
|
||||
if (skipintromus)
|
||||
return;
|
||||
|
||||
if (leveltime < MUSICSTARTTIME) // SRB2Kart
|
||||
S_ChangeMusicInternal((encoremode ? "estart" : "kstart"), false); //S_StopMusic();
|
||||
//S_ChangeMusicEx((encoremode ? "estart" : "kstart"), 0, false, mapmusposition, 0, 0);
|
||||
}
|
||||
|
||||
void S_StartMapMusic(boolean restore)
|
||||
{
|
||||
//no need to constantly run this after race has started
|
||||
if (leveltime > MUSICSTARTTIME)
|
||||
return;
|
||||
|
||||
if (keepmusic && !restore) // make sure this doesent kill the music when its called from P_RestoreMusic in some cases
|
||||
return;
|
||||
|
||||
if (skipintromus)
|
||||
{
|
||||
if (leveltime < starttime)
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, true, mapmusposition, 0, 0);
|
||||
if (leveltime == MUSICSTARTTIME)
|
||||
S_ShowMusicCredit();
|
||||
return;
|
||||
}
|
||||
|
||||
if (leveltime < starttime) // SRB2Kart
|
||||
S_ChangeMusicInternal((encoremode ? "estart" : "kstart"), false); // yes this will be spammed otherwise encore and some stuff WILL overwrite it
|
||||
else if (leveltime == starttime) // The GO! sound stops the level start ambience
|
||||
S_StopMusic();
|
||||
else if (leveltime == MUSICSTARTTIME) // Plays the music after the starting countdown.
|
||||
{
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, true, mapmusposition, 0, 0);
|
||||
S_ShowMusicCredit();
|
||||
}
|
||||
}
|
||||
|
||||
void S_RestartMusic(void)
|
||||
|
||||
+12
-1
@@ -68,6 +68,13 @@ extern consvar_t cv_resume;
|
||||
extern consvar_t cv_fading;
|
||||
extern consvar_t cv_birdmusic;
|
||||
|
||||
extern consvar_t cv_keepmusic;
|
||||
extern consvar_t cv_skipintromusic;
|
||||
//extern consvar_t cv_ignoremusicchanges;
|
||||
extern boolean keepmusic;
|
||||
extern boolean skipintromus;
|
||||
#define MUSICSTARTTIME (starttime + (TICRATE/2))
|
||||
|
||||
extern consvar_t precachesound;
|
||||
|
||||
typedef enum
|
||||
@@ -101,7 +108,11 @@ void S_InitSfxChannels(INT32 sfxVolume);
|
||||
//
|
||||
void S_StopSounds(void);
|
||||
void S_ClearSfx(void);
|
||||
void S_Start(void);
|
||||
|
||||
void S_InitMapMusic(void);
|
||||
void S_StartMapMusic(boolean restore);
|
||||
|
||||
void S_CheckMap(void);
|
||||
|
||||
// Stops music and restarts it from same position. Used for instant applying changes to amiga filters.
|
||||
void S_RestartMusic(void);
|
||||
|
||||
+89
-88
@@ -111,6 +111,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
|
||||
#endif
|
||||
|
||||
#if defined (__unix__) || (defined (UNIXCOMMON) && !defined (__APPLE__))
|
||||
#include <poll.h>
|
||||
#include <errno.h>
|
||||
#include <sys/wait.h>
|
||||
#define NEWSIGNALHANDLER
|
||||
@@ -544,10 +545,9 @@ typedef struct
|
||||
|
||||
feild_t tty_con;
|
||||
|
||||
// when printing general stuff to stdout stderr (Sys_Printf)
|
||||
// we need to disable the tty console stuff
|
||||
// this increments so we can recursively disable
|
||||
static INT32 ttycon_hide = 0;
|
||||
// lock to prevent clearing partial lines, since not everything
|
||||
// printed ends on a newline.
|
||||
static boolean ttycon_ateol = true;
|
||||
// some key codes that the terminal may be using
|
||||
// TTimo NOTE: I'm not sure how relevant this is
|
||||
static INT32 tty_erase;
|
||||
@@ -575,63 +575,31 @@ static inline void tty_FlushIn(void)
|
||||
// TTimo NOTE: it seems on some terminals just sending '\b' is not enough
|
||||
// so for now, in any case we send "\b \b" .. yeah well ..
|
||||
// (there may be a way to find out if '\b' alone would work though)
|
||||
// Hanicef NOTE: using \b this way is unreliable because of terminal state,
|
||||
// it's better to use \r to reset the cursor to the beginning of the
|
||||
// line and clear from there.
|
||||
static void tty_Back(void)
|
||||
{
|
||||
char key;
|
||||
ssize_t d;
|
||||
key = '\b';
|
||||
d = write(STDOUT_FILENO, &key, 1);
|
||||
key = ' ';
|
||||
d = write(STDOUT_FILENO, &key, 1);
|
||||
key = '\b';
|
||||
d = write(STDOUT_FILENO, &key, 1);
|
||||
(void)d;
|
||||
write(STDOUT_FILENO, "\r", 1);
|
||||
if (tty_con.cursor>0)
|
||||
{
|
||||
write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
|
||||
}
|
||||
write(STDOUT_FILENO, " \b", 2);
|
||||
}
|
||||
|
||||
static void tty_Clear(void)
|
||||
{
|
||||
size_t i;
|
||||
write(STDOUT_FILENO, "\r", 1);
|
||||
if (tty_con.cursor>0)
|
||||
{
|
||||
for (i=0; i<tty_con.cursor; i++)
|
||||
{
|
||||
tty_Back();
|
||||
write(STDOUT_FILENO, " ", 1);
|
||||
}
|
||||
write(STDOUT_FILENO, "\r", 1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// clear the display of the line currently edited
|
||||
// bring cursor back to beginning of line
|
||||
static inline void tty_Hide(void)
|
||||
{
|
||||
//I_Assert(consolevent);
|
||||
if (ttycon_hide)
|
||||
{
|
||||
ttycon_hide++;
|
||||
return;
|
||||
}
|
||||
tty_Clear();
|
||||
ttycon_hide++;
|
||||
}
|
||||
|
||||
// show the current line
|
||||
// FIXME TTimo need to position the cursor if needed??
|
||||
static inline void tty_Show(void)
|
||||
{
|
||||
size_t i;
|
||||
ssize_t d;
|
||||
//I_Assert(consolevent);
|
||||
I_Assert(ttycon_hide>0);
|
||||
ttycon_hide--;
|
||||
if (ttycon_hide == 0 && tty_con.cursor)
|
||||
{
|
||||
for (i=0; i<tty_con.cursor; i++)
|
||||
{
|
||||
d = write(STDOUT_FILENO, tty_con.buffer+i, 1);
|
||||
}
|
||||
}
|
||||
(void)d;
|
||||
}
|
||||
|
||||
// never exit without calling this, or your terminal will be left in a pretty bad state
|
||||
@@ -698,50 +666,65 @@ void I_GetConsoleEvents(void)
|
||||
// we use this when sending back commands
|
||||
event_t ev = {0,0,0,0};
|
||||
char key = 0;
|
||||
ssize_t d;
|
||||
struct pollfd pfd =
|
||||
{
|
||||
.fd = STDIN_FILENO,
|
||||
.events = POLLIN,
|
||||
.revents = 0,
|
||||
};
|
||||
|
||||
if (!consolevent)
|
||||
return;
|
||||
|
||||
ev.type = ev_console;
|
||||
ev.data1 = 0;
|
||||
if (read(STDIN_FILENO, &key, 1) == -1 || !key)
|
||||
return;
|
||||
for (;;)
|
||||
{
|
||||
if (poll(&pfd, 1, 0) < 1 || !(pfd.revents & POLLIN))
|
||||
return;
|
||||
|
||||
// we have something
|
||||
// backspace?
|
||||
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
|
||||
if ((key == tty_erase) || (key == 127) || (key == 8))
|
||||
{
|
||||
if (tty_con.cursor > 0)
|
||||
ev.type = ev_console;
|
||||
ev.data1 = 0;
|
||||
if (read(STDIN_FILENO, &key, 1) == -1 || !key)
|
||||
return;
|
||||
|
||||
// we have something
|
||||
// backspace?
|
||||
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
|
||||
if ((key == tty_erase) || (key == 127) || (key == 8))
|
||||
{
|
||||
tty_con.cursor--;
|
||||
tty_con.buffer[tty_con.cursor] = '\0';
|
||||
tty_Back();
|
||||
if (tty_con.cursor > 0)
|
||||
{
|
||||
tty_con.cursor--;
|
||||
tty_con.buffer[tty_con.cursor] = '\0';
|
||||
tty_Back();
|
||||
}
|
||||
ev.data1 = KEY_BACKSPACE;
|
||||
}
|
||||
ev.data1 = KEY_BACKSPACE;
|
||||
}
|
||||
else if (key < ' ') // check if this is a control char
|
||||
{
|
||||
if (key == '\n')
|
||||
else if (key < ' ') // check if this is a control char
|
||||
{
|
||||
tty_Clear();
|
||||
tty_con.cursor = 0;
|
||||
ev.data1 = KEY_ENTER;
|
||||
if (key == '\n')
|
||||
{
|
||||
tty_Clear();
|
||||
tty_con.cursor = 0;
|
||||
ev.data1 = KEY_ENTER;
|
||||
}
|
||||
else if (key == 0x4) // ^D, aka EOF
|
||||
{
|
||||
// shut down, most unix programs behave this way
|
||||
I_Quit();
|
||||
}
|
||||
else continue;
|
||||
}
|
||||
else return;
|
||||
else if (tty_con.cursor < sizeof(tty_con.buffer))
|
||||
{
|
||||
// push regular character
|
||||
ev.data1 = tty_con.buffer[tty_con.cursor] = key;
|
||||
tty_con.cursor++;
|
||||
// print the current line (this is differential)
|
||||
write(STDOUT_FILENO, &key, 1);
|
||||
}
|
||||
if (ev.data1) D_PostEvent(&ev);
|
||||
//tty_FlushIn();
|
||||
}
|
||||
else if (tty_con.cursor < sizeof (tty_con.buffer))
|
||||
{
|
||||
// push regular character
|
||||
ev.data1 = tty_con.buffer[tty_con.cursor] = key;
|
||||
tty_con.cursor++;
|
||||
// print the current line (this is differential)
|
||||
d = write(STDOUT_FILENO, &key, 1);
|
||||
}
|
||||
if (ev.data1) D_PostEvent(&ev);
|
||||
//tty_FlushIn();
|
||||
(void)d;
|
||||
}
|
||||
|
||||
#elif defined (_WIN32)
|
||||
@@ -937,9 +920,16 @@ static void I_RegisterChildSignals(void)
|
||||
void I_OutputMsg(const char *fmt, ...)
|
||||
{
|
||||
size_t len;
|
||||
char txt[8192];
|
||||
char *txt;
|
||||
va_list argptr;
|
||||
|
||||
va_start(argptr,fmt);
|
||||
len = vsnprintf(NULL, 0, fmt, argptr);
|
||||
va_end(argptr);
|
||||
if (len == 0)
|
||||
return;
|
||||
|
||||
txt = malloc(len+1);
|
||||
va_start(argptr,fmt);
|
||||
vsprintf(txt, fmt, argptr);
|
||||
va_end(argptr);
|
||||
@@ -973,7 +963,10 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
DWORD bytesWritten;
|
||||
|
||||
if (co == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
free(txt);
|
||||
return;
|
||||
}
|
||||
|
||||
if (GetFileType(co) == FILE_TYPE_CHAR && GetConsoleMode(co, &bytesWritten))
|
||||
{
|
||||
@@ -989,11 +982,16 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
if (oldLength > 0)
|
||||
{
|
||||
LPVOID blank = malloc(oldLength);
|
||||
if (!blank) return;
|
||||
if (!blank)
|
||||
{
|
||||
free(txt);
|
||||
return;
|
||||
}
|
||||
memset(blank, ' ', oldLength); // Blank out.
|
||||
oldLines = malloc(oldLength*sizeof(TCHAR));
|
||||
if (!oldLines)
|
||||
{
|
||||
free(txt);
|
||||
free(blank);
|
||||
return;
|
||||
}
|
||||
@@ -1028,18 +1026,20 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
}
|
||||
#else
|
||||
#ifdef HAVE_TERMIOS
|
||||
if (consolevent)
|
||||
if (consolevent && ttycon_ateol)
|
||||
{
|
||||
tty_Hide();
|
||||
tty_Clear();
|
||||
ttycon_ateol = false;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!framebuffer)
|
||||
fprintf(stderr, "%s", txt);
|
||||
#ifdef HAVE_TERMIOS
|
||||
if (consolevent)
|
||||
if (consolevent && txt[len-1] == '\n')
|
||||
{
|
||||
tty_Show();
|
||||
write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
|
||||
ttycon_ateol = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1048,6 +1048,7 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
fflush(stderr);
|
||||
|
||||
#endif
|
||||
free(txt);
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
+68
-11
@@ -664,7 +664,7 @@ static void ST_overlayDrawer(void)
|
||||
|
||||
if (!hu_showscores) // hide the following if TAB is held
|
||||
{
|
||||
if (cv_showdirectorhud.value && ((demo.playback && !demo.freecam && (!demo.title || !modeattacking)) || !P_IsLocalPlayer(stplyr)) && !splitscreen)
|
||||
if (cv_showdirectorhud.value && !splitscreen && ((demo.playback && !demo.freecam && (!demo.title || !modeattacking)) || !P_IsLocalPlayer(stplyr)) && !K_DirectorIsPlayerAlone())
|
||||
{
|
||||
char directortext[20] = {0};
|
||||
|
||||
@@ -808,25 +808,82 @@ static void ST_overlayDrawer(void)
|
||||
}
|
||||
}
|
||||
|
||||
void ST_DrawDemoTitleEntry(void)
|
||||
static void ST_DrawTextInput(INT32 x, INT32 y, textinput_t *input, INT32 flags)
|
||||
{
|
||||
static UINT8 skullAnimCounter = 0;
|
||||
char *nametodraw;
|
||||
static const INT32 MAXINPUTWIDTH = (MAXSTRINGLENGTH-1)*8;
|
||||
|
||||
skullAnimCounter++;
|
||||
if (renderisnewtic)
|
||||
skullAnimCounter++;
|
||||
skullAnimCounter %= 8;
|
||||
|
||||
nametodraw = demo.titlename;
|
||||
while (V_StringWidth(nametodraw, 0) > MAXSTRINGLENGTH*8 - 8)
|
||||
nametodraw++;
|
||||
char nametodraw[MAXSTRINGLENGTH*2+1] = {0};
|
||||
|
||||
size_t drawstart = 0;
|
||||
size_t drawend = 0; // Only used for selection
|
||||
|
||||
INT32 skullx = x;
|
||||
|
||||
while (V_SubStringWidth(input->buffer+drawstart, input->cursor-drawstart, V_ALLOWLOWERCASE) > MAXINPUTWIDTH)
|
||||
++drawstart;
|
||||
|
||||
size_t drawlength = V_SubStringLengthToFit(input->buffer+drawstart, MAXINPUTWIDTH+8, V_ALLOWLOWERCASE)+1;
|
||||
drawend = drawstart + drawlength;
|
||||
|
||||
memcpy(nametodraw, input->buffer+drawstart, drawlength);
|
||||
|
||||
if (input->length)
|
||||
skullx += V_SubStringWidth(nametodraw, input->cursor-drawstart, V_ALLOWLOWERCASE);
|
||||
|
||||
V_DrawString(x, y, V_ALLOWLOWERCASE|flags, nametodraw);
|
||||
|
||||
// draw text cursor for name
|
||||
if (skullAnimCounter < 4) // blink cursor
|
||||
V_DrawCharacter(skullx, y+3, '_'|flags, false);
|
||||
|
||||
// draw selection
|
||||
if (input->select != input->cursor)
|
||||
{
|
||||
size_t start = min(input->select, input->cursor);
|
||||
size_t end = max(input->select, input->cursor);
|
||||
|
||||
INT32 startx = 0;
|
||||
INT32 width = 0;
|
||||
|
||||
// I couldn't figure out one formula so here's bunch of separate cases
|
||||
if (start < drawstart && end > drawend) // Selection covers whole visible portion of demo name
|
||||
{
|
||||
startx = -2;
|
||||
width = V_StringWidth(nametodraw, V_ALLOWLOWERCASE)+4;
|
||||
}
|
||||
else if (start < drawstart) // Only left side of selection is off visible part
|
||||
{
|
||||
startx = -2;
|
||||
size_t len = (end - start) - (drawstart - start);
|
||||
width = V_SubStringWidth(nametodraw, len, V_ALLOWLOWERCASE)+2;
|
||||
}
|
||||
else if (end > drawend) // Only right side of selection is off visible part
|
||||
{
|
||||
startx = V_SubStringWidth(nametodraw, start-drawstart, V_ALLOWLOWERCASE);
|
||||
width = V_StringWidth(nametodraw+(start-drawstart), V_ALLOWLOWERCASE)+2;
|
||||
}
|
||||
else // All selection is on visible part
|
||||
{
|
||||
startx = V_SubStringWidth(nametodraw, start-drawstart, V_ALLOWLOWERCASE);
|
||||
width = V_SubStringWidth(nametodraw+(start-drawstart), end-start, V_ALLOWLOWERCASE);
|
||||
}
|
||||
|
||||
V_DrawFill(x+startx, y, width, 8, 103|V_TRANSLUCENT|flags);
|
||||
}
|
||||
}
|
||||
|
||||
void ST_DrawDemoTitleEntry(void)
|
||||
{
|
||||
#define x (BASEVIDWIDTH/2 - 139)
|
||||
#define y (BASEVIDHEIGHT/2)
|
||||
M_DrawTextBox(x, y + 4, MAXSTRINGLENGTH, 1);
|
||||
V_DrawString(x + 8, y + 12, V_ALLOWLOWERCASE, nametodraw);
|
||||
if (skullAnimCounter < 4)
|
||||
V_DrawCharacter(x + 8 + V_StringWidth(nametodraw, 0), y + 12,
|
||||
'_' | 0x80, false);
|
||||
|
||||
ST_DrawTextInput(x + 8, y + 12, &demo.titlenameinput, 0);
|
||||
|
||||
M_DrawTextBox(x + 30, y - 24, 26, 1);
|
||||
V_DrawString(x + 38, y - 16, V_ALLOWLOWERCASE, "Enter the name of the replay.");
|
||||
|
||||
+58
-10
@@ -2843,11 +2843,14 @@ INT32 V_LevelNameHeight(const char *string)
|
||||
//
|
||||
// Find string width from hu_font chars
|
||||
//
|
||||
INT32 V_StringWidth(const char *string, INT32 option)
|
||||
INT32 V_SubStringWidth(const char *string, INT32 length, INT32 option)
|
||||
{
|
||||
INT32 c, w = 0;
|
||||
INT32 spacewidth = 4, charwidth = 0;
|
||||
size_t i;
|
||||
ssize_t i;
|
||||
|
||||
if (length < 0)
|
||||
length = strlen(string);
|
||||
|
||||
switch (option & V_SPACINGMASK)
|
||||
{
|
||||
@@ -2863,7 +2866,7 @@ INT32 V_StringWidth(const char *string, INT32 option)
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < strlen(string); i++)
|
||||
for (i = 0; string[i] && i < length; i++)
|
||||
{
|
||||
c = string[i];
|
||||
if ((UINT8)c >= 0x80 && (UINT8)c <= 0x8F) //color parsing! -Inuyasha 2.16.09
|
||||
@@ -2882,11 +2885,14 @@ INT32 V_StringWidth(const char *string, INT32 option)
|
||||
//
|
||||
// Find string width from hu_font chars, 0.5x scale
|
||||
//
|
||||
INT32 V_SmallStringWidth(const char *string, INT32 option)
|
||||
INT32 V_SmallSubStringWidth(const char *string, INT32 length, INT32 option)
|
||||
{
|
||||
INT32 c, w = 0;
|
||||
INT32 spacewidth = 2, charwidth = 0;
|
||||
size_t i;
|
||||
ssize_t i;
|
||||
|
||||
if (length < 0)
|
||||
length = strlen(string);
|
||||
|
||||
switch (option & V_SPACINGMASK)
|
||||
{
|
||||
@@ -2902,7 +2908,7 @@ INT32 V_SmallStringWidth(const char *string, INT32 option)
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < strlen(string); i++)
|
||||
for (i = 0; string[i] && i < length; i++)
|
||||
{
|
||||
c = string[i];
|
||||
if ((UINT8)c >= 0x80 && (UINT8)c <= 0x8F) //color parsing! -Inuyasha 2.16.09
|
||||
@@ -2921,12 +2927,15 @@ INT32 V_SmallStringWidth(const char *string, INT32 option)
|
||||
//
|
||||
// Find string width from tny_font chars
|
||||
//
|
||||
INT32 V_ThinStringWidth(const char *string, INT32 option)
|
||||
INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 option)
|
||||
{
|
||||
INT32 c, w = 0;
|
||||
INT32 spacewidth = 2, charwidth = 0;
|
||||
boolean lowercase = (option & V_ALLOWLOWERCASE);
|
||||
size_t i;
|
||||
ssize_t i;
|
||||
|
||||
if (length < 0)
|
||||
length = strlen(string);
|
||||
|
||||
switch (option & V_SPACINGMASK)
|
||||
{
|
||||
@@ -2943,7 +2952,7 @@ INT32 V_ThinStringWidth(const char *string, INT32 option)
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < strlen(string); i++)
|
||||
for (i = 0; string[i] && i < length; i++)
|
||||
{
|
||||
c = string[i];
|
||||
if ((UINT8)c >= 0x80 && (UINT8)c <= 0x8F) //color parsing! -Inuyasha 2.16.09
|
||||
@@ -2961,7 +2970,7 @@ INT32 V_ThinStringWidth(const char *string, INT32 option)
|
||||
else
|
||||
{
|
||||
w += (charwidth ? charwidth
|
||||
: ((option & V_6WIDTHSPACE && i < strlen(string)-1) ? max(1, SHORT(tny_font[c]->width)-1) // Reuse this flag for the alternate bunched-up spacing
|
||||
: ((option & V_6WIDTHSPACE && i < length-1) ? max(1, SHORT(tny_font[c]->width)-1) // Reuse this flag for the alternate bunched-up spacing
|
||||
: SHORT(tny_font[c]->width)));
|
||||
}
|
||||
}
|
||||
@@ -2970,6 +2979,45 @@ INT32 V_ThinStringWidth(const char *string, INT32 option)
|
||||
return w;
|
||||
}
|
||||
|
||||
//
|
||||
// Find maximum length for substring taken from current string to fit into given width
|
||||
//
|
||||
INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option)
|
||||
{
|
||||
INT32 c, w = 0;
|
||||
INT32 spacewidth = 4, charwidth = 0;
|
||||
INT32 i;
|
||||
|
||||
switch (option & V_SPACINGMASK)
|
||||
{
|
||||
case V_MONOSPACE:
|
||||
spacewidth = 8;
|
||||
/* FALLTHRU */
|
||||
case V_OLDSPACING:
|
||||
charwidth = 8;
|
||||
break;
|
||||
case V_6WIDTHSPACE:
|
||||
spacewidth = 6;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; string[i] && w < width; i++)
|
||||
{
|
||||
c = string[i];
|
||||
if ((UINT8)c >= 0x80 && (UINT8)c <= 0x8F) //color parsing! -Inuyasha 2.16.09
|
||||
continue;
|
||||
|
||||
c = toupper(c) - HU_FONTSTART;
|
||||
if (c < 0 || c >= HU_FONTSIZE || !hu_font[c])
|
||||
w += spacewidth;
|
||||
else
|
||||
w += (charwidth ? charwidth : SHORT(hu_font[c]->width));
|
||||
}
|
||||
|
||||
return max(i-1, 0);
|
||||
}
|
||||
|
||||
char V_GetSkincolorChar(INT32 color)
|
||||
{
|
||||
char cstart = 0x80;
|
||||
|
||||
+9
-3
@@ -237,11 +237,17 @@ void V_DrawCreditString(fixed_t x, fixed_t y, INT32 option, const char *string);
|
||||
INT32 V_CreditStringWidth(const char *string);
|
||||
|
||||
// Find string width from hu_font chars
|
||||
INT32 V_StringWidth(const char *string, INT32 option);
|
||||
INT32 V_SubStringWidth(const char *string, INT32 length, INT32 option);
|
||||
#define V_StringWidth(string, option) V_SubStringWidth(string, -1, option)
|
||||
// Find string width from hu_font chars, 0.5x scale
|
||||
INT32 V_SmallStringWidth(const char *string, INT32 option);
|
||||
INT32 V_SmallSubStringWidth(const char *string, INT32 length, INT32 option);
|
||||
#define V_SmallStringWidth(string, option) V_SmallSubStringWidth(string, -1, option)
|
||||
// Find string width from tny_font chars
|
||||
INT32 V_ThinStringWidth(const char *string, INT32 option);
|
||||
INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 option);
|
||||
#define V_ThinStringWidth(string, option) V_ThinSubStringWidth(string, -1, option)
|
||||
|
||||
// Find maximum length for substring taken from current string to fit into given width
|
||||
INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option);
|
||||
|
||||
char V_GetSkincolorChar(INT32 color);
|
||||
|
||||
|
||||
+19
-2
@@ -2169,8 +2169,16 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
|
||||
if (vsizecache[realentry] == 0)
|
||||
continue;
|
||||
vlumps[i].size = vsizecache[realentry];
|
||||
|
||||
const char *name = (fileinfo + realentry)->name;
|
||||
if (strlen(name) == 5 && memcmp(name, "MAP", 3) == 0)
|
||||
{
|
||||
numlumps--; // We skip map marker, so 1 of entries becomes empty
|
||||
continue; // This will skip i++ so we will write to same entry
|
||||
}
|
||||
|
||||
// Play it safe with the name in this case.
|
||||
memcpy(vlumps[i].name, (fileinfo + realentry)->name, 8);
|
||||
memcpy(vlumps[i].name, name, 8);
|
||||
vlumps[i].name[8] = '\0';
|
||||
vlumps[i].data = (UINT8*)(
|
||||
Z_Malloc(vlumps[i].size, PU_LEVEL, NULL) // This is memory inefficient, sorry about that.
|
||||
@@ -2198,8 +2206,17 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
|
||||
vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
|
||||
for (i = 0; i < numlumps; i++, lumpnum++)
|
||||
{
|
||||
// Check if it is map marker. It is not always first lump sadly, so we need to expect it anywhere
|
||||
const char *name = W_CheckNameForNum(lumpnum);
|
||||
if (strlen(name) == 5 && memcmp(name, "MAP", 3) == 0)
|
||||
{
|
||||
--i; // Decrement so on next iteration we write on same i, so we don't leave corrupted vlumps entry
|
||||
numlumps--; // Just so we don't try to access the leftover vlumps entry
|
||||
continue;
|
||||
}
|
||||
|
||||
vlumps[i].size = W_LumpLength(lumpnum);
|
||||
memcpy(vlumps[i].name, W_CheckNameForNum(lumpnum), 8);
|
||||
memcpy(vlumps[i].name, name, 8);
|
||||
vlumps[i].name[8] = '\0';
|
||||
vlumps[i].data = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user