hash_sparse: change length checks

dont early return on 0 len, let it be the falltrough case, this seems to help branch prediction

src/CMakeLists.txt

@@ -54,7 +54,7 @@ set(SRB2_CORE_SOURCES
 	string.c
 	tables.c
 	v_video.c
-	w_wad.cpp
+	w_wad.c
 	y_inter.c
 	z_zone.cpp
 )

src/Makefile

@@ -269,13 +269,13 @@ endif
 
 ifdef USEASAN
 # compile with asan
-opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
+opts+=-fsanitize=address
 libs+=-fsanitize=address
 endif
 
 ifdef USEUBSAN
-# compile with ubsan
-opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
+# compile with asan
+opts+=-fsanitize=undefined
 libs+=-fsanitize=undefined
 endif
 
@@ -295,7 +295,6 @@ opts+=$(debug_opts)
 
 opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))
 
-CWFLAGS+=-std=gnu17
 CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers
 
 opts+=$(WFLAGS) $(CFLAGS)

src/Makefile.d/versions.mk

@@ -20,8 +20,7 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wnull-dereference
-#WFLAGS+=-Wno-trigraphs
+WFLAGS:=-Wall -Wno-trigraphs -Wnull-dereference
 ifdef GCC152
 WFLAGS+=-Wzero-as-null-pointer-constant
 endif
@@ -32,7 +31,7 @@ ifndef RELAXWARNINGS
  WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
-# WFLAGS+=-Wno-div-by-zero
+ WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -63,7 +62,7 @@ endif
 endif
  WFLAGS+=-Wsign-compare
 ifdef GCC91
-# WFLAGS+=-Wno-error=address-of-packed-member
+ WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
  WFLAGS+=-Wlogical-op
@@ -106,14 +105,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-#WFLAGS+=-Wno-error=format-overflow=2
+WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-#WFLAGS+=-Wno-suggest-attribute=noreturn
+WFLAGS+=-Wno-suggest-attribute=noreturn
 endif
 
 ifdef NOLDWARNING
@@ -131,21 +130,21 @@ ifdef GCC44
 #WFLAGS+=-Wno-error=array-bounds
 endif
 ifdef GCC46
-# WFLAGS+=-Wno-error=suggest-attribute=noreturn
+ WFLAGS+=-Wno-error=suggest-attribute=noreturn
 endif
 ifdef GCC54
-# WFLAGS+=-Wno-logical-op -Wno-error=logical-op
+ WFLAGS+=-Wno-logical-op -Wno-error=logical-op
 endif
 ifdef GCC61
-# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
+ WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
 endif
 ifdef GCC71
  WFLAGS+=-Wimplicit-fallthrough=4
 endif
 ifdef GCC81
-# WFLAGS+=-Wno-error=format-overflow
-# WFLAGS+=-Wno-format-overflow
-# WFLAGS+=-Wno-error=multistatement-macros
+ WFLAGS+=-Wno-error=format-overflow
+ WFLAGS+=-Wno-format-overflow
+ WFLAGS+=-Wno-error=multistatement-macros
 endif
 
 ifneq (,$(filter $(CC) $(CXX),clang clang++))
@@ -184,6 +183,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-#WFLAGS+=-Wno-logical-op
+WFLAGS+=-Wno-logical-op
 endif
 endif

src/blua/lapi.c

@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
 LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
   lua_lock(L);
   luaC_checkGC(L);
-  setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len));
+  setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
   api_incr_top(L);
   lua_unlock(L);
 }
@@ -519,6 +519,23 @@ LUA_API int lua_pushthread (lua_State *L) {
 ** get functions (Lua -> stack)
 */
 
+static void auxgetstr (lua_State *L, const TValue *t, const char *k) {
+  const TValue *slot;
+  TValue key;
+  TString *str = luaS_new(L, k);
+  api_checkvalidindex(L, t);
+  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
+    setobj2s(L, L->top, slot);
+    api_incr_top(L);
+  }
+  else {
+    setsvalue(L, &key, str);
+    luaV_finishget(L, t, L->top, L->top, slot);
+    api_incr_top(L);
+  }
+  lua_unlock(L);
+}
+
 
 LUA_API void lua_gettable (lua_State *L, int idx) {
   StkId t;
@@ -531,15 +548,8 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
 
 
 LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
   lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_gettable(L, t, &key, L->top);
-  api_incr_top(L);
-  lua_unlock(L);
+  auxgetstr(L, index2adr(L, idx), k);
 }
 
 
@@ -630,6 +640,26 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
 ** set functions (stack -> Lua)
 */
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
+  TValue key;
+  const TValue *slot;
+  TString *str = luaS_new(L, k);
+  api_checknelems(L, 1);
+  api_checkvalidindex(L, t);
+  if (luaV_fastset(L, t, str, slot, luaH_setstr, L->top)) {
+    setobj2t(L, cast(TValue *, slot), L->top - 1);
+    L->top--;  /* pop value */
+  }
+  else {
+    setsvalue2s(L, &key, str);
+    luaV_finishset(L, t, &key, L->top - 1, slot);
+    L->top--;  /* pop value */
+  }
+  lua_unlock(L);
+}
+
 
 LUA_API void lua_settable (lua_State *L, int idx) {
   StkId t;
@@ -642,18 +672,12 @@ LUA_API void lua_settable (lua_State *L, int idx) {
   lua_unlock(L);
 }
 
+#pragma GCC diagnostic pop
+
 
 LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
   lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_settable(L, t, &key, L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
+  auxsetstr(L, index2adr(L, idx), k);
 }
 
 

src/blua/lauxlib.c

@@ -20,6 +20,7 @@
 #define lauxlib_c
 #define LUA_LIB
 
+#include "ldebug.h"
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -468,8 +469,19 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
 
 
 LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  while (l--)
-    luaL_addchar(B, *s++);
+ while (l) {
+    size_t space = bufffree(B);
+    if (space == 0) {
+      luaL_prepbuffer(B);
+      lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
+      space = LUAL_BUFFERSIZE;
+    }
+    if (space > l) space = l;
+    memcpy(B->p, s, space);
+    B->p += space;
+    s += space;
+    l -= space;
+  }
 }
 
 
@@ -686,6 +698,6 @@ static int panic (lua_State *L) {
 
 LUALIB_API lua_State *luaL_newstate (void) {
   lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
+  if (l_likely(L)) lua_atpanic(L, &panic);
   return L;
 }

src/blua/lcode.c

@@ -626,8 +626,20 @@ static void codenot (FuncState *fs, expdesc *e) {
   removevalues(fs, e->t);
 }
 
+/*
+** Check whether expression 'e' is a literal string
+*/
+static int isKstr (FuncState *fs, expdesc *e) {
+  return (e->k == VK && ttisstring(&fs->f->k[e->u.s.info]));
+}
 
+/*
+** Create expression 't[k]'. 't' must have its final result already in a
+** register or upvalue. Upvalues can only be indexed by literal strings.
+*/
 void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
+  if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non string? */
+    luaK_exp2anyreg(fs, t);  /* put it in a register */
   t->u.s.aux = luaK_exp2RK(fs, k);
   t->k = VINDEXED;
 }
@@ -790,18 +802,19 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
     case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
     case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
     case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
+      break;
+    }
+    case OPR_EQ: case OPR_LT: case OPR_LE: {
+      codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
+      break;
+    }
+    case OPR_NE: case OPR_GT: case OPR_GE: {
+      codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
+      break;
+    }
     default: lua_assert(0);
   }
 }

src/blua/lcode.h

@@ -21,13 +21,13 @@
 
 
 /*
-** grep "ORDER OPR" if you change these enums
+** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
   OPR_CONCAT,
-  OPR_NE, OPR_EQ,
-  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_EQ, OPR_LT, OPR_LE,
+  OPR_NE, OPR_GT, OPR_GE,
   OPR_AND, OPR_OR,
   OPR_BAND, OPR_BOR, OPR_BXOR,
   OPR_BSHL, OPR_BSHR,

src/blua/ldebug.c

@@ -542,16 +542,39 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
 
 
 static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+  TMS tm = 0;
   Instruction i;
   if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
     return NULL;  /* calling function is not Lua (or is unknown) */
   ci--;  /* calling function */
   i = ci_func(ci)->l.p->code[currentpc(L, ci)];
-  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
-      GET_OPCODE(i) == OP_TFORLOOP)
-    return getobjname(L, ci, GETARG_A(i), name);
-  else
-    return NULL;  /* no useful name can be found */
+  switch (GET_OPCODE(i)) {
+    case OP_CALL:
+    case OP_TAILCALL:
+    case OP_TFORLOOP:
+      return getobjname(L, ci, GETARG_A(i), name);
+    case OP_GETGLOBAL:
+    case OP_SELF:
+    case OP_GETTABLE: tm = TM_INDEX; break;
+    case OP_SETGLOBAL:
+    case OP_SETTABLE: tm = TM_NEWINDEX; break;
+    case OP_EQ: tm = TM_EQ; break;
+    case OP_ADD: tm = TM_ADD; break;
+    case OP_SUB: tm = TM_SUB; break;
+    case OP_MUL: tm = TM_MUL; break;
+    case OP_DIV: tm = TM_DIV; break;
+    case OP_MOD: tm = TM_MOD; break;
+    case OP_POW: tm = TM_POW; break;
+    case OP_UNM: tm = TM_UNM; break;
+    case OP_LEN: tm = TM_LEN; break;
+    case OP_LT: tm = TM_LT; break;
+    case OP_LE: tm = TM_LE; break;
+    case OP_CONCAT: tm = TM_CONCAT; break;
+    default:
+      return NULL;  /* else no useful name can be found */
+  }
+  *name = getstr(G(L)->tmname[tm]);
+  return "metamethod";
 }
 
 

src/blua/ldo.c

@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
 
 
 void luaD_growstack (lua_State *L, int n) {
-  if (l_likely(n <= L->stacksize))  /* double size is enough? */
+  if (n <= L->stacksize)  /* double size is enough? */
     luaD_reallocstack(L, 2*L->stacksize);
   else
     luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
     ci->top = L->top + LUA_MINSTACK;
     lua_assert(ci->top <= L->stack_last);
     ci->nresults = nresults;
-    if (L->hookmask & LUA_MASKCALL)
+    if (l_unlikely(L->hookmask & LUA_MASKCALL))
       luaD_callhook(L, LUA_HOOKCALL, -1);
     lua_unlock(L);
     n = (*curr_func(L)->c.f)(L);  /* do the actual call */

src/blua/liolib.c

@@ -356,20 +356,21 @@ static int read_line (lua_State *L, FILE *f) {
 
 
 static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
+  size_t tbr = n;  /* number of chars to be read */
+  size_t rlen;  /* how much to read in each cycle */
+  size_t nr;  /* number of chars actually read in each cycle */
   luaL_Buffer b;
   luaL_buffinit(L, &b);
   rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
   do {
     char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    if (rlen > tbr) rlen = tbr;  /* cannot read more than asked */
     nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
-    n -= nr;  /* still have to read `n' chars */
-  } while (n > 0 && nr == rlen);  /* until end of count or eof */
+    tbr -= nr;  /* still have to read 'tbr' chars */
+  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
   luaL_pushresult(&b);  /* close buffer */
-  return (n == 0 || lua_objlen(L, -1) > 0);
+  return (tbr == 0 || tbr < n);  /* true iff read something */
 }
 
 
@@ -432,13 +433,13 @@ static int f_read (lua_State *L) {
 
 static int io_readline (lua_State *L) {
   FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int sucess;
+  int success;
   if (f == NULL)  /* file is already closed? */
     luaL_error(L, "file is already closed");
-  sucess = read_line(L, f);
+  success = read_line(L, f);
   if (ferror(f))
     return luaL_error(L, "%s", strerror(errno));
-  if (sucess) return 1;
+  if (success) return 1;
   else {  /* EOF */
     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
       lua_settop(L, 0);

src/blua/lopcodes.h

@@ -232,6 +232,8 @@ OP_VARARG/*	A B	R(A), R(A+1), ..., R(A+B-1) = vararg		*/
   (*) In OP_SETLIST, if (B == 0) then B = `top';
       if (C == 0) then next `instruction' is real C
 
+  (*) In OP_SELF, the index must be a string.
+
   (*) For comparisons, A specifies what condition the test should accept
       (true or false).
 

src/blua/lparser.c

@@ -881,10 +881,10 @@ static const struct {
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
    {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* power and concat (right associative) */
-   {3, 3}, {3, 3},                  /* equality and inequality */
-   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
-   {2, 2}, {1, 1}                   /* logical (and/or) */
+   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
+   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
+   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
+   {2, 2}, {1, 1}                   /* and, or */
    ,{6, 6}, {6, 6}, {6, 6},           /* bit-wise (band/bor/bxor) */
    {7, 7}, {7, 7}		    /* shl/shr */
 };

src/blua/lstring.c

@@ -51,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
                                        unsigned int h) {
   TString *ts;
   stringtable *tb;
-  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
+  if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
     luaM_toobig(L);
   ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
   ts->tsv.len = l;
@@ -72,18 +72,72 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
 }
 
 
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
+// string hash taken from luaJIT
+
+/* Unaligned load of uint32_t. */
+static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
+{
+  uint32_t result;
+  memcpy(&result, ptr, 4);
+  return result;
+}
+
+// smol macro to look a little less messy lul
+#define getu8(p) *cast(const uint8_t *, p)
+
+/* Keyed sparse ARX string hash. Constant time. */
+static unsigned hash_sparse(const char *str, size_t len)
+{
+  /* Constants taken from lookup3 hash by Bob Jenkins. */
+  unsigned int a, b, h = cast(unsigned int, len);
+#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
+  if (len >= 4) {  /* Caveat: unaligned access! */
+    a  = getu32(str);
+    h ^= getu32(str+len-4);
+    b  = getu32(str+(len>>1)-2);
+    h ^= b; h -= rol(b, 14);
+    b += getu32(str+(len>>2)-1);
+  } else if (len > 0) {
+    a  = getu8(str);
+    h ^= getu8(str+len-1);
+    b  = getu8(str+(len>>1));
+    h ^= b; h -= rol(b, 14);
+  } else {
+    return 0;
+  }
+  a ^= h; a -= rol(h, 11);
+  b ^= a; b -= rol(a, 25);
+  h ^= b; h -= rol(b, 16);
+#undef rol
+  return h;
+}
+
+#undef getu8
+
+
+static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
+#if 0
   unsigned int h = cast(unsigned int, l);  /* seed */
   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
   size_t l1;
   for (l1=l; l1>=step; l1-=step)  /* compute hash */
     h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
+  return h;
+#else
+  return hash_sparse(str, l);
+#endif
+}
+
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
+  unsigned int h = luaS_hash(str, l);
   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
        o != NULL;
        o = o->gch.next) {
     TString *ts = rawgco2ts(o);
-    if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
+    if (ts->tsv.hash == h &&
+        ts->tsv.len == l &&
+       (memcmp(str, getstr(ts), l) == 0)) {
       /* string may be dead */
       if (isdead(G(L), o)) changewhite(o);
       return ts;

src/blua/ltm.c

@@ -61,7 +61,7 @@ TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
 }
 
 
-TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event) {
+TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
   Table *mt;
   switch (ttype(o)) {
     case LUA_TTABLE:

src/blua/ltm.h

@@ -55,7 +55,7 @@ LUAI_DATA const char *const luaT_typenames[];
 
 
 LUAI_FUNC TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event);
+LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event);
 LUAI_FUNC void luaT_init (lua_State *L);
 
 #endif

src/blua/lvm.c

@@ -28,7 +28,7 @@
 
 
 
-/* limit for table tag-method chains (to avoid loops) */
+/* limit for table tag-method chains (to avoid infinite loops) */
 #define MAXTAGLOOP	100
 
 
@@ -105,61 +105,94 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
 }
 
 
-void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
-  int loop;
+/*
+** Finish the table access 'val = t[key]'.
+** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
+** t[k] entry (which must be nil).
+*/
+void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
+                      const TValue *slot) {
+  int loop;  /* counter to avoid infinite loops */
+  const TValue *tm;  /* metamethod */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      const TValue *res = luaH_get(h, key); /* do a primitive get */
-      if (!ttisnil(res) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
-        setobj2s(L, val, res);
+    if (slot == NULL) {  /* 't' is not a table? */
+      lua_assert(!ttistable(t));
+      tm = luaT_gettmbyobj(L, t, TM_INDEX);
+      if (l_unlikely(ttisnil(tm)))
+        luaG_typeerror(L, t, "index");  /* no metamethod */
+      /* else will try the metamethod */
+    }
+    else {  /* 't' is a table */
+      lua_assert(ttisnil(slot));
+      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
+      if (tm == NULL) {  /* no metamethod? */
+        setnilvalue(val);  /* result is nil */
         return;
       }
-      /* else will try the tag method */
+      /* else will try the metamethod */
     }
-    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTMres(L, val, tm, t, key);
+    if (ttisfunction(tm)) {  /* is metamethod a function? */
+      callTMres(L, val, tm, t, key);  /* call it */
       return;
     }
-    t = tm;  /* else repeat with `tm' */
+    t = tm;  /* else try to access 'tm[key]' */
+    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
+      setobj2s(L, val, slot);  /* done */
+      return;
+    }
+    /* else repeat (tail call 'luaV_finishget') */
   }
-  luaG_runerror(L, "loop in gettable");
+  luaG_runerror(L, "'__index' chain too long; possible loop");
 }
 
-
-void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
-  int loop;
+/*
+** Finish a table assignment 't[key] = val'.
+** If 'slot' is NULL, 't' is not a table.  Otherwise, 'slot' points
+** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
+** entry.  (The value at 'slot' must be nil, otherwise 'luaV_fastset'
+** would have done the job.)
+*/
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
+                     StkId val, const TValue *slot) {
+  int loop;  /* counter to avoid infinite loops */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    TValue *tm = NULL;
-    if (ttistable(t)) {  /* `t' is a table? */
+    const TValue *tm;
+    if (slot != NULL) {
+      lua_assert(ttistable(t) && ttisnil(slot));
       Table *h = hvalue(t);
-      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
-      /* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
-      if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
-         ((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
-        setobj2t(L, oldval, val);
+      /* must check the metamethod */
+      /* slot is nil=> look for newindex, slot is not nil => look for usedindex */
+      if (!((ttisnil(slot) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
+         ((!ttisnil(slot)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
+        /* no metamethod and (now) there is an entry with given key */
+        setobj2t(L, cast(TValue *, slot), val);
         luaC_barriert(L, h, val);
         return;
       }
-      /* else will try the tag method */
+      /* else will try the metamethod */
     }
-    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
-      luaG_typeerror(L, t, "index");
+    else {  /* not a table; check metamethod */
+      if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
+        luaG_typeerror(L, t, "index");
+    }
+    /* try the metamethod */
     if (ttisfunction(tm)) {
       callTM(L, tm, t, key, val);
       return;
     }
-    t = tm;  /* else repeat with `tm' */
+    t = tm;  /* else repeat assignment over 'tm' */
+    if (luaV_fastset(L, t, key, slot, luaH_set, val))
+      return;  /* done */
+    /* else loop */
   }
-  luaG_runerror(L, "loop in settable");
+  luaG_runerror(L, "settable chain too long; possible loop");
 }
+#pragma GCC diagnostic pop
 
 
-static int call_binTM (lua_State *L, TValue *p1, TValue *p2,
+static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                        StkId res, TMS event) {
   const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
   if (ttisnil(tm))
@@ -184,7 +217,7 @@ static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
 }
 
 
-static int call_orderTM (lua_State *L, TValue *p1, TValue *p2,
+static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
                          TMS event) {
   const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
   const TValue *tm2;
@@ -366,6 +399,7 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
 
 
 #define arith_op(op,tm) { \
+        StkId ra = RA(i); \
         TValue *rb = RKB(i); \
         TValue *rc = RKC(i); \
         if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -377,6 +411,24 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
       }
 
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+
+/*
+** copy of 'luaV_gettable', but protecting call to potential metamethod
+** (which can reallocate the stack)
+*/
+#define gettableProtected(L,t,k,v)  { const TValue *slot; \
+  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
+  else Protect(luaV_finishget(L,t,k,v,slot)); }
+
+
+/* same for 'luaV_settable' */
+#define settableProtected(L,t,k,v) { const TValue *slot; \
+  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
+    Protect(luaV_finishset(L,t,k,v,slot)); }
+
+
 
 void luaV_execute (lua_State *L, int nexeccalls) {
   LClosure *cl;
@@ -386,13 +438,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
  reentry:  /* entry point */
   lua_assert(isLua(L->ci));
   pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;
-  base = L->base;
-  k = cl->p->k;
+  cl = &clvalue(L->ci->func)->l;  /* local reference to function's closure */
+  k = cl->p->k;  /* local reference to function's constant table */
+  base = L->base;  /* local copy of function's base */
   /* main loop of interpreter */
   for (;;) {
     const Instruction i = *pc++;
-    StkId ra;
     if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
       traceexec(L, pc);
@@ -402,26 +453,28 @@ void luaV_execute (lua_State *L, int nexeccalls) {
       }
       base = L->base;
     }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
     lua_assert(base == L->base && L->base == L->ci->base);
     lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
     lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
     switch (GET_OPCODE(i)) {
       case OP_MOVE: {
+        StkId ra = RA(i);
         setobjs2s(L, ra, RB(i));
         continue;
       }
       case OP_LOADK: {
+        StkId ra = RA(i);
         setobj2s(L, ra, KBx(i));
         continue;
       }
       case OP_LOADBOOL: {
+        StkId ra = RA(i);
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
         continue;
       }
       case OP_LOADNIL: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
@@ -429,11 +482,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETUPVAL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
         continue;
       }
       case OP_GETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         TValue *rb = KBx(i);
         sethvalue(L, &g, cl->env);
@@ -442,10 +497,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
+        StkId ra = RA(i);
+        StkId rb = RB(i);
+        TValue *rc = RKC(i);
+        gettableProtected(L, rb, rc, ra);
         continue;
       }
       case OP_SETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
@@ -453,16 +512,21 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETUPVAL: {
+        StkId ra = RA(i);
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
         continue;
       }
       case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
+        StkId ra = RA(i);
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        settableProtected(L, ra, rb, rc);
         continue;
       }
       case OP_NEWTABLE: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int c = GETARG_C(i);
         sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -470,9 +534,16 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SELF: {
+        StkId ra = RA(i);
+        const TValue *slot;
         StkId rb = RB(i);
-        setobjs2s(L, ra+1, rb);
-        Protect(luaV_gettable(L, rb, RKC(i), ra));
+        TValue *rc = RKC(i);
+        TString *key = rawtsvalue(rc);  /* key must be a string */
+        setobjs2s(L, ra + 1, rb);
+        if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
+          setobj2s(L, ra, slot);
+        }
+        else Protect(luaV_finishget(L, rb, rc, ra, slot));
         continue;
       }
       case OP_ADD: {
@@ -488,6 +559,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_DIV: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -503,6 +575,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_MOD: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -522,26 +595,27 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_BAND: {
-	arith_op(luai_numand, TM_AND);
-	continue;
+        arith_op(luai_numand, TM_AND);
+        continue;
       }
       case OP_BOR: {
-	arith_op(luai_numor, TM_OR);
-	continue;
+        arith_op(luai_numor, TM_OR);
+        continue;
       }
       case OP_BXOR: {
-	arith_op(luai_numxor, TM_XOR);
-	continue;
+        arith_op(luai_numxor, TM_XOR);
+        continue;
       }
       case OP_BSHL: {
-	arith_op(luai_numshl, TM_SHL);
-	continue;
+        arith_op(luai_numshl, TM_SHL);
+        continue;
       }
       case OP_BSHR: {
-	arith_op(luai_numshr, TM_SHR);
-	continue;
+        arith_op(luai_numshr, TM_SHR);
+        continue;
       }
       case OP_BNOT: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -553,6 +627,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_UNM: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -564,11 +639,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_NOT: {
+        StkId ra = RA(i);
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
         continue;
       }
       case OP_LEN: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         switch (ttype(rb)) {
           case LUA_TTABLE: {
@@ -626,12 +703,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TEST: {
+        StkId ra = RA(i);
         if (l_isfalse(ra) != GETARG_C(i))
           dojump(L, pc, GETARG_sBx(*pc));
         pc++;
         continue;
       }
       case OP_TESTSET: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (l_isfalse(rb) != GETARG_C(i)) {
           setobjs2s(L, ra, rb);
@@ -641,6 +720,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int nresults = GETARG_C(i) - 1;
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
@@ -662,6 +742,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_TAILCALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         L->savedpc = pc;
@@ -694,6 +775,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_RETURN: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
@@ -709,6 +791,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_FORLOOP: {
+        StkId ra = RA(i);
         lua_Number step = nvalue(ra+2);
         lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
         lua_Number limit = nvalue(ra+1);
@@ -721,6 +804,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_FORPREP: {
+        StkId ra = RA(i);
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
@@ -737,6 +821,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TFORLOOP: {
+        StkId ra = RA(i);
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+2, ra+2);
         setobjs2s(L, cb+1, ra+1);
@@ -753,6 +838,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETLIST: {
+        StkId ra = RA(i);
         int n = GETARG_B(i);
         int c = GETARG_C(i);
         int last;
@@ -775,10 +861,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CLOSE: {
+        StkId ra = RA(i);
         luaF_close(L, ra);
         continue;
       }
       case OP_CLOSURE: {
+        StkId ra = RA(i);
         Proto *p;
         Closure *ncl;
         int nup, j;
@@ -799,6 +887,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_VARARG: {
+        StkId ra = RA(i);
         int b = GETARG_B(i) - 1;
         int j;
         CallInfo *ci = L->ci;
@@ -822,3 +911,5 @@ void luaV_execute (lua_State *L, int nexeccalls) {
     }
   }
 }
+
+#pragma GCC diagnostic pop

src/blua/lvm.h

@@ -22,14 +22,61 @@
 	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
 
 
+/*
+** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
+** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
+** return 0 (meaning it will have to check metamethod) with 'slot'
+** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
+** 'f' is the raw get function to use.
+*/
+#define luaV_fastget(L,t,k,slot,f) \
+  (!ttistable(t)  \
+   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
+   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
+      !ttisnil(slot)))  /* result not nil? */
+
+/*
+** standard implementation for 'gettable'
+*/
+#define luaV_gettable(L,t,k,v) { const TValue *slot; \
+  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
+  else luaV_finishget(L,t,k,v,slot); }
+
+
+/*
+** Fast track for set table. If 't' is a table and 't[k]' is not nil,
+** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
+** return false with 'slot' equal to NULL (if 't' is not a table) or
+** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
+** returns true, there is no need to 'invalidateTMcache', because the
+** call is not creating a new entry.
+*/
+#define luaV_fastset(L,t,k,slot,f,v) \
+  (!ttistable(t) \
+   ? (slot = NULL, 0) \
+   : (slot = f(L, hvalue(t), k), \
+     ttisnil(slot) ? 0 \
+     : (__extension__ ({ \
+          if (valiswhite(v) && isblack(obj2gco(hvalue(t)))) \
+            luaC_barrierback(L, hvalue(t)); \
+          setobj2t(L, cast(TValue *,slot), v); \
+          1; \
+        }))))
+
+#define luaV_settable(L,t,k,v) { const TValue *slot; \
+  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
+    luaV_finishset(L,t,k,v,slot); }
+
+
+
 LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
 LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
 LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
 LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
-                                            StkId val);
+LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
+                               StkId val, const TValue *tm);
+LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
+                               StkId val, const TValue *oldval);
 LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
 LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
 

src/command.c

@@ -1178,7 +1178,7 @@ consvar_t *CV_FindVar(const char *name)
 	consvar_t *cvar;
 
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
-		if (fasticmp(name, cvar->name))
+		if (fasticmp(name,cvar->name))
 			return cvar;
 
 	return NULL;

src/console.c

@@ -46,16 +46,16 @@
 #ifdef HAVE_THREADS
 I_mutex con_mutex;
 
-// I_In_Exiting_Signal_Handler is an evil hack
+// g_in_exiting_signal_handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/
 
 static boolean con_started = false; // console has been initialised
        boolean con_startup = false; // true at game startup, screen need refreshing
@@ -640,25 +640,65 @@ INT32 CON_ShiftChar(INT32 ch)
 
 	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
 	{
-		if (shiftdown ^ capslock)
-			ch = shiftxform[ch];
-	}
-	else // if we're holding shift we should still shift non letter symbols
-	{
-		if (shiftdown)
-			ch = shiftxform[ch];
-		else if (cv_keyboardlayout.value == 3)
+		if (cv_keyboardlayout.value == 3)
 		{
-			if (altdown & 0x2)
+			if (shiftdown ^ capslock)
+				ch = shiftxform[ch];
+			else if (altdown & 0x2)
 				ch = french_altgrxform[ch];
 			else
 				ch = HU_FallBackFrSpecialLetter(ch);
 		}
+		else
+		{
+			if (shiftdown ^ capslock)
+				ch = shiftxform[ch];
+		}
+	}
+	else	// if we're holding shift we should still shift non letter symbols
+	{
+		if (cv_keyboardlayout.value == 3)
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+			else if (altdown & 0x2)
+				ch = french_altgrxform[ch];
+			else
+				ch = HU_FallBackFrSpecialLetter(ch);
+		}
+		else
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+		}
 	}
 
 	return ch;
 }
 
+INT32 CON_ShitAndAltGrChar(INT32 ch)
+{
+	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
+	{
+		if (shiftdown ^ capslock)
+			ch = shiftxform[ch];
+	}
+	else	// if we're holding shift we should still shift non letter symbols
+	{
+		if (shiftdown)
+			ch = shiftxform[ch];
+		else if (altdown & 0x2)
+		{
+			ch = french_altgrxform[ch];
+		}
+		else
+		{
+			ch = HU_FallBackFrSpecialLetter(ch);
+		}
+	}
+
+	return ch;
+}
 
 // Clear time of console heads up messages
 //
@@ -852,7 +892,7 @@ boolean CON_Responder(event_t *ev)
 		return true;
 
 	// ctrl modifier -- changes behavior, adds shortcuts
-	if (ctrldown && (cv_keyboardlayout.value != 3 || (cv_keyboardlayout.value == 3 && !altdown)))
+	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
 	{
 		// show all cvars/commands that match what we have inputted
 		if (key == KEY_TAB)
@@ -1182,10 +1222,19 @@ void CON_LogMessage(const char *msg)
 // Console print! Wahooo! Lots o fun!
 //
 
-static inline void CONS_PrintMsg(char *txt)
+void CONS_Printf(const char *fmt, ...)
 {
+	va_list argptr;
+	static char *txt = NULL;
 	boolean startup;
 
+	if (txt == NULL)
+		txt = malloc(8192);
+
+	va_start(argptr, fmt);
+	vsnprintf(txt, 8192, fmt, argptr);
+	va_end(argptr);
+
 	// echo console prints to log file
 	DEBFILE(txt);
 
@@ -1211,21 +1260,6 @@ static inline void CONS_PrintMsg(char *txt)
 	}
 }
 
-void CONS_Printf(const char *fmt, ...)
-{
-	va_list argptr;
-	static char *txt = NULL;
-
-	if (txt == NULL)
-		txt = malloc(8192);
-
-	va_start(argptr, fmt);
-	vsnprintf(txt, 8192, fmt, argptr);
-	va_end(argptr);
-
-	CONS_PrintMsg(txt);
-}
-
 void CONS_Alert(alerttype_t level, const char *fmt, ...)
 {
 	va_list argptr;
@@ -1254,7 +1288,9 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
 			break;
 	}
 
-	CONS_PrintMsg(txt);
+	// I am lazy and I feel like just letting CONS_Printf take care of things.
+	// Is that okay?
+	CONS_Printf("%s", txt);
 }
 
 void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1272,9 +1308,11 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 	vsnprintf(txt, 8192, fmt, argptr);
 	va_end(argptr);
 
-	CONS_PrintMsg(txt);
+	// Again I am lazy, oh well
+	CONS_Printf("%s", txt);
 }
 
+
 // Print an error message, and wait for ENTER key to continue.
 // To make sure the user has seen the message
 //

src/console.h

@@ -13,10 +13,6 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -49,6 +45,7 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
 extern UINT8 *consolebgmap;
 
 INT32 CON_ShiftChar(INT32 ch);
+INT32 CON_ShitAndAltGrChar(INT32 ch);
 
 void CON_SetupBackColormap(void);
 void CON_ClearHUD(void); // clear heads up messages
@@ -66,8 +63,4 @@ boolean CON_Ready(void);
 
 void CON_LogMessage(const char *msg);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

src/d_clisrv.h

@@ -654,17 +654,15 @@ void D_ResetTiccmds(void);
 
 tic_t GetLag(INT32 node);
 
-extern boolean hu_resynching;
+extern UINT8 hu_resynching;
 #ifdef SATURNPAK
-extern boolean hu_redownloadinggamestate;
+extern UINT8 hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 
-#define SAVEGAMESIZE (768*1024)
-
 typedef struct rewind_s
 {
-	UINT8 savebuffer[SAVEGAMESIZE];
+	UINT8 savebuffer[(768*1024)];
 	tic_t leveltime;
 	size_t demopos;
 

src/d_main.c

@@ -130,8 +130,8 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadwadcount = 0;
-static size_t postloadwadcount = 0;
+static size_t autoloadcount = 0;
+static size_t postloadcount = 0;
 //
 
 boolean devparm = false; // started game with -devparm
@@ -697,11 +697,6 @@ void D_SRB2Loop(void)
 
 	for (;;)
 	{
-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		// capbudget is the minimum precise_t duration of a single loop iteration
 		precise_t capbudget;
 		precise_t elapsed;
@@ -1037,38 +1032,25 @@ static INT32 D_DetectFileType(const char* filename)
 }
 
 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);
 
-	if (*index >= MAX_WADFILES)
-	{
-		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
-		return;
-	}
-
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}
 
-	if (fileType == 1)
-	{
-		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
-		return;
-	}
-
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
+			I_Error("No more free memory to AutoloadFile %s",file);
 
 		strcpy(newfile, file);
-		filearray[*index] = newfile;
-		(*index)++;
+		filearray[index] = newfile;
 	}
 	else
 	{
@@ -1111,7 +1093,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}
 
@@ -1137,34 +1119,27 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';
 
-		// ok so theres still issues with players adding stuff to autoload by accident
-		// sometimes this stuff contains maps
-		// you can probably imagine how that goes in a netgame....
-		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
-		{
-			CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
-			continue;
-		}
-
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}
 
 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
+			autoloadcount++;
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
+			postloadcount++;
 		}
 	}
 
-	autoloadwadfiles[autoloadwadcount] = NULL;
-	autoloadwadfilespost[postloadwadcount] = NULL;
+	autoloadwadfiles[autoloadcount] = NULL;
+	autoloadwadfilespost[postloadcount] = NULL;
 
 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1173,7 +1148,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadwadcount == 0)
+	if (autoloadcount == 0)
 		return;
 
 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1181,15 +1156,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfiles, autoloadwadcount);
+	D_CleanFile(autoloadwadfiles, autoloadcount);
 
-	autoloadwadcount = 0;
+	autoloadcount = 0;
 }
 
 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadwadcount == 0 || !netgame)
+	if (postloadcount == 0 || !netgame)
 		return;
 
 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1197,9 +1172,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfilespost, postloadwadcount);
+	D_CleanFile(autoloadwadfilespost, postloadcount);
 
-	postloadwadcount = 0;
+	postloadcount = 0;
 }
 
 // ==========================================================================
@@ -1208,7 +1183,7 @@ void D_AddPostloadFiles(void)
 
 static boolean AddIWAD(const char * file, const char *dir)
 {
-	char *path = va(pandf, dir, file);
+	char * path = va(pandf, dir, file);
 
 	if (FIL_ReadFileOK(path))
 	{
@@ -2043,7 +2018,7 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
-		gconst char *replayname = strrchr(replayurl, '/');
+		char *replayname = strrchr(replayurl, '/');
 
 		if (!replayname || !replayurl)
 			I_Error("REPLAY: Invalid URL.");

src/d_net.c

@@ -612,8 +612,12 @@ void Net_WaitAllAckReceived(UINT32 timeout)
 
 static void InitNode(node_t *node)
 {
-	memset(node, 0, sizeof(node_t));
+	node->acktosend_head = node->acktosend_tail = 0;
+	memset(node->acktosend, 0, sizeof(node->acktosend));
+	node->firstacktosend = 0;
 	node->nextacknum = 1;
+	node->remotefirstack = 0;
+	node->flags = 0;
 }
 
 static void InitAck(void)

src/d_netcmd.c

@@ -1208,11 +1208,11 @@ static boolean AllowedPlayerNameChar(char ch)
 
 static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 {
-	size_t ix, len = strlen(name);
+	INT32 ix;
 
-	if (len == 0 || len > MAXPLAYERNAME)
+	if (strlen(name) == 0 || strlen(name) > MAXPLAYERNAME)
 		return false; // Empty or too long.
-	if (name[0] == ' ' || name[len-1] == ' ')
+	if (name[0] == ' ' || name[strlen(name)-1] == ' ')
 		return false; // Starts or ends with a space.
 	if (isdigit(name[0]))
 		return false; // Starts with a digit.
@@ -1226,19 +1226,20 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 
 	// Also, anything over 0x80 is disallowed too, since compilers love to
 	// differ on whether they're printable characters or not.
-	for (ix = 0; ix < len; ix++)
+	for (ix = 0; name[ix] != '\0'; ix++)
 		if (!AllowedPlayerNameChar(name[ix]))
 			return false;
 
 	// Check if a player is currently using the name, case-insensitively.
 	for (ix = 0; ix < MAXPLAYERS; ix++)
 	{
-		if (ix != (size_t)playernum && playeringame[ix]
+		if (ix != playernum && playeringame[ix]
 			&& fasticmp(name, player_names[ix]))
 		{
 			// We shouldn't kick people out just because
 			// they joined the game with the same name
 			// as someone else -- modify the name instead.
+			size_t len = strlen(name);
 
 			// Recursion!
 			// Slowly strip characters off the end of the
@@ -1457,9 +1458,7 @@ UINT8 CanChangeSkin(INT32 playernum)
 				return true;
 		}
 
-		if (players[playernum].spectator ||
-			players[playernum].playerstate == PST_DEAD ||
-			players[playernum].playerstate == PST_REBORN)
+		if (players[playernum].spectator || players[playernum].playerstate == PST_DEAD || players[playernum].playerstate == PST_REBORN)
 			return true;
 
 		return false;
@@ -1493,144 +1492,445 @@ static void ForceAllSkins(INT32 forcedskin)
 	}
 }
 
-static INT32 chmappending;
-static INT32 snacpending[MAXSPLITSCREENPLAYERS];
-
-// wonky compat, idk if anything uses this....
-#define playerisbot (splitplayer == 1 && botingame)
+static INT32 snacpending = 0, snac2pending = 0, snac3pending = 0, snac4pending = 0, chmappending = 0;
 
 // name, color, or skin has changed
 //
-static void SendNameAndColor(UINT8 splitplayer)
+static void SendNameAndColor(void)
 {
 	char buf[MAXPLAYERNAME+2];
 	char *p;
 
 	p = buf;
 
-	// splitscreen
-	if (splitscreen < splitplayer && !playerisbot)
-		return;
-
-	const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
-
-	player_t *player = &players[pnum];
-
-	// TODO: make those cvars arrays
-	consvar_t *playercolor, *playername, *playerskin;
-	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
-	consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
-	consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
-
-	playercolor = colorvars[splitplayer];
-	playername  = namevars[splitplayer];
-	playerskin  = skinvars[splitplayer];
-
 	// normal player colors
 	if (G_GametypeHasTeams())
 	{
-		if (player->ctfteam == 1 && playercolor->value != skincolor_redteam)
-			CV_StealthSetValue(playercolor, skincolor_redteam);
-		else if (player->ctfteam == 2 && playercolor->value != skincolor_blueteam)
-			CV_StealthSetValue(playercolor, skincolor_blueteam);
+		if (players[consoleplayer].ctfteam == 1 && cv_playercolor.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor, skincolor_redteam);
+		else if (players[consoleplayer].ctfteam == 2 && cv_playercolor.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor, skincolor_blueteam);
 	}
 
 	// never allow the color "none"
-	if (!playercolor->value)
+	if (!cv_playercolor.value)
 	{
-		if (player->skincolor)
-			CV_StealthSetValue(playercolor, player->skincolor);
-		else if (skins[player->skin].prefcolor)
-			CV_StealthSetValue(playercolor, skins[player->skin].prefcolor);
+		if (players[consoleplayer].skincolor)
+			CV_StealthSetValue(&cv_playercolor, players[consoleplayer].skincolor);
+		else if (skins[players[consoleplayer].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
 		else
-			CV_StealthSet(playercolor, playercolor->defaultvalue);
+			CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
 	}
 
+	if (fastcmp(cv_playername.string, player_names[consoleplayer])
+		&& cv_playercolor.value == players[consoleplayer].skincolor
+		&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
+		return;
+
 	// We'll handle it later if we're not playing.
 	if (!Playing())
 		return;
 
-	if (fastcmp(playername->string, player_names[pnum])
-		&& playercolor->value == player->skincolor
-		&& fastcmp(playerskin->string, skins[player->skin].name))
-		return;
-
-	if (playerisbot)
-	{
-		players[pnum].skincolor = botcolor;
-		if (players[pnum].mo)
-			players[pnum].mo->color = players[pnum].skincolor;
-		SetPlayerSkinByNum(pnum, botskin-1);
-		return;
-	}
-
 	// If you're not in a netgame, merely update the skin, color, and name.
 	if (!netgame)
 	{
 		INT32 foundskin;
 
-		CleanupPlayerName(pnum, playername->zstring);
-		strcpy(player_names[pnum], playername->zstring);
+		CleanupPlayerName(consoleplayer, cv_playername.zstring);
+		strcpy(player_names[consoleplayer], cv_playername.zstring);
 
-		player->skincolor = playercolor->value;
+		players[consoleplayer].skincolor = cv_playercolor.value;
 
-		if (player->mo)
-			player->mo->color = player->skincolor;
+		if (players[consoleplayer].mo)
+			players[consoleplayer].mo->color = players[consoleplayer].skincolor;
 
-		if ((foundskin = R_SkinAvailable(playerskin->string)) != -1)
+		if ((foundskin = R_SkinAvailable(cv_skin.string)) != -1)
 		{
-			playerskin->value = foundskin;
-			SetPlayerSkin(pnum, playerskin->string);
-			CV_StealthSet(playerskin, skins[playerskin->value].name);
+			cv_skin.value = foundskin;
+			SetPlayerSkin(consoleplayer, cv_skin.string);
+			CV_StealthSet(&cv_skin, skins[cv_skin.value].name);
 		}
 		else
 		{
-			playerskin->value = player->skin;
-			CV_StealthSet(playerskin, skins[player->skin].name);
+			cv_skin.value = players[consoleplayer].skin;
+			CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 			// will always be same as current
-			SetPlayerSkin(pnum, playerskin->string);
+			SetPlayerSkin(consoleplayer, cv_skin.string);
 		}
 
 		return;
 	}
 
-	snacpending[splitplayer]++;
+	snacpending++;
 
 	// Don't change name if muted
-	if (player_name_changes[pnum] >= MAXNAMECHANGES)
+	if (player_name_changes[consoleplayer] >= MAXNAMECHANGES)
 	{
-		CV_StealthSet(playername, player_names[pnum]);
+		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
 		HU_AddChatText("\x85*You must wait to change your name again", false);
 	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(pnum)))
-		CV_StealthSet(playername, player_names[pnum]);
+	else if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
+		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
 	else // Cleanup name if changing it
-		CleanupPlayerName(pnum, playername->zstring);
+		CleanupPlayerName(consoleplayer, cv_playername.zstring);
 
 	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(pnum))
-		CV_StealthSet(playerskin, skins[player->skin].name);
+	if (!CanChangeSkin(consoleplayer))
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 
 	// check if player has the skin loaded (cv_skin may have
 	// the name of a skin that was available in the previous game)
-	playerskin->value = R_SkinAvailable(playerskin->string);
-	if (playerskin->value < 0)
+	cv_skin.value = R_SkinAvailable(cv_skin.string);
+	if (cv_skin.value < 0)
 	{
-		INT32 skinnum = player->skin;
-		CV_StealthSet(playerskin, skins[skinnum].name);
-		playerskin->value = skinnum;
+		INT32 skinnum = players[consoleplayer].skin;
+		CV_StealthSet(&cv_skin, skins[skinnum].name);
+		cv_skin.value = skinnum;
 	}
 
 	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, playername->zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)playercolor->value);
-	WRITEUINT8(p, (UINT8)playerskin->value);
-	SendNetXCmdForPlayer(splitplayer, XD_NAMEANDCOLOR, buf, p - buf);
+	WRITESTRINGN(p, cv_playername.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor.value);
+	WRITEUINT8(p, (UINT8)cv_skin.value);
+	SendNetXCmdForPlayer(0, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+// splitscreen
+static void SendNameAndColor2(void)
+{
+	INT32 secondplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 1 && !botingame)
+		return; // can happen if skin2/color2/name2 changed
+
+	if (displayplayers[1] != consoleplayer)
+		secondplaya = displayplayers[1];
+	else if (!netgame) // HACK
+		secondplaya = 1;
+
+	if (secondplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[secondplaya].ctfteam == 1 && cv_playercolor2.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor2, skincolor_redteam);
+		else if (players[secondplaya].ctfteam == 2 && cv_playercolor2.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor2, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor2.value)
+	{
+		if (players[secondplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor2, players[secondplaya].skincolor);
+		else if (skins[players[secondplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor2, skins[players[secondplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor2, cv_playercolor2.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (botingame)
+	{
+		players[secondplaya].skincolor = botcolor;
+		if (players[secondplaya].mo)
+			players[secondplaya].mo->color = players[secondplaya].skincolor;
+		SetPlayerSkinByNum(secondplaya, botskin-1);
+		return;
+	}
+	else if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(secondplaya, cv_playername2.zstring);
+		strcpy(player_names[secondplaya], cv_playername2.zstring);
+
+		// don't use displayplayers[1]: the second player must be 1
+		players[secondplaya].skincolor = cv_playercolor2.value;
+		if (players[secondplaya].mo)
+			players[secondplaya].mo->color = players[secondplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin2.string)) != -1)
+		{
+			cv_skin2.value = foundskin;
+			SetPlayerSkin(secondplaya, cv_skin2.string);
+		}
+		else
+		{
+			cv_skin2.value = players[secondplaya].skin;
+			CV_StealthSet(&cv_skin2, skins[players[secondplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(secondplaya, cv_skin2.string);
+		}
+		return;
+	}
+
+	snac2pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[1]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[1])))
+		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[1], cv_playername2.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[1]))
+		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
+
+	// check if player has the skin loaded (cv_skin2 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin2.value = R_SkinAvailable(cv_skin2.string);
+	if (cv_skin2.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[1]].skin;
+		CV_StealthSet(&cv_skin2, skins[skinnum].name);
+		cv_skin2.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername2.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor2.value);
+	WRITEUINT8(p, (UINT8)cv_skin2.value);
+	SendNetXCmdForPlayer(1, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+static void SendNameAndColor3(void)
+{
+	INT32 thirdplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 2)
+		return; // can happen if skin3/color3/name3 changed
+
+	if (displayplayers[2] != consoleplayer)
+		thirdplaya = displayplayers[2];
+	else if (!netgame) // HACK
+		thirdplaya = 2;
+
+	if (thirdplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[thirdplaya].ctfteam == 1 && cv_playercolor3.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor3, skincolor_redteam);
+		else if (players[thirdplaya].ctfteam == 2 && cv_playercolor3.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor3, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor3.value)
+	{
+		if (players[thirdplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor3, players[thirdplaya].skincolor);
+		else if (skins[players[thirdplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor3, skins[players[thirdplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor3, cv_playercolor3.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(thirdplaya, cv_playername3.zstring);
+		strcpy(player_names[thirdplaya], cv_playername3.zstring);
+
+		// don't use displayplayers[2]: the third player must be 2
+		players[thirdplaya].skincolor = cv_playercolor3.value;
+		if (players[thirdplaya].mo)
+			players[thirdplaya].mo->color = players[thirdplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin3.string)) != -1)
+		{
+			cv_skin3.value = foundskin;
+			SetPlayerSkin(thirdplaya, cv_skin3.string);
+		}
+		else
+		{
+			cv_skin3.value = players[thirdplaya].skin;
+			CV_StealthSet(&cv_skin3, skins[players[thirdplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(thirdplaya, cv_skin3.string);
+		}
+		return;
+	}
+
+	snac3pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[2]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[2])))
+		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[2], cv_playername3.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[2]))
+		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
+
+	// check if player has the skin loaded (cv_skin3 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin3.value = R_SkinAvailable(cv_skin3.string);
+	if (cv_skin3.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[2]].skin;
+		CV_StealthSet(&cv_skin3, skins[skinnum].name);
+		cv_skin3.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername3.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor3.value);
+	WRITEUINT8(p, (UINT8)cv_skin3.value);
+	SendNetXCmdForPlayer(2, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+static void SendNameAndColor4(void)
+{
+	INT32 fourthplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 3)
+		return; // can happen if skin4/color4/name4 changed
+
+	if (displayplayers[3] != consoleplayer)
+		fourthplaya = displayplayers[3];
+	else if (!netgame) // HACK
+		fourthplaya = 3;
+
+	if (fourthplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[fourthplaya].ctfteam == 1 && cv_playercolor4.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor4, skincolor_redteam);
+		else if (players[fourthplaya].ctfteam == 2 && cv_playercolor4.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor4, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor4.value)
+	{
+		if (players[fourthplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor4, players[fourthplaya].skincolor);
+		else if (skins[players[fourthplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor4, skins[players[fourthplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor4, cv_playercolor4.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (botingame)
+	{
+		players[fourthplaya].skincolor = botcolor;
+		if (players[fourthplaya].mo)
+			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
+		SetPlayerSkinByNum(fourthplaya, botskin-1);
+		return;
+	}
+	else if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(fourthplaya, cv_playername4.zstring);
+		strcpy(player_names[fourthplaya], cv_playername4.zstring);
+
+		// don't use displayplayers[3]: the second player must be 4
+		players[fourthplaya].skincolor = cv_playercolor4.value;
+		if (players[fourthplaya].mo)
+			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin4.string)) != -1)
+		{
+			cv_skin4.value = foundskin;
+			SetPlayerSkin(fourthplaya, cv_skin4.string);
+		}
+		else
+		{
+			cv_skin4.value = players[fourthplaya].skin;
+			CV_StealthSet(&cv_skin4, skins[players[fourthplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(fourthplaya, cv_skin4.string);
+		}
+		return;
+	}
+
+	snac4pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[3]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[3])))
+		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[3], cv_playername4.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[3]))
+		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
+
+	// check if player has the skin loaded (cv_skin4 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin4.value = R_SkinAvailable(cv_skin4.string);
+	if (cv_skin4.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[3]].skin;
+		CV_StealthSet(&cv_skin4, skins[skinnum].name);
+		cv_skin4.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername4.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor4.value);
+	WRITEUINT8(p, (UINT8)cv_skin4.value);
+	SendNetXCmdForPlayer(3, XD_NAMEANDCOLOR, buf, p - buf);
 }
 
 static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 {
-	player_t *player = &players[playernum];
+	player_t *p = &players[playernum];
 	char name[MAXPLAYERNAME+1];
 	UINT8 color, skin;
 
@@ -1639,14 +1939,19 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		I_Error("There is no player %d!", playernum);
 #endif
 
-	if (P_IsLocalPlayer(player))
-	{
-		snacpending[playernum]--;
+	if (playernum == consoleplayer)
+		snacpending--; // TODO: make snacpending an array instead of 4 separate vars?
+	else if (playernum == displayplayers[1])
+		snac2pending--;
+	else if (playernum == displayplayers[2])
+		snac3pending--;
+	else if (playernum == displayplayers[3])
+		snac4pending--;
+
 #ifdef PARANOIA
-		if (snacpending[playernum] < 0)
-			I_Error("snacpending negative!");
+	if (snacpending < 0 || snac2pending < 0 || snac3pending < 0 || snac4pending < 0)
+		I_Error("snacpending negative!");
 #endif
-	}
 
 	READSTRINGN(*cp, name, MAXPLAYERNAME);
 	color = READUINT8(*cp);
@@ -1660,32 +1965,33 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 	}
 
 	// set color
-	player->skincolor = color % MAXSKINCOLORS;
-	if (player->mo)
-		player->mo->color = (UINT8)player->skincolor;
+	p->skincolor = color % MAXSKINCOLORS;
+	if (p->mo)
+		p->mo->color = (UINT8)p->skincolor;
 	demo_extradata[playernum] |= DXD_COLOR;
 
 	// normal player colors
-	if (server && !P_IsLocalPlayer(player))
+	if (server && (p != &players[consoleplayer] && p != &players[displayplayers[1]]
+		&& p != &players[displayplayers[2]] && p != &players[displayplayers[3]]))
 	{
 		boolean kick = false;
 
 		// team colors
 		if (G_GametypeHasTeams())
 		{
-			if (player->ctfteam == 1 && player->skincolor != skincolor_redteam)
+			if (p->ctfteam == 1 && p->skincolor != skincolor_redteam)
 				kick = true;
-			else if (player->ctfteam == 2 && player->skincolor != skincolor_blueteam)
+			else if (p->ctfteam == 2 && p->skincolor != skincolor_blueteam)
 				kick = true;
 		}
 
 		// don't allow color "none"
-		if (!player->skincolor)
+		if (!p->skincolor)
 			kick = true;
 
 		if (kick)
 		{
-			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], player->ctfteam, player->skincolor);
+			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], p->ctfteam, p->skincolor);
 			SendKick(playernum, KICK_MSG_CON_FAIL);
 			return;
 		}
@@ -1697,7 +2003,6 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		const INT32 forcedskin = cv_forceskin.value;
 		SetPlayerSkinByNum(playernum, forcedskin);
 
-		// TODO: make cv_skin an array
 		if (playernum == consoleplayer)
 			CV_StealthSet(&cv_skin, skins[forcedskin].name);
 		else if (playernum == displayplayers[1])
@@ -1711,16 +2016,44 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		SetPlayerSkinByNum(playernum, skin);
 }
 
-void SendWeaponPref(UINT8 splitplayer)
+void SendWeaponPref(void)
 {
 	UINT8 buf[1];
 
 	buf[0] = 0;
-
-	if (cv_flipcam[splitplayer].value)
+	if (cv_flipcam[0].value)
 		buf[0] |= 1;
+	SendNetXCmdForPlayer(0, XD_WEAPONPREF, buf, 1);
+}
 
-	SendNetXCmdForPlayer(splitplayer, XD_WEAPONPREF, buf, 1);
+void SendWeaponPref2(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[1].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(1, XD_WEAPONPREF, buf, 1);
+}
+
+void SendWeaponPref3(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[2].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(2, XD_WEAPONPREF, buf, 1);
+}
+
+void SendWeaponPref4(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[3].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(3, XD_WEAPONPREF, buf, 1);
 }
 
 static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
@@ -1736,10 +2069,23 @@ static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
 		player->pflags |= PF_ANALOGMODE;
 }
 
-void D_SendPlayerConfig(UINT8 splitplayer)
+void D_SendPlayerConfig(void)
 {
-	SendNameAndColor(splitplayer);
-	SendWeaponPref(splitplayer);
+	SendNameAndColor();
+	if (splitscreen || botingame)
+		SendNameAndColor2();
+	if (splitscreen > 1)
+		SendNameAndColor3();
+	if (splitscreen > 2)
+		SendNameAndColor4();
+
+	SendWeaponPref();
+	if (splitscreen)
+		SendWeaponPref2();
+	if (splitscreen > 1)
+		SendWeaponPref3();
+	if (splitscreen > 2)
+		SendWeaponPref4();
 }
 
 // Only works for displayplayer, sorry!
@@ -1762,12 +2108,10 @@ INT32 D_LookupPlayer(const char *s)
 		return playernum;
 	}
 
-	const size_t len = strlen(s);
-
 	for (playernum = 0; playernum < MAXPLAYERS; ++playernum)
 	{
 		/* Match name case-insensitively: fully, or partially the start. */
-		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, len) == 0))
+		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, strlen(s)) == 0))
 		{
 			return playernum;
 		}
@@ -1807,15 +2151,13 @@ static void GetViewablePlayerPlaceRange(INT32 *first, INT32 *last)
 	(*last) = 0;
 
 	for (i = 0; i < MAXPLAYERS; ++i)
-	{
 		if (G_CouldView(i))
-		{
-			place = players[i].kartstuff[k_position];
-			if (place < (*first))
-				(*first) = place;
-			if (place > (*last))
-				(*last) = place;
-		}
+	{
+		place = players[i].kartstuff[k_position];
+		if (place < (*first))
+			(*first) = place;
+		if (place > (*last))
+			(*last) = place;
 	}
 }
 
@@ -2149,7 +2491,7 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pencoremode, boolean r
 				displayplayers[1] = 1;
 				playeringame[1] = true;
 				players[1].bot = 1;
-				SendNameAndColor(1);
+				SendNameAndColor2();
 			}
 		}
 
@@ -5426,54 +5768,50 @@ static void ForceSkin_OnChange(void)
 	}
 }
 
-// Allows the player's name to be changed if cv_mute is off.
+//Allows the player's name to be changed if cv_mute is off.
 static void Name_OnChange(void)
 {
 	if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
-		return;
 	}
-
-	SendNameAndColor(0);
+	else
+		SendNameAndColor();
 
 }
 
 static void Name2_OnChange(void)
 {
-	if (cv_mute.value) // Secondary player can't be admin.
+	if (cv_mute.value) //Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
-		return;
 	}
-
-	SendNameAndColor(1);
+	else
+		SendNameAndColor2();
 }
 
 static void Name3_OnChange(void)
 {
-	if (cv_mute.value) // Third player can't be admin.
+	if (cv_mute.value) //Third player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
-		return;
 	}
-
-	SendNameAndColor(2);
+	else
+		SendNameAndColor3();
 }
 
 static void Name4_OnChange(void)
 {
-	if (cv_mute.value) // Secondary player can't be admin.
+	if (cv_mute.value) //Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
-		return;
 	}
-
-	SendNameAndColor(3);
+	else
+		SendNameAndColor4();
 }
 
 /** Sends a skin change for the console player, unless that player is moving.
@@ -5495,7 +5833,7 @@ static void Skin_OnChange(void)
 	}
 
 	if (CanChangeSkin(consoleplayer) && !P_PlayerMoving(consoleplayer))
-		SendNameAndColor(0);
+		SendNameAndColor();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5516,7 +5854,7 @@ static void Skin2_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[1]) && !P_PlayerMoving(displayplayers[1]))
-		SendNameAndColor(1);
+		SendNameAndColor2();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5532,7 +5870,7 @@ static void Skin3_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[2]) && !P_PlayerMoving(displayplayers[2]))
-		SendNameAndColor(2);
+		SendNameAndColor3();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5548,7 +5886,7 @@ static void Skin4_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[3]) && !P_PlayerMoving(displayplayers[3]))
-		SendNameAndColor(3);
+		SendNameAndColor4();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5661,7 +5999,7 @@ static void Color_OnChange(void)
 	if (!P_PlayerMoving(consoleplayer))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(0);
+		SendNameAndColor();
 	}
 	else
 	{
@@ -5683,7 +6021,7 @@ static void Color2_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[1]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(1);
+		SendNameAndColor2();
 	}
 	else
 	{
@@ -5700,7 +6038,7 @@ static void Color3_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[2]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(2);
+		SendNameAndColor3();
 	}
 	else
 	{
@@ -5717,7 +6055,7 @@ static void Color4_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[3]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(3);
+		SendNameAndColor4();
 	}
 	else
 	{

src/d_netcmd.h

@@ -21,7 +21,10 @@ extern "C" {
 
 #include "command.h"
 
-void SendWeaponPref(UINT8 splitplayer);
+void SendWeaponPref(void);
+void SendWeaponPref2(void);
+void SendWeaponPref3(void);
+void SendWeaponPref4(void);
 
 // console vars
 extern consvar_t cv_playername;
@@ -292,7 +295,7 @@ typedef union {
 // add game commands, needs cleanup
 void D_RegisterServerCommands(void);
 void D_RegisterClientCommands(void);
-void D_SendPlayerConfig(UINT8 splitplayer);
+void D_SendPlayerConfig(void);
 void Command_ExitGame_f(void);
 void Command_Retry_f(void);
 void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore

src/d_netfil.c

@@ -960,7 +960,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download base-game file: \"%s\"", filename);
+		I_Error("Tried to download \"%s\"", filename);
 
 	if (filenum >= fileneedednum)
 	{
@@ -1019,21 +1019,21 @@ void Got_Filetxpak(void)
 
 		switch(file->status)
 		{
-			case FS_NOTFOUND:
-				s = "FS_NOTFOUND";
-				break;
-			case FS_FOUND:
-				s = "FS_FOUND";
-				break;
-			case FS_OPEN:
-				s = "FS_OPEN";
-				break;
-			case FS_MD5SUMBAD:
-				s = "FS_MD5SUMBAD";
-				break;
-			default:
-				s = "unknown";
-				break;
+		case FS_NOTFOUND:
+			s = "FS_NOTFOUND";
+			break;
+		case FS_FOUND:
+			s = "FS_FOUND";
+			break;
+		case FS_OPEN:
+			s = "FS_OPEN";
+			break;
+		case FS_MD5SUMBAD:
+			s = "FS_MD5SUMBAD";
+			break;
+		default:
+			s = "unknown";
+			break;
 		}
 
 		I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);

src/dedicated/i_system.c

@@ -984,7 +984,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }
 
-static volatile sig_atomic_t g_in_exiting_signal_handler = false;
+boolean g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1048,11 +1048,6 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }
 
-boolean I_In_Exiting_Signal_Handler(void)
-{
-	return g_in_exiting_signal_handler;
-}
-
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1072,17 +1067,11 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-static volatile sig_atomic_t interrupted = 0;
-
-boolean I_Interrupted(void)
+FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
 {
-	return interrupted;
-}
-
-static void quit_handler(int num)
-{
-	(void)num;
-	interrupted = 1;
+	signal(num, SIG_DFL); //default signal action
+	raise(num);
+	I_Quit();
 }
 
 #ifdef HAVE_LIBBACKTRACE
@@ -1384,7 +1373,6 @@ static void I_Fork(void)
 
 INT32 I_StartupSystem(void)
 {
-	W_Startup();
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to

src/dehacked.c

@@ -115,25 +115,20 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 	size_t i = 0;
 	if (myfeof(f))
 		return NULL;
-
 	// we need one byte for a null terminated string
 	bufsize--;
-
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
-
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
-
 		if (c == '\n')
 			break;
 	}
-
 	buf[i] = '\0';
 
 	dbg_line++;
@@ -143,31 +138,25 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 static char *myhashfgets(char *buf, size_t bufsize, MYFILE *f)
 {
 	size_t i = 0;
-
 	if (myfeof(f))
 		return NULL;
-
 	// we need one byte for a null terminated string
 	bufsize--;
-
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
-
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
-
 		if (c == '\n') // Ensure debug line is right...
 			dbg_line++;
-
 		if (c == '#')
 			break;
 	}
-
+	i++;
 	buf[i] = '\0';
 
 	return buf;
@@ -184,7 +173,7 @@ FUNCPRINTF static void deh_warning(const char *first, ...)
 	vsnprintf(buf, 1000, first, argptr); // sizeof only returned 4 here. it didn't like that pointer.
 	va_end(argptr);
 
-	if (dbg_line == -1) // Not in a SOC, line number unknown.
+	if(dbg_line == -1) // Not in a SOC, line number unknown.
 		CONS_Alert(CONS_WARNING, "%s\n", buf);
 	else
 		CONS_Alert(CONS_WARNING, "Line %u: %s\n", dbg_line, buf);
@@ -272,6 +261,7 @@ static void clear_levels(void)
 		// (no need to set num to 0, we're freeing the entire header shortly)
 		Z_Free(mapheaderinfo[i]->customopts);
 
+		P_DeleteGrades(i);
 		Z_Free(mapheaderinfo[i]);
 		mapheaderinfo[i] = NULL;
 	}
@@ -325,10 +315,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 					goto done;
 				PlayerMenu[num].status = IT_CALL;
 
-				// A friendly neighborhood alias for brevity's sake
-				const size_t note_size = sizeof(description[num].notes);
-
-				for (i = 0; i < (INT32)(MAXLINELEN-note_size-3); i++)
+				for (i = 0; i < MAXLINELEN-3; i++)
 				{
 					if (s[i] == '=')
 					{
@@ -336,12 +323,10 @@ static void readPlayer(MYFILE *f, INT32 num)
 						break;
 					}
 				}
-
 				if (playertext)
 				{
-					strlcpy(description[num].notes, playertext, note_size);
-					strlcat(description[num].notes,
-							myhashfgets(playertext, note_size, f), note_size);
+					strcpy(description[num].notes, playertext);
+					strcat(description[num].notes, myhashfgets(playertext, sizeof (description[num].notes), f));
 				}
 				else
 					strcpy(description[num].notes, "");
@@ -350,7 +335,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 				// It works down here, though.
 				{
 					INT32 numline = 0;
-					for (i = 0; (size_t)i < note_size-1; i++)
+					for (i = 0; (size_t)i < sizeof(description[num].notes)-1; i++)
 					{
 						if (numline < 20 && description[num].notes[i] == '\n')
 							numline++;
@@ -359,7 +344,6 @@ static void readPlayer(MYFILE *f, INT32 num)
 							break;
 					}
 				}
-
 				description[num].notes[strlen(description[num].notes)-1] = '\0';
 				description[num].notes[i] = '\0';
 				continue;
@@ -835,8 +819,22 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			// Now go to uppercase
 			strupr(word2);
 
+			// NiGHTS grades
+			if (fastncmp(word, "GRADES", 6))
+			{
+				UINT8 mare = (UINT8)atoi(word + 6);
+
+				if (mare <= 0 || mare > 8)
+				{
+					deh_warning("Level header %d: unknown word '%s'", num, word);
+					continue;
+				}
+
+				P_AddGradesForMare((INT16)(num-1), mare-1, word2);
+			}
+
 			// Strings that can be truncated
-			if (fastcmp(word, "SCRIPTNAME"))
+			else if (fastcmp(word, "SCRIPTNAME"))
 			{
 				deh_strlcpy(mapheaderinfo[num-1]->scriptname, word2,
 					sizeof(mapheaderinfo[num-1]->scriptname), va("Level header %d: scriptname", num));
@@ -848,6 +846,10 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			}
 			else if (fastcmp(word, "ACT"))
 			{
+				/*if (i >= 0 && i < 20) // 0 for no act number, TTL1 through TTL19
+					mapheaderinfo[num-1]->actnum = (UINT8)i;
+				else
+					deh_warning("Level header %d: invalid act number %d", num, i);*/
 				deh_strlcpy(mapheaderinfo[num-1]->actnum, word2,
 					sizeof(mapheaderinfo[num-1]->actnum), va("Level header %d: actnum", num));
 			}
@@ -912,7 +914,11 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 				mapheaderinfo[num-1]->mustrack = ((UINT16)i - 1);
 			else if (fastcmp(word, "MUSICPOS"))
 				mapheaderinfo[num-1]->muspos = (UINT32)get_number(word2);
-
+			else if (fastcmp(word, "MUSICINTERFADEOUT"))
+				mapheaderinfo[num-1]->musinterfadeout = (UINT32)get_number(word2);
+			else if (fastcmp(word, "MUSICINTER"))
+				deh_strlcpy(mapheaderinfo[num-1]->musintername, word2,
+					sizeof(mapheaderinfo[num-1]->musintername), va("Level header %d: intermission music", num));
 			else if (fastcmp(word, "FORCECHARACTER"))
 			{
 				strlcpy(mapheaderinfo[num-1]->forcecharacter, word2, SKINNAMESIZE+1);
@@ -954,12 +960,44 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			else if (fastcmp(word, "SKYBOXSCALEZ"))
 				mapheaderinfo[num-1]->skybox_scalez = (INT16)i;
 
+			else if (fastcmp(word, "BONUSTYPE"))
+			{
+				if      (fastcmp(word2, "NONE"))   i = -1;
+				else if (fastcmp(word2, "NORMAL")) i =  0;
+				else if (fastcmp(word2, "BOSS"))   i =  1;
+				else if (fastcmp(word2, "ERZ3"))   i =  2;
+
+				if (i >= -1 && i <= 2) // -1 for no bonus. Max is 2.
+					mapheaderinfo[num-1]->bonustype = (SINT8)i;
+				else
+					deh_warning("Level header %d: invalid bonus type number %d", num, i);
+			}
+
+			else if (fastcmp(word, "SAVEOVERRIDE"))
+			{
+				if      (fastcmp(word2, "DEFAULT")) i = SAVE_DEFAULT;
+				else if (fastcmp(word2, "ALWAYS"))  i = SAVE_ALWAYS;
+				else if (fastcmp(word2, "NEVER"))   i = SAVE_NEVER;
+
+				if (i >= SAVE_NEVER && i <= SAVE_ALWAYS)
+					mapheaderinfo[num-1]->saveoverride = (SINT8)i;
+				else
+					deh_warning("Level header %d: invalid save override number %d", num, i);
+			}
+
 			else if (fastcmp(word, "LEVELFLAGS"))
 				mapheaderinfo[num-1]->levelflags = get_number(word2);
 			else if (fastcmp(word, "MENUFLAGS"))
 				mapheaderinfo[num-1]->menuflags = get_number(word2);
 
 			// SRB2Kart
+			/*else if (fastcmp(word, "AUTOMAP"))
+			{
+				if (i || word2[0] == 'T' || word2[0] == 'Y')
+					mapheaderinfo[num-1]->automap = true;
+				else
+					mapheaderinfo[num-1]->automap = false;
+			}*/
 			else if (fastcmp(word, "MOBJSCALE"))
 				mapheaderinfo[num-1]->mobj_scale = get_number(word2);
 			else if (fastcmp(word, "LIGHTCONTRAST") || fastcmp(word, "ENCORELIGHTCONTRAST"))
@@ -1072,26 +1110,6 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 				else
 					mapheaderinfo[num-1]->menuflags &= ~LF2_NOVISITNEEDED;
 			}
-			else if (fastcmp(word, "MUSICINTERFADEOUT"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "MUSICINTER"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "BONUSTYPE"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "SAVEOVERRIDE"))
-			{
-				continue; // unused
-			}
-			else if (fastncmp(word, "GRADES", 6)) // NiGHTS grades
-			{
-				continue; // unused
-			}
 			else
 				deh_warning("Level header %d: unknown word '%s'", num, word);
 		}
@@ -1182,6 +1200,7 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
 			i = atoi(word2);
 			usi = (UINT16)i;
 
+
 			if (fastcmp(word, "NUMBEROFPICS"))
 			{
 				cutscenes[num]->scene[scenenum].numpics = (UINT8)i;
@@ -1862,8 +1881,16 @@ static void reademblemdata(MYFILE *f, INT32 num)
 					emblemlocations[num-1].type = ET_GLOBAL;
 				else if (fastcmp(word2, "SKIN"))
 					emblemlocations[num-1].type = ET_SKIN;
+				/*else if (fastcmp(word2, "SCORE"))
+					emblemlocations[num-1].type = ET_SCORE;*/
 				else if (fastcmp(word2, "TIME"))
 					emblemlocations[num-1].type = ET_TIME;
+				/*else if (fastcmp(word2, "RINGS"))
+					emblemlocations[num-1].type = ET_RINGS;
+				else if (fastcmp(word2, "NGRADE"))
+					emblemlocations[num-1].type = ET_NGRADE;
+				else if (fastcmp(word2, "NTIME"))
+					emblemlocations[num-1].type = ET_NTIME;*/
 				else
 					emblemlocations[num-1].type = (UINT8)value;
 			}
@@ -2152,11 +2179,14 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 	}
 	else if ((offset=0) || fastcmp(params[0], "GAMECLEAR")
 	||        (++offset && fastcmp(params[0], "ALLEMERALDS")))
+	//||        (++offset && fastcmp(params[0], "ULTIMATECLEAR")))
 	{
 		ty = UC_GAMECLEAR + offset;
 		re = (params[1]) ? atoi(params[1]) : 1;
 	}
 	else if ((offset=0) || fastcmp(params[0], "OVERALLTIME"))
+	//||        (++offset && fastcmp(params[0], "OVERALLSCORE"))
+	//||        (++offset && fastcmp(params[0], "OVERALLRINGS")))
 	{
 		PARAMCHECK(1);
 		ty = UC_OVERALLTIME + offset;
@@ -2165,6 +2195,8 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 	else if ((offset=0) || fastcmp(params[0], "MAPVISITED")
 	||        (++offset && fastcmp(params[0], "MAPBEATEN"))
 	||        (++offset && fastcmp(params[0], "MAPALLEMERALDS")))
+	//||        (++offset && fastcmp(params[0], "MAPULTIMATE"))
+	//||        (++offset && fastcmp(params[0], "MAPPERFECT")))
 	{
 		PARAMCHECK(1);
 		ty = UC_MAPVISITED + offset;
@@ -2182,6 +2214,8 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 		}
 	}
 	else if ((offset=0) || fastcmp(params[0], "MAPTIME"))
+	//||        (++offset && fastcmp(params[0], "MAPSCORE"))
+	//||        (++offset && fastcmp(params[0], "MAPRINGS")))
 	{
 		PARAMCHECK(2);
 		ty = UC_MAPTIME + offset;
@@ -2564,7 +2598,7 @@ static void readmaincfg(MYFILE *f)
 			}
 			else if (fastcmp(word, "MAXXTRALIFE"))
 			{
-				continue; // unused
+				maxXtraLife = (UINT8)get_number(word2);
 			}
 			else if (fastcmp(word, "GAMEDATA"))
 			{
@@ -2594,7 +2628,6 @@ static void readmaincfg(MYFILE *f)
 				strcatbf(savegamename, srb2home, PATHSEP);
 
 				refreshdirmenu |= REFRESHDIR_GAMEDATA;*/
-				continue;
 			}
 			else if (fastcmp(word, "RESETDATA"))
 			{
@@ -8512,7 +8545,7 @@ static inline int lib_action(lua_State *L)
 
 // Hardcoded A_Action name to call for super() or NULL if super() would be invalid.
 // Set in lua_infolib.
-const char *superactions[MAXRECURSION] = {};
+const char *superactions[MAXRECURSION];
 UINT8 superstack = 0;
 
 static int lib_dummysuper(lua_State *L)

src/dehacked.h

@@ -13,10 +13,6 @@
 #ifndef __DEHACKED_H__
 #define __DEHACKED_H__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "m_fixed.h" // for get_number
 #include "info.h"
 
@@ -75,9 +71,4 @@ typedef struct
 } MYFILE;
 #define myfeof(a) (a->data + a->size <= a->curpos)
 char *myfgets(char *buf, size_t bufsize, MYFILE *f);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

src/doomdef.h

@@ -516,6 +516,22 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);
 
+/* http://www.cse.yorku.ca/~oz/hash.html */
+static inline
+UINT32 quickncasehash (const char *p, size_t n)
+{
+	size_t i = 0;
+	UINT32 x = 5381;
+
+	while (i < n && p[i])
+	{
+		x = (x * 33) ^ tolower(p[i]);
+		i++;
+	}
+
+	return x;
+}
+
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))

src/doomstat.h

@@ -205,6 +205,12 @@ extern struct quake
 	fixed_t radius, intensity;
 } quake;
 
+// NiGHTS grades
+typedef struct
+{
+	UINT32 grade[6]; // D, C, B, A, S, X (F: failed to reach any of these)
+} nightsgrades_t;
+
 // Custom Lua values
 // (This is not ifdeffed so the map header structure can stay identical, just in case.)
 typedef struct
@@ -255,16 +261,28 @@ typedef struct
 	UINT8 numlaps;        ///< Number of laps in circuit mode, unless overridden.
 	SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no.
 	UINT8 levelselect;    ///< Is this map available in the level select? If so, which map list is it available in?
+	SINT8 bonustype;      ///< What type of bonus does this level have? (-1 for null.)
+	SINT8 saveoverride;   ///< Set how the game is allowed to save (1 for always, -1 for never, 0 is 2.1 default)
+
 	UINT8 levelflags;     ///< LF_flags:  merged eight booleans into one UINT8 for space, see below
 	UINT8 menuflags;      ///< LF2_flags: options that affect record attack / nights mode menus
 
+	// NiGHTS stuff.
+	UINT8 numGradedMares;   ///< Internal. For grade support.
+	nightsgrades_t *grades; ///< NiGHTS grades. Allocated dynamically for space reasons. Be careful.
+
 	// SRB2kart
+	//boolean automap;    ///< Displays a level's white map outline in modified games
 	fixed_t mobj_scale;   ///< Replacement for TOL_ERZ3
 
 	mapheader_lighting_t lighting;			///< Wall and sprite lighting
 	mapheader_lighting_t lighting_encore;	///< Alternative lighting for Encore mode
 	boolean use_encore_lighting;			///< Whether to use separate Encore lighting
 
+	// Music stuff.
+	UINT32 musinterfadeout;  ///< Fade out level music on intermission screen in milliseconds
+	char musintername[7];    ///< Intermission screen music.
+
 	// Lua stuff.
 	// (This is not ifdeffed so the map header structure can stay identical, just in case.)
 	UINT8 numCustomOptions;     ///< Internal. For Lua custom value support.
@@ -361,6 +379,8 @@ typedef struct
 {
 	tic_t time; ///< Time in which the level was finished.
 	tic_t lap;  ///< Best lap time for this level.
+	//UINT32 score; ///< Score when the level was finished.
+	//UINT16 rings; ///< Rings when the level was finished.
 } recorddata_t;
 
 /** Setup for one NiGHTS map.
@@ -374,19 +394,34 @@ typedef struct
 #define GRADE_A 5
 #define GRADE_S 6
 
+/*typedef struct
+{
+	// 8 mares, 1 overall (0)
+	UINT8	nummares;
+	UINT32	score[9];
+	UINT8	grade[9];
+	tic_t	time[9];
+} nightsdata_t;*/
+
+//extern nightsdata_t *nightsrecords[NUMMAPS];
 extern recorddata_t *mainrecords[NUMMAPS];
 
 // mapvisited is now a set of flags that says what we've done in the map.
 #define MV_VISITED     1
 #define MV_BEATEN      2
 #define MV_ALLEMERALDS 4
+//#define MV_ULTIMATE     8
+//#define MV_PERFECT     16
 #define MV_MAX         7 // used in gamedata check
 extern UINT8 mapvisited[NUMMAPS];
 
-extern UINT32 token;     ///< Number of tokens collected in a level
+// Temporary holding place for nights data for the current map
+//nightsdata_t ntemprecords;
+
+extern UINT32 token; ///< Number of tokens collected in a level
 extern UINT32 tokenlist; ///< List of tokens collected
-extern INT32  tokenbits; ///< Used for setting token bits
-extern INT32  sstimer;   ///< Time allotted in the special stage
+extern INT32 tokenbits; ///< Used for setting token bits
+extern INT32 sstimer; ///< Time allotted in the special stage
 extern UINT32 bluescore; ///< Blue Team Scores
 extern UINT32 redscore;  ///< Red Team Scores
 
@@ -426,6 +461,7 @@ extern UINT8 introtoplay;
 extern UINT8 creditscutscene;
 
 extern UINT8 use1upSound;
+extern UINT8 maxXtraLife; // Max extra lives from rings
 
 extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations
 

src/doomtype.h

@@ -68,21 +68,8 @@ extern "C" {
 	#define strnicmp(x,y,n) strncasecmp(x,y,n)
 #endif
 
-// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
-// to not cause warnings or compile issues on older glibc versions we do this silly thing
-// to not have a gazillion glibc version checks
-#if defined(__GLIBC_PREREQ)
-#if __GLIBC_PREREQ(2, 43)
-	#define gconst const
-#else
-	#define gconst
-#endif
-#else
-	#define gconst
-#endif
-
-#ifndef _GNU_SOURCE
 char *nongnu_strcasestr(const char *in, const char *what);
+#ifndef _GNU_SOURCE
 #define strcasestr nongnu_strcasestr
 #endif
 
@@ -140,9 +127,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)
 
 /* Boolean type definition */
-#include <stdbool.h>
 
 #ifndef _WIN32
+#include <stdbool.h>
 // dont use stdbools _BOOL type
 // its smaller (1 byte) than the old interger bool (4 bytes)
 // which results in packed struct sizes being mismatched between vanilla and this
@@ -150,7 +137,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 // which we cant use as enumeration constants
 typedef int32_t boolean;
 #else
-#define boolean int32_t
+#define false FALSE
+#define true TRUE
+#define boolean BOOL
 #endif
 
 /* 7.18.2.1  Limits of exact-width integer types */

src/f_wipe.c

@@ -361,11 +361,6 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 	// on for fade-to-black
 	for (;;)
 	{
-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		// get fademask first so we can tell if it exists or not
 		fmask = F_GetFadeMask(wipetype, wipeframe++);
 

src/g_demo.c

@@ -2616,7 +2616,7 @@ void G_DoPlayDemo(char *defdemoname)
 	if (defdemoname == NULL)
 	{
 		demobuf.p = demobuf.buffer;
-		pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed
+		pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed
 	}
 	else
 	{
@@ -2628,7 +2628,7 @@ void G_DoPlayDemo(char *defdemoname)
 			n++;
 
 		pdemoname = ZZ_Alloc(strlen(n)+1);
-		strcpy(pdemoname, n);
+		strcpy(pdemoname,n);
 
 		M_SetPlaybackMenuPointer();
 
@@ -3090,9 +3090,6 @@ post_compat:
 	if (cv_director.value)
 		CV_SetValue(&cv_director, 0);
 
-	if (demo.timing)
-		G_DoneLevelLoad();
-
 	demo.deferstart = true;
 }
 #undef SKIPERRORS

src/g_game.c

@@ -69,6 +69,9 @@ UINT8 botcolor = 0;
 
 JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
 
+// 1024 bytes is plenty for a savegame
+#define SAVEGAMESIZE (1024)
+
 // SRB2kart
 char gamedatafilename[64] = "kartdata.dat";
 char timeattackfolder[64] = "kart";
@@ -97,6 +100,7 @@ boolean savemoddata = false;
 UINT8 paused = 0;
 UINT8 modeattacking = ATTACKING_NONE;
 boolean imcontinuing = false;
+boolean runemeraldmanager = false;
 
 boolean netgame = false; // only true if packets are broadcast
 boolean multiplayer = false;
@@ -209,6 +213,7 @@ const INT32 wantedfrequency = 10*TICRATE;
 INT32 gameovertics = 15*TICRATE;
 
 UINT8 use1upSound = 0;
+UINT8 maxXtraLife = 2; // Max extra lives from rings
 
 UINT8 introtoplay = 0;
 UINT8 creditscutscene = 0;
@@ -3897,7 +3902,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
+		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -4148,7 +4153,6 @@ static void measurekeywords(mapsearchfreq_t *fr,
 {
 	char *qp;
 	char *sp;
-
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4163,12 +4167,10 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
-
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
-
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);

src/hardware/hw_cache.cpp

@@ -15,6 +15,8 @@
 
 #ifdef HWRENDER
 
+#include <unordered_set>
+
 #include "hw_main.h"
 #include "hw_glob.h"
 #include "hw_gl.h"
@@ -98,7 +100,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
 			position = 0;
 		}
 
-		position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
+		position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
 
 		if (position + count >= pblockheight)
 			count = pblockheight - position;
@@ -162,7 +164,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -212,7 +214,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -288,7 +290,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	INT32 blocksize = (glMipmap->width * glMipmap->height);
 
 	bpp = format2bpp(glMipmap->format);
-	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
+	block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
 
 	switch (bpp)
 	{
@@ -325,7 +327,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];
 
 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
+	gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
 
 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -344,7 +346,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif
 
-	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
 	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -377,7 +379,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
+		pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;
 
 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -413,7 +415,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;
 
 		// setup the texture info
-		glMipmap->format = (GLTextureFormat_t)(patchformat);
+		glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
 
 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -455,7 +457,7 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;
 
-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
@@ -471,7 +473,7 @@ void HWR_FreeTexture(patch_t *patch)
 
 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+		GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 		HWR_FreeTextureColormaps(patch);
 
@@ -497,7 +499,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;
 
-	pat = (GLPatch_t *)(patch->hardware);
+	pat = static_cast<GLPatch_t *>(patch->hardware);
 	if (!pat)
 		return;
 
@@ -612,20 +614,24 @@ void HWR_FreeMapTextures(void)
 	gl_numtextures = 0;
 }
 
-#define NAME    flatcheck
-#define KEY_TY  UINT32
-#define HASH_FN vt_hash_integer
-#define CMPR_FN vt_cmpr_integer
-#include "../verstable.h"
-
 static void HWR_PrecacheLevelFlats(void)
 {
 	// lookup for flats that may´ve been already loaded
-	flatcheck flatpresent;
-	flatcheck_init(&flatpresent);
+	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
+	std::unordered_set<UINT32> flatpresent;
 	size_t i, j;
 	INT32 k;
 
+	auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
+	{
+		// flat already loaded?
+		if (flatpresent.count(lump) == 0)
+		{
+			HWR_GetFlat(lump, noencoremap);
+			flatpresent.insert(lump);
+		}
+	};
+
 	// special case for encore
 #ifdef GLENCORE
 	if (encoremap)
@@ -643,23 +649,14 @@ static void HWR_PrecacheLevelFlats(void)
 
 				const levelflat_t *levelflat = &levelflats[pic];
 
-				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-				{
-					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
-					flatcheck_insert(&flatpresent, levelflat->lumpnum);
-				}
+				load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
 
 				if (levelflat->speed) // is it an animated flat ?
 				{
 					// start from 0, occasionally basenumlump != flat->lumpnum
 					for (k = 0; k < levelflat->numpics; k++)
 					{
-						lumpnum_t lump = levelflat->baselumpnum + k;
-						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-						{
-							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
-							flatcheck_insert(&flatpresent, lump);
-						}
+						load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
 					}
 				}
 			}
@@ -674,29 +671,18 @@ static void HWR_PrecacheLevelFlats(void)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
 
-			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-			{
-				HWR_GetFlat(levelflat->lumpnum, false);
-				flatcheck_insert(&flatpresent, levelflat->lumpnum);
-			}
+			load_flat(levelflat->lumpnum, false);
 
 			if (levelflat->speed) // is it an animated flat ?
 			{
 				// start from 0, occasionally basenumlump != flat->lumpnum
 				for (k = 0; k < levelflat->numpics; k++)
 				{
-					lumpnum_t lump = levelflat->baselumpnum + k;
-					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-					{
-						HWR_GetFlat(lump, false);
-						flatcheck_insert(&flatpresent, lump);
-					}
+					load_flat(levelflat->baselumpnum + k, false);
 				}
 			}
 		}
 	}
-
-	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -706,7 +692,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;
 
-	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
+	texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
 
@@ -881,7 +867,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();
 
 	gl_numtextures = pnumtextures;
-	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
+	gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
 
 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -978,7 +964,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
 
 #ifdef GLENCORE
-	flat = (UINT8 *)(glMipmap->data);
+	flat = static_cast<UINT8 *>(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1022,7 +1008,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+		glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
 		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
@@ -1046,7 +1032,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	if (!glMipmap->downloaded)
 	{
@@ -1067,7 +1053,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 	HWR_MakePatch(patch, glPatch, glMipmap, true);
 
 	// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1103,7 +1089,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 
 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1139,12 +1125,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 	//              (it have a liste of mipmap)
 	//    this malloc is cleared in HWR_FreeColormapCache
 	//    (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
-	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
+	newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;
 
-	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
 	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -1167,7 +1153,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 	{
 		void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
 		Patch_Create(NULL, 0, ptr);
-		Patch_AllocateHardwarePatch((patch_t *)(ptr));
+		Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
 	}
 
 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1184,7 +1170,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1340,7 +1326,7 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = (UINT8 *)(Z_Malloc(
+	UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
 		HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
 		PU_STATIC, NULL));
 #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1385,7 +1371,7 @@ void HWR_SetMapPalette(void)
 		if (palsize < 768) // 256 * 3
 			I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
 
-		RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
+		RGB_data = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
 		// we got the RGB palette now, but we need it in RGBA format.
 		for (i = 0; i < 256; i++)
 		{
@@ -1420,7 +1406,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
+	RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
 
 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.

src/hardware/hw_data.h

@@ -54,7 +54,7 @@ struct GLMipmap_s
 	UINT16					width, height;
 	UINT32					downloaded; // The GPU has this texture.
 
-	struct GLMipmap_s		*nextcolormap;
+	struct	GLMipmap_s		*nextcolormap;
 	struct GLColormap_s		*colormap;
 };
 typedef struct GLMipmap_s GLMipmap_t;

src/hardware/hw_defs.h

@@ -110,7 +110,7 @@ typedef struct
 typedef struct
 {
 	poly_t *planepoly;  // the generated convex polygon
-} poly_subsector_t;
+} extrasubsector_t;
 
 // Vanilla features
 //#define USE_MODEL_NEXTFRAME

src/hardware/hw_draw.c

@@ -222,7 +222,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf = {};
+		FSurfaceInfo Surf;
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -385,7 +385,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 	// clip it since it is used for bunny scroll in doom I
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf = {};
+		FSurfaceInfo Surf;
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -490,7 +490,7 @@ void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
 void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
 
 	v[0].x = v[3].x = -1.0f;
@@ -543,7 +543,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 void HWR_DrawConsoleBack(UINT32 color, INT32 height)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	// setup some neat-o translucency effect
 	if (!height) //cool hack 0 height is full height
@@ -598,7 +598,7 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
 void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh, fwait = 0;
 	RGBA_t *palette;
 
@@ -702,7 +702,7 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)
@@ -820,7 +820,7 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
 void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)

src/hardware/hw_glob.h

@@ -52,12 +52,12 @@ void HWR_ObjectLightLevelPost(gl_vissprite_t *spr, const sector_t *sector, INT32
 // --------
 // hw_bsp.c
 // --------
-extern poly_subsector_t *poly_subsectors;
+extern extrasubsector_t *extrasubsectors;
 #ifdef PARANOIA
-extern size_t num_poly_subsector;
+extern size_t addsubsector;
 #endif
-void HWR_InitPolyPool(void);
-void HWR_FreePolyPool(void);
+
+void HWR_FreeExtraSubsectors(void);
 
 // --------
 // hw_cache.c

src/hardware/hw_main.cpp

@@ -125,7 +125,7 @@ ps_metric_t ps_hw_batchdrawtime = {};
 static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags);
 static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
 
-static void HWR_AddTransparentFloor(lumpnum_t lumpnum, poly_subsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
+static 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);
 static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
 static void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
 
@@ -231,17 +231,6 @@ consvar_t cv_glanisotropicmode = {"gr_anisotropicmode", "1", CV_CALL|CV_SAVE, gl
 
 consvar_t cv_glsolvetjoin = {"gr_solvetjoin", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_glpolytile = {"gr_polytile", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-
-CV_PossibleValue_t grpolyshape_cons_t[] = {
-	{0, "Subsector"},
-	{1, "Fat"},
-	{2, "Trim"},
-	{3, "NotConvex"},
-	{0, NULL}
-};
-consvar_t cv_glpolyshape = {"gr_polygon_shape", "Trim", CV_SAVE, grpolyshape_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-
 consvar_t cv_glbatching = {"gr_batching", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_glwireframe = {"gr_wireframe", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -253,6 +242,7 @@ consvar_t cv_glportals = {"gr_portals", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,
 
 consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_glflashpal = {"gr_flashpal", "On", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
@@ -559,9 +549,9 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
 
 // HWR_RenderPlane
 // Render a floor or ceiling convex polygon
-static void HWR_RenderPlane(subsector_t *subsector, poly_subsector_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 = {};
+	FSurfaceInfo Surf;
 	FOutVector *v3d;
 	polyvertex_t *pv;
 	pslope_t *slope = NULL;
@@ -1386,7 +1376,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	extracolormap_t *colormap = gl_frontsector->extra_colormap;
 	lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap);
 
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	Surf.PolyColor.s.alpha = 255;
 
@@ -2685,7 +2675,7 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	float           scrollx = 0.0f, scrolly = 0.0f;
 	float           anglef  = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
 	angle_t         angle = 0;
-	FSurfaceInfo    Surf = {};
+	FSurfaceInfo    Surf;
 	fixed_t         tempxsow, tempytow;
 	size_t          nrPlaneVerts;
 
@@ -2832,7 +2822,7 @@ static void HWR_AddPolyObjectPlanes(void)
 	sector_t *polyobjsector;
 	INT32 light = 0;
 
-	// Polyobject Planes need their own function for drawing because they don't have poly_subsectors by themselves
+	// Polyobject Planes need their own function for drawing because they don't have extrasubsectors by themselves
 	// It should be okay because polyobjects should always be convex anyway
 
 	for (i = 0; i < numpolys; i++)
@@ -2852,8 +2842,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2874,8 +2865,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2960,9 +2952,9 @@ static void HWR_Subsector(size_t num)
 	ffloor_t *rover;
 
 #ifdef PARANOIA // no risk while developing, enough debugging nights!
-	if (num >= num_poly_subsector)
+	if (num >= addsubsector)
 		I_Error("HWR_Subsector: ss %s with numss = %s, addss = %s\n",
-			sizeu1(num), sizeu2(numsubsectors), sizeu3(num_poly_subsector));
+			sizeu1(num), sizeu2(numsubsectors), sizeu3(addsubsector));
 #endif
 
 	if (num < numsubsectors)
@@ -3057,7 +3049,7 @@ static void HWR_Subsector(size_t num)
 			if (sub->validcount != validcount)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false));
-				HWR_RenderPlane(sub, &poly_subsectors[num], false,
+				HWR_RenderPlane(sub, &extrasubsectors[num], false,
 					gl_frontsector->floorheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap);
@@ -3072,7 +3064,7 @@ static void HWR_Subsector(size_t num)
 			if (sub->validcount != validcount)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true));
-				HWR_RenderPlane(sub, &poly_subsectors[num], true,
+				HWR_RenderPlane(sub, &extrasubsectors[num], true,
 					gl_frontsector->ceilingheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap);
@@ -3119,7 +3111,7 @@ static void HWR_Subsector(size_t num)
 					alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
 
 					HWR_AddTransparentFloor(0,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											false,
 											*rover->bottomheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3131,7 +3123,7 @@ static void HWR_Subsector(size_t num)
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < bottomCullHeight));
 
 					HWR_AddTransparentFloor(levelflats[*rover->bottompic].lumpnum,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											false,
 											*rover->bottomheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3143,7 +3135,7 @@ static void HWR_Subsector(size_t num)
 					HWR_GetFlat(levelflats[*rover->bottompic].lumpnum, R_NoEncore(gl_frontsector, false));
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < bottomCullHeight));
 
-					HWR_RenderPlane(sub, &poly_subsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->bottompic].lumpnum,
+					HWR_RenderPlane(sub, &extrasubsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->bottompic].lumpnum,
 									rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
 				}
 			}
@@ -3165,7 +3157,7 @@ static void HWR_Subsector(size_t num)
 					alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
 
 					HWR_AddTransparentFloor(0,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											true,
 											*rover->topheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3177,7 +3169,7 @@ static void HWR_Subsector(size_t num)
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < topCullHeight));
 
 					HWR_AddTransparentFloor(levelflats[*rover->toppic].lumpnum,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											true,
 											*rover->topheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3189,7 +3181,7 @@ static void HWR_Subsector(size_t num)
 					HWR_GetFlat(levelflats[*rover->toppic].lumpnum, R_NoEncore(gl_frontsector, true));
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < topCullHeight));
 
-					HWR_RenderPlane(sub, &poly_subsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->toppic].lumpnum,
+					HWR_RenderPlane(sub, &extrasubsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->toppic].lumpnum,
 									rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
 				}
 			}
@@ -3427,7 +3419,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 {
 	float this_scale = 1.0f;
 	FOutVector swallVerts[4];
-	FSurfaceInfo sSurf = {};
+	FSurfaceInfo sSurf;
 	FBITFIELD blendmode = 0;
 	fixed_t floorheight, mobjfloor;
 	pslope_t *floorslope;
@@ -3663,7 +3655,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	FOutVector baseWallVerts[4]; // This is what the verts should end up as
 	patch_t *gpatch;
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	extracolormap_t *colormap;
 	INT32 lightlevel;
 	boolean lightset = true;
@@ -3692,7 +3684,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// Draw shadow BEFORE sprite
 	if (UNLIKELY(cv_shadow.value // Shadows enabled
@@ -3794,10 +3786,10 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	{
 		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
 		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
 
 		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
 	}
 
 	if (HWR_UseShader())
@@ -3948,7 +3940,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FBITFIELD blend = 0;
 
 	INT32 shader = SHADER_NONE;
@@ -3980,7 +3972,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// create the sprite billboard
 	//
@@ -4091,10 +4083,10 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	{
 		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
 		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
 
 		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
 	}
 
 	if (HWR_UseShader())
@@ -4113,7 +4105,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	INT32 shader = SHADER_NONE;
 
@@ -4130,7 +4122,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// create the sprite billboard
 	//
@@ -4270,7 +4262,7 @@ typedef struct
 
 typedef struct
 {
-	poly_subsector_t *xsub;
+	extrasubsector_t *xsub;
 	boolean isceiling;
 	fixed_t fixedheight;
 	INT32 lightlevel;
@@ -4354,7 +4346,7 @@ static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, I
 	wallinfo->wallcolormap = wallcolormap;
 }
 
-static void HWR_AddTransparentFloor(lumpnum_t lumpnum, poly_subsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap)
+static 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)
 {
 	planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE));
 
@@ -4521,6 +4513,7 @@ static void HWR_RenderDrawNodes(void)
 	drawnodes.clear(); // clear so our size is 0 again!
 }
 
+
 // --------------------------------------------------------------------------
 //  Draw all vissprites
 // --------------------------------------------------------------------------
@@ -4857,7 +4850,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		flip = sprframe->flip; // Will only be 0x00 or 0xFF
 
 		if (papersprite && ang < ANGLE_180)
-			flip ^= 0xFF;
+			flip ^= 0xFFFF;
 	}
 	else
 	{
@@ -5824,7 +5817,6 @@ void HWR_RenderPlayerView(void)
 
 void HWR_LoadLevel(void)
 {
-	HWR_FreePolyPool();
 	HWR_CreatePlanePolygons((INT32)numnodes - 1);
 
 	// Build the sky dome
@@ -5909,8 +5901,6 @@ void HWR_AddCommands(void)
 	CV_RegisterVar(&cv_glanisotropicmode);
 
 	CV_RegisterVar(&cv_glsolvetjoin);
-	CV_RegisterVar(&cv_glpolytile);
-	CV_RegisterVar(&cv_glpolyshape);
 
 	CV_RegisterVar(&cv_glbatching);
 
@@ -5923,6 +5913,7 @@ void HWR_AddCommands(void)
 
 	CV_RegisterVar(&cv_glpaletterendering);
 	CV_RegisterVar(&cv_glpalettedepth);
+	CV_RegisterVar(&cv_glflashpal);
 }
 
 // --------------------------------------------------------------------------
@@ -5938,7 +5929,6 @@ void HWR_Startup(void)
 		CONS_Printf("HWR_Startup()...\n");
 		textureformat = patchformat = GL_TEXFMT_RGBA;
 
-		HWR_InitPolyPool();
 		HWR_InitMapTextures();
 		HWR_InitMD2();
 
@@ -6030,7 +6020,7 @@ static void COM_HWR_glinfo(void)
 void HWR_Shutdown(void)
 {
 	CONS_Printf("HWR_Shutdown()\n");
-	HWR_FreePolyPool();
+	HWR_FreeExtraSubsectors();
 	HWR_FreeMapTextures();
 	GL_FlushScreenTextures();
 	HWR_ClearAllTextures();
@@ -6080,7 +6070,7 @@ static void HWR_DoPostProcessor(void)
 {
 	// Armageddon Blast Flash!
 	// Could this even be considered postprocessor?
-	if (!HWR_ShouldUsePaletteRendering())
+	if (!HWR_PalRenderFlashpal())
 	{
 		const player_t *player = &players[displayplayers[viewssnum]];
 
@@ -6093,7 +6083,7 @@ static void HWR_DoPostProcessor(void)
 				{-4.0f, -4.0f, 4.0f, 0.0f, 0.0f}
 			};
 
-			FSurfaceInfo Surf = {};
+			FSurfaceInfo Surf;
 
 			// This won't change if the flash palettes are changed unfortunately, but it works for its purpose
 			if (player->flashpal == PAL_NUKE)

src/hardware/hw_main.h

@@ -195,7 +195,7 @@ extern consvar_t cv_gllightdither;
 extern consvar_t cv_glfiltermode;
 extern consvar_t cv_glanisotropicmode;
 
-extern consvar_t cv_glsolvetjoin, cv_glpolytile, cv_glpolyshape;
+extern consvar_t cv_glsolvetjoin;
 
 extern consvar_t cv_glbatching;
 
@@ -208,6 +208,7 @@ extern consvar_t cv_glportals;
 
 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
+extern consvar_t cv_glflashpal;
 
 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -219,6 +220,11 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }
 
+FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
+{
+	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
+}
+
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {

src/hardware/hw_md2.c

@@ -1099,7 +1099,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	INT32 frame = 0;
 	INT32 nextFrame = -1;
 	FTransform p;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	if (!cv_glmdls.value || spr->precip)
 		return;
@@ -1336,8 +1336,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		if (spr->mobj->frame & FF_ANIMATE)
 		{
 			// set duration and tics to be the correct values for FF_ANIMATE states
-			durs = spr->mobj->state->var2;
-			tics = (INT32)spr->mobj->anim_duration;
+			durs = (float)spr->mobj->state->var2;
+			tics = (float)spr->mobj->anim_duration;
 		}
 
 		//FIXME: this is not yet correct
@@ -1475,7 +1475,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	patch_t *gpatch, *blendgpatch;
 	GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
 	FTransform p;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	if (!md2->model)
 	{
@@ -1526,6 +1526,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	if (blendgpatch)
 		hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
 
+	memset(&Surf, 0x00, sizeof(FSurfaceInfo));
 	Surf.PolyColor.rgba = 0xFFFFFFFF;
 	Surf.PolyFlags = PF_Occlude | PF_Modulated;
 

src/hardware/hw_shaders.c

@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	gconst char *location = strstr(str1, str2);
+	char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else

src/hardware/r_opengl/r_opengl.c

@@ -1383,19 +1383,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	gconst GLubyte *where, *terminator;
+	GLubyte         *where, *terminator;
 
 	if (!extension || !start)
 		return 0;
 
-	where = (gconst GLubyte *)strchr(extension, ' ');
+	where = (GLubyte *) strchr(extension, ' ');
 
 	if (where || *extension == '\0')
 		return 0;
 
 	for (;;)
 	{
-		where = (gconst GLubyte *)strstr((const char *)start, extension);
+		where = (GLubyte *) strstr((const char *) start, extension);
 
 		if (!where)
 			break;

src/http-mserv.c

@@ -318,7 +318,6 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
-	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }

src/hu_stuff.c

@@ -97,6 +97,7 @@ static textinput_t w_chat;
 static boolean headsupactive = false;
 boolean hu_showscores = false; // draw rankings
 static char hu_tick;
+static tic_t hu_emoteanim = 0;
 emote_autocomplete_t emote_autocomplete = {0};
 
 static huddrawlist_h luahuddrawlist_scores = NULL;
@@ -906,7 +907,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 	target = READSINT8(*p);
 	flags = READUINT8(*p);
 	msg = buf;
-	READSTRINGN(*p, msg, HU_MAXMSGLEN + 1);
+	READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);
 
 	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
 	{
@@ -1094,6 +1095,7 @@ void HU_Ticker(void)
 		return;
 
 	hu_tick++;
+	hu_emoteanim++;
 	hu_tick &= 7; // currently only to blink chat input cursor
 
 	if (PLAYER1INPUTDOWN(gc_scores))
@@ -1808,7 +1810,6 @@ static void HU_DrawChat(void)
 	INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
 	UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
 	INT32 cflag = 0;
-	INT32 pm_offset = 0; // for cases when you type emote while also doing /pm
 	size_t select_start = 0, select_end = 0;
 	const char *ntalk = "Say: ", *ttalk = "Team: ";
 	const char *talk = ntalk;
@@ -1920,6 +1921,64 @@ static void HU_DrawChat(void)
 		}
 	}
 
+	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
+	{
+		emote_t *suggest;
+		int skip = 0;
+
+		const char *complete;
+		int complete_len;
+
+		if (emote_autocomplete.complete[0])
+		{
+			complete = emote_autocomplete.complete;
+			complete_len = strlen(complete);
+		}
+		else
+		{
+			complete = &w_chat_buf[emote_autocomplete.emotestart];
+			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
+		}
+
+		// A bit of copy-paste from /pm code :p
+		INT32 suggesty = chaty - charheight - 1;
+		size_t longest_suggestion_length = 0;
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
+			++skip;
+		}
+
+		skip = 0;
+
+#ifdef NETSPLITSCREEN
+		if (splitscreen)
+		{
+			suggesty -= BASEVIDHEIGHT/2;
+			if (splitscreen > 1)
+				suggesty += 16;
+		}
+		else
+#endif
+			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*skip), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			// Highlight currently suggested emote
+			int hlflag = 0;
+			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
+				hlflag = V_YELLOWMAP;
+
+			V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
+			M_DrawEmote(chatx + boxw + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			++skip;
+		}
+	}
+
 	// handle /pm list. It's messy, horrible and I don't care.
 	if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
 	{
@@ -2000,74 +2059,9 @@ static void HU_DrawChat(void)
 
 		if (count == 0) // no results.
 		{
-			pm_offset = 48 + 2;
 			V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
 			V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
 		}
-		else
-		{
-			pm_offset = (longest_name_length+4)*4 + 2;
-		}
-	}
-
-	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
-	{
-		emote_t *suggest;
-		int skip = 0;
-
-		const char *complete;
-		int complete_len;
-
-		if (emote_autocomplete.complete[0])
-		{
-			complete = emote_autocomplete.complete;
-			complete_len = strlen(complete);
-		}
-		else
-		{
-			complete = &w_chat_buf[emote_autocomplete.emotestart];
-			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
-		}
-
-		// A bit of copy-paste from /pm code :p
-		INT32 suggesty = chaty - charheight - 1;
-		size_t longest_suggestion_length = 0;
-
-		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
-		{
-			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
-			++skip;
-		}
-
-		INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
-
-		skip = 0;
-
-#ifdef NETSPLITSCREEN
-		if (splitscreen)
-		{
-			suggesty -= BASEVIDHEIGHT/2;
-			if (splitscreen > 1)
-				suggesty += 16;
-		}
-		else
-#endif
-			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
-
-		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
-		{
-			V_DrawFillConsoleMap(chatx + boxw + pm_offset + 2, suggesty - (7*skip), emote_suggest_boxw, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-
-			// Highlight currently suggested emote
-			int hlflag = 0;
-			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
-				hlflag = V_YELLOWMAP;
-
-			V_DrawSmallString(chatx + boxw + pm_offset + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
-			M_DrawEmote(chatx + boxw + pm_offset + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-
-			++skip;
-		}
 	}
 
 	HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.

src/i_system.h

@@ -43,7 +43,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;
 
 /** \brief Set to true when inside a signal handler that will exit the program. */
-boolean I_In_Exiting_Signal_Handler(void);
+extern boolean g_in_exiting_signal_handler;
 
 /**	\brief	The I_GetFreeMem function
 
@@ -195,10 +195,6 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);
 
-/**	\brief To check if a Interrupt or Terminate Signal was fired
- */
-boolean I_Interrupted(void);
-
 /**	\brief	The I_GetDiskFreeSpace function
 
 	\param	freespace	a INT64 pointer to hold the free space amount

src/i_tcp.c

@@ -496,10 +496,8 @@ static void cleanupnodes(void)
 
 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
-	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
-	}
 }
 
 static SINT8 getfreenode(void)
@@ -509,13 +507,11 @@ static SINT8 getfreenode(void)
 	cleanupnodes();
 
 	for (j = 0; j < MAXNETNODES; j++)
-	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
-	}
 
 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -816,7 +812,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (numnode <= 0 || numnode > MAXNETNODES)
+	if (!numnode || numnode > MAXNETNODES)
 		return;
 
 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1436,12 +1432,14 @@ static void SOCK_RegisterHolePunch(void)
 
 static boolean SOCK_OpenSocket(void)
 {
-	memset(clientaddress, 0, sizeof(clientaddress));
+	size_t i;
+
+	memset(clientaddress, 0, sizeof (clientaddress));
 
-	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
+	for (i = 1; i < MAXNETNODES; i++)
+		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
-
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1481,7 +1479,7 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;
 
-	if (node < 0 || node > MAXNETNODES)
+	if (node > MAXNETNODES)
 		return false;
 
 	ban = numbans;

src/k_hud.c

@@ -931,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
 
 //}
 
-static INT32 ITEM_X, ITEM_Y;	// Item Window
-static INT32 TIME_X, TIME_Y;	// Time Sticker
-static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-static INT32 SPDM_X, SPDM_Y;	// Speedometer
-static INT32 POSI_X, POSI_Y;	// Position Number
-static INT32 FACE_X, FACE_Y;	// Top-four Faces
-static INT32 STCD_X, STCD_Y;	// Starting countdown
-static INT32 CHEK_Y;			// CHECK graphic
-static INT32 MINI_X, MINI_Y;	// Minimap
-static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+INT32 ITEM_X, ITEM_Y;	// Item Window
+INT32 TIME_X, TIME_Y;	// Time Sticker
+INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+INT32 SPDM_X, SPDM_Y;	// Speedometer
+INT32 POSI_X, POSI_Y;	// Position Number
+INT32 FACE_X, FACE_Y;	// Top-four Faces
+INT32 STCD_X, STCD_Y;	// Starting countdown
+INT32 CHEK_Y;			// CHECK graphic
+INT32 MINI_X, MINI_Y;	// Minimap
+INT32 WANT_X, WANT_Y;	// Battle WANTED poster
 
 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-static INT32 ITEM2_X, ITEM2_Y;
-static INT32 LAPS2_X, LAPS2_Y;
-static INT32 POSI2_X, POSI2_Y;
+INT32 ITEM2_X, ITEM2_Y;
+INT32 LAPS2_X, LAPS2_Y;
+INT32 POSI2_X, POSI2_Y;
 
 static void K_initKartHUD(void)
 {
@@ -3816,7 +3816,7 @@ static void K_drawKartMinimap(void)
 
 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap = NULL;
+			UINT8 *colormap;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3827,27 +3827,10 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;
 
-			if (mobj->color)
-			{
-				if (mobj->colorized)
-				{
-					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-				}
-				else
-				{
-					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
-
-					// special case if startcolor is not the default (160 / Green)
-					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
-					{
-						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
-					}
-					else
-					{
-						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
-					}
-				}
-			}
+			if (mobj->colorized)
+				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+			else
+				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
 
 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);

src/k_kart.c

@@ -660,22 +660,13 @@ INT32 K_GetSkinNum(player_t *player)
 
 //
 // returns the mobj skinnumber
-// accounts for localskins ?
+// accounts for localskins
 //
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
 {
 	return skin - K_GetSkinArray(local);
 }
 
-//
-// returns the mobj skinnumber
-// accounts for localskins
-//
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
-{
-	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
-}
-
 //
 // returns the players skinnumber
 // accounts for localskins
@@ -2159,13 +2150,7 @@ static void K_GetKartBoostPower(player_t *player)
 		&& player->speed > 0
 		&& !player->spectator)
 	{
-		mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true);
-
-		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
-		// is to hide them if you are in saltyhop jump
-		if (dust && player->mo->salty.jump)
-			dust->flags2 |= MF2_DONTDRAW;
-
+		K_SpawnWipeoutTrail(player->mo, true);
 		if (leveltime % 6 == 0)
 			S_StartSound(player->mo, sfx_cdfm70);
 	}
@@ -3640,7 +3625,7 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 	P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
 }
 
-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 {
 	mobj_t *dust;
 	angle_t aoff;
@@ -3681,8 +3666,6 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 
 	if (translucent)
 		dust->flags2 |= MF2_SHADOW;
-
-	return dust;
 }
 
 //	K_DriftDustHandling
@@ -6183,13 +6166,6 @@ void K_KartUpdatePosition(player_t *player)
 						}
 					}
 
-					// the player should NOT be checked against themselves! lol
-					// otherwise prevcheck will effectively be halved
-					// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
-					// oh well
-					//if (player == &players[i])
-						//continue;
-
 					const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
 					const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);
 

src/k_kart.h

@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
 void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
 void K_SpawnBoostTrail(player_t *player);
 void K_SpawnSparkleTrail(mobj_t *mo);
-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
 void K_DriftDustHandling(mobj_t *spawner);
 void K_PuntMine(mobj_t *mine, mobj_t *punter);
 void K_DoSneaker(player_t *player, INT32 type);

src/lua_hooklib.c

@@ -199,7 +199,7 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
 
 FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
 {
-	mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
+	mobjtype_t   mobj_type = luaL_optnumber(L, 3, MT_NULL);
 
 	luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t");
 
@@ -296,7 +296,8 @@ struct Hook_State {
 	INT32        status;/* return status to calling function */
 	void       * userdata;
 	int          hook_type;
-	mobjtype_t   mobj_type;/* <NUMMOBJTYPES if mobj hook */
+	mobjtype_t   mobj_type;/* >0 if mobj hook */
+	boolean      force_mobj;// allows mobj_type equal 0
 	const char * string;/* used to fetch table, ran first if set */
 	int          top;/* index of last argument passed to hook */
 	int          id;/* id to fetch ref */
@@ -363,8 +364,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_hook
 		int default_status,
 		int hook_type
 ){
+	hook->force_mobj = false;
+
 	return init_hook_type(hook, default_status,
-			hook_type, NUMMOBJTYPES, NULL,
+			hook_type, 0, NULL,
 			hookIds[hook_type].numHooks);
 }
 
@@ -378,6 +381,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
 	const mobjtype_t mobj_type =
 		primary_mobj ? primary_mobj->type : NUMMOBJTYPES;
 
+	hook->force_mobj = true;
+
 	return init_hook_type(hook, default_status,
 			hook_type, mobj_type, NULL,
 			mobj_hook_available(hook_type, mobj_type));
@@ -390,8 +395,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_string_hook
 		int          hook_type,
 		const char * string
 ){
+	hook->force_mobj = false;
+
 	if (init_hook_type(hook, default_status,
-				hook_type, NUMMOBJTYPES, string,
+				hook_type, 0, string,
 				stringHooks[hook_type].ref))
 	{
 		lua_pushstring(gL, string);
@@ -407,7 +414,7 @@ FUNCINLINE static ATTRINLINE boolean prepare_hud_hook
 		int hook_type
 ){
 	return init_hook_type(hook, 0,
-			hook_type, NUMMOBJTYPES, NULL,
+			hook_type, 0, NULL,
 			hudHookIds[hook_type].numHooks);
 }
 
@@ -547,11 +554,14 @@ static int call_hooks
 	{
 		calls += call_string_hooks(hook);
 	}
-	else if (hook->mobj_type < NUMMOBJTYPES)
+	else if (hook->force_mobj)
 	{
 		/* call generic mobj hooks first */
 		calls += call_mobj_type_hooks(hook, MT_NULL);
-		calls += call_mobj_type_hooks(hook, hook->mobj_type);
+
+		if (hook->mobj_type < NUMMOBJTYPES)
+			calls += call_mobj_type_hooks(hook, hook->mobj_type);
+
 		ps_lua_mobjhooks.value.i += calls;
 	}
 	else

src/lua_maplib.c

@@ -1506,6 +1506,7 @@ enum mapheaderinfo_e
 	mapheaderinfo_saveoverride,
 	mapheaderinfo_levelflags,
 	mapheaderinfo_menuflags,
+	//mapheaderinfo_automap,
 	mapheaderinfo_mobj_scale,
 };
 
@@ -1541,6 +1542,7 @@ static const char *const mapheaderinfo_opt[] = {
 	"saveoverride",
 	"levelflags",
 	"menuflags",
+	//"automap",
 	"mobj_scale",
 	NULL,
 };
@@ -1582,11 +1584,10 @@ static int mapheaderinfo_get(lua_State *L)
 		lua_pushinteger(L, header->muspos);
 		break;
 	case mapheaderinfo_musinterfadeout:
-		lua_pushinteger(L, 0); // unused
+		lua_pushinteger(L, header->musinterfadeout);
 		break;
 	case mapheaderinfo_musintername:
-		// uhh psure its fine to just push nil instead of empty string?
-		lua_pushstring(L, NULL);
+		lua_pushstring(L, header->musintername);
 		break;
 	case mapheaderinfo_forcecharacter:
 		lua_pushstring(L, header->forcecharacter);
@@ -1640,10 +1641,10 @@ static int mapheaderinfo_get(lua_State *L)
 		lua_pushinteger(L, header->levelselect);
 		break;
 	case mapheaderinfo_bonustype:
-		lua_pushinteger(L, 0); // unused
+		lua_pushinteger(L, header->bonustype);
 		break;
 	case mapheaderinfo_saveoverride:
-		lua_pushinteger(L, SAVE_DEFAULT); // unused
+		lua_pushinteger(L, header->saveoverride);
 		break;
 	case mapheaderinfo_levelflags:
 		lua_pushinteger(L, header->levelflags);
@@ -1651,9 +1652,13 @@ static int mapheaderinfo_get(lua_State *L)
 	case mapheaderinfo_menuflags:
 		lua_pushinteger(L, header->menuflags);
 		break;
+	/*case mapheaderinfo_automap:
+		lua_pushstring(L, header->selectheading);
+		break;*/
 	case mapheaderinfo_mobj_scale:
 		lua_pushfixed(L, header->mobj_scale);
 		break;
+	// TODO add support for reading numGradedMares and grades
 	default:
 	{
 		// Read custom vars now

src/lzf.h

@@ -13,10 +13,6 @@
 #define LZF_H
 #include <stdio.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /***********************************************************************
 **
 **	lzf -- an extremely fast/free compression/decompression-method
@@ -75,9 +71,5 @@ size_t
 lzf_decompress (const void *const in_data,  size_t in_len,
                 void             *out_data, size_t out_len);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif
 

src/m_cond.c

@@ -479,13 +479,32 @@ UINT8 M_CheckLevelEmblems(void)
 	// Update Score, Time, Rings emblems
 	for (i = 0; i < numemblems; ++i)
 	{
-		// Requires time on map <= x
-		if (emblemlocations[i].type != ET_TIME || emblemlocations[i].collected)
+		if (emblemlocations[i].type <= ET_SKIN || emblemlocations[i].collected)
 			continue;
 
 		levelnum = emblemlocations[i].level;
 		valToReach = emblemlocations[i].var;
-		res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
+
+		switch (emblemlocations[i].type)
+		{
+			/*case ET_SCORE: // Requires score on map >= x
+				res = (G_GetBestScore(levelnum) >= (unsigned)valToReach);
+				break;*/
+			case ET_TIME: // Requires time on map <= x
+				res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
+				break;
+			/*case ET_RINGS: // Requires rings on map >= x
+				res = (G_GetBestRings(levelnum) >= valToReach);
+				break;
+			case ET_NGRADE: // Requires NiGHTS grade on map >= x
+				res = (G_GetBestNightsGrade(levelnum, 0) >= valToReach);
+				break;
+			case ET_NTIME: // Requires NiGHTS time on map <= x
+				res = (G_GetBestNightsTime(levelnum, 0) <= (unsigned)valToReach);
+				break;*/
+			default: // unreachable but shuts the compiler up.
+				continue;
+		}
 
 		emblemlocations[i].collected = res;
 		if (res)

src/m_cond.h

@@ -27,11 +27,21 @@ typedef enum
 	UC_MATCHESPLAYED,   // SRB2Kart: MATCHESPLAYED [x played]
 	UC_GAMECLEAR,       // GAMECLEAR <x times>
 	UC_ALLEMERALDS,     // ALLEMERALDS <x times>
+	//UC_ULTIMATECLEAR,   // ULTIMATECLEAR <x times>
+	//UC_OVERALLSCORE,    // OVERALLSCORE [score to beat]
 	UC_OVERALLTIME,     // OVERALLTIME [time to beat, tics]
+	//UC_OVERALLRINGS,    // OVERALLRINGS [rings to beat]
 	UC_MAPVISITED,      // MAPVISITED [map number]
 	UC_MAPBEATEN,       // MAPBEATEN [map number]
 	UC_MAPALLEMERALDS,  // MAPALLEMERALDS [map number]
+	//UC_MAPULTIMATE,     // MAPULTIMATE [map number]
+	//UC_MAPPERFECT,      // MAPPERFECT [map number]
+	//UC_MAPSCORE,        // MAPSCORE [map number] [score to beat]
 	UC_MAPTIME,         // MAPTIME [map number] [time to beat, tics]
+	//UC_MAPRINGS,        // MAPRINGS [map number] [rings to beat]
+	//UC_NIGHTSSCORE,     // NIGHTSSCORE [map number] <mare, omit or "0" for overall> [score to beat]
+	//UC_NIGHTSTIME,      // NIGHTSTIME [map number] <mare, omit "0" overall> [time to beat, tics]
+	//UC_NIGHTSGRADE,     // NIGHTSGRADE [map number] <mare, omit "0" overall> [grade]
 	UC_TRIGGER,         // TRIGGER [trigger number]
 	UC_TOTALEMBLEMS,    // TOTALEMBLEMS [number of emblems]
 	UC_EMBLEM,          // EMBLEM [emblem number]

src/m_emotes.cpp

@@ -278,7 +278,7 @@ void M_DrawScaledEmote(fixed_t x, fixed_t y, fixed_t scale, emote_t *emote, INT3
 static void Command_ListEmotes_f(void)
 {
 	const int EMOTES_PER_PAGE = 24;
-	const int NUMPAGES = emotes.size()/EMOTES_PER_PAGE + (emotes.size() % EMOTES_PER_PAGE != 0 ? 1 : 0);
+	const int NUMPAGES = std::max<int>(emotes.size()/EMOTES_PER_PAGE, 1);
 	int page = 1;
 
 	if (COM_Argc() > 1)

src/m_menu.c

@@ -186,8 +186,8 @@ static INT16 itemOn = 1; // menu item skull is on, Hack by Tails 09-18-2002
 static INT16 skullAnimCounter = 10; // skull animation counter
 static boolean interpTimerHackAllow = 0;
 
-static UINT8 setupcontrolplayer;
-static INT32 (*setupcontrols)[2];  // pointer to the gamecontrols of the player being edited
+static  UINT8 setupcontrolplayer;
+static  INT32   (*setupcontrols)[2];  // pointer to the gamecontrols of the player being edited
 
 // shhh... what am I doing... nooooo!
 static INT32 vidm_testingmode = 0;
@@ -201,8 +201,8 @@ static char setupm_ip[64];
 static textinput_t setupm_input_ip;
 
 
-static fixed_t  multi_tics;
-static state_t *multi_state;
+static fixed_t    multi_tics;
+static state_t   *multi_state;
 
 // this is set before entering the MultiPlayer setup menu,
 // for either player 1 or 2
@@ -1024,9 +1024,9 @@ boolean M_Responder(event_t *ev)
 				//case KEY_JOY1 + 2:
 				ch = KEY_ENTER;
 				break;
-			/*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now.
-				ch = 'n';
-				break;*/
+				/*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now.
+					ch = 'n';
+					break;*/
 			case KEY_MOUSE1 + 1:
 				//case KEY_JOY1 + 1:
 				ch = KEY_BACKSPACE;
@@ -1305,21 +1305,12 @@ boolean M_Responder(event_t *ev)
 	{
 		playback_last_menu_interaction_leveltime = leveltime;
 		// Flip left/right with up/down for the playback menu, since it's a horizontal icon row.
-
 		switch (ch)
 		{
-			case KEY_LEFTARROW:
-				ch = KEY_UPARROW;
-				break;
-			case KEY_UPARROW:
-				ch = KEY_RIGHTARROW;
-				break;
-			case KEY_RIGHTARROW:
-				ch = KEY_DOWNARROW;
-				break;
-			case KEY_DOWNARROW:
-				ch = KEY_LEFTARROW;
-				break;
+			case KEY_LEFTARROW: ch = KEY_UPARROW; break;
+			case KEY_UPARROW: ch = KEY_RIGHTARROW; break;
+			case KEY_RIGHTARROW: ch = KEY_DOWNARROW; break;
+			case KEY_DOWNARROW: ch = KEY_LEFTARROW; break;
 
 			// arbitrary keyboard shortcuts because fuck you
 
@@ -1370,8 +1361,7 @@ boolean M_Responder(event_t *ev)
 					G_AdjustView(4, 1, true);
 				break;
 
-			default:
-				break;
+			default: break;
 		}
 	}
 
@@ -1496,7 +1486,6 @@ boolean M_Responder(event_t *ev)
 			}
 
 			return false;
-			break;
 
 		default:
 			CON_Responder(ev);
@@ -2075,6 +2064,7 @@ void M_Init(void)
 			OP_OpenGLOptionsMenu[op_gl_shader].status = IT_GRAYEDOUT;
 			OP_OpenGLOptionsMenu[op_gl_lightdither].status = IT_GRAYEDOUT;
 			OP_OpenGLOptionsMenu[op_gl_palrender].status = IT_GRAYEDOUT;
+			OP_OpenGLOptionsMenu[op_gl_flashpal].status = IT_GRAYEDOUT;
 
 			OP_ExpOptionsMenu[op_exp_paldepth].status = IT_GRAYEDOUT;
 		}
@@ -4026,16 +4016,16 @@ boolean replaynamesloaded = false;
 #ifdef HAVE_THREADS
 I_mutex replayquerymutex;
 
-// I_In_Exiting_Signal_Handler is an evil hack
+// g_in_exiting_signal_handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_search_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&replayquerymutex); }
-#  define Unlock_search_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(replayquerymutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_search_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&replayquerymutex); }
+#  define Unlock_search_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(replayquerymutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_search_state()
 #  define Unlock_search_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/
 
 
 #define MAXREPLAYQUERY 37
@@ -4123,9 +4113,6 @@ static void AddCheckedReplay(void)
 // Check up to maxnum replays if they match with query
 static void M_HutCheckReplays(size_t maxnum)
 {
-	// Stripped of color codes
-	char demo_title[sizeof(demolist_all[0].title)];
-
 	if (!replaynamesloaded)
 		return;
 
@@ -4158,9 +4145,7 @@ static void M_HutCheckReplays(size_t maxnum)
 			case MD_NOTLOADED:
 			case MD_OUTDATED:
 			case MD_LOADED:
-				StripColors(demo_title, demolist_all[replayquerycheck].title, sizeof(demo_title));
-
-				if (demolist_all[replayquerycheck].title[0] && strcasestr(demo_title, replayqueryinput.buffer) != 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...
@@ -4920,7 +4905,6 @@ static void M_HutStartReplay(INT32 choice)
 	demo.loadfiles = (itemOn == 0);
 	demo.ignorefiles = (itemOn != 0);
 
-	CONS_Printf(M_GetText("Playing back demo '%s'.\n"), demolist[dir_on[menudepthleft]].filepath);
 	G_DoPlayDemo(demolist[dir_on[menudepthleft]].filepath);
 }
 
@@ -6482,7 +6466,7 @@ static void M_ChooseTimeAttack(INT32 choice)
 static void M_HandleStaffReplay(INT32 choice)
 {
 	boolean exitmenu = false; // exit to previous menu
-	lumpnum_t l = W_CheckNumForName(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
+	lumpnum_t l = W_CheckNumForName(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value));
 
 	switch (choice)
 	{
@@ -6512,7 +6496,7 @@ static void M_HandleStaffReplay(INT32 choice)
 			M_ClearMenus(true);
 			modeattacking = ATTACKING_RECORD;
 			demo.loadfiles = false; demo.ignorefiles = true; // Just assume that record attack replays have the files needed
-			G_DoPlayDemo(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
+			G_DoPlayDemo(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value));
 			break;
 		default:
 			break;
@@ -7956,7 +7940,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	patch_t *statbg  = (patch_t *)W_CachePatchName("K_STATBG", PU_PATCH);
 	patch_t *statlr  = (patch_t *)W_CachePatchName("K_STATLR", PU_PATCH);
 	patch_t *statud  = (patch_t *)W_CachePatchName("K_STATUD", PU_PATCH);
-	patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0" , PU_PATCH);
+	patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0", PU_PATCH);
 	patch_t *patch;
 	UINT8 frame;
 	UINT8 speed;
@@ -10057,6 +10041,7 @@ static void M_DrawVideoMode(void)
 			va("Wait %d second%s", testtime, (testtime > 1) ? "s" : ""));
 		M_CentreText(OP_VideoModeDef.y + 158,
 			"or press ESC to return");
+
 	}
 	else
 	{

src/m_menudefs.c

@@ -1023,6 +1023,8 @@ static menuitem_t OP_OpenGLOptionsMenu[] =
 	{IT_STRING | IT_CVAR,	NULL, "Fallback Player 3D Model",	&cv_glfallbackplayermodel,	20},
 	{IT_STRING | IT_CVAR,	NULL, "Shaders",					&cv_glshaders,				25},
 	{IT_STRING | IT_CVAR,	NULL, "Palette Rendering",			&cv_glpaletterendering,		30},
+	{IT_STRING | IT_CVAR,   NULL, "Palette Rendering Flashpals",&cv_glflashpal,				35},
+	//{IT_STRING | IT_CVAR, 	NULL, "Min Shader Brightness", 		&cv_glsecbright,			40},
 
 	{IT_STRING | IT_CVAR,	NULL, "Texture Quality",			&cv_gltexturedepth,			45},
 	{IT_STRING | IT_CVAR,	NULL, "Texture Filter",				&cv_glfiltermode,			50},
@@ -1043,6 +1045,7 @@ static const char* OP_OpenGLTooltips[] =
 	"Fallback 3D model for characters that don't have any.",
 	"Graphical Shaders.",
 	"Recreates the look of software mode.",
+	"Flash palettes for palette rendering.",
 	"Bit-depth of textures.",
 	"Filter to use on textures.",
 	"Anisotropic filtering.",
@@ -1061,6 +1064,7 @@ enum
 	op_gl_falbckmdls,
 	op_gl_shader,
 	op_gl_palrender,
+	op_gl_flashpal,
 	op_gl_scrdepth,
 	op_gl_filter,
 	op_gl_anis,
@@ -2770,5 +2774,6 @@ void M_UpdateOGLMenu(void)
 	OP_OpenGLOptionsMenu[op_gl_lightdither].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
 
 	OP_OpenGLOptionsMenu[op_gl_palrender].status = (cv_glscreentextures.value != 2 || !HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
+	OP_OpenGLOptionsMenu[op_gl_flashpal].status = (!HWR_ShouldUsePaletteRendering()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
 }
 #endif

src/m_misc.c

@@ -788,10 +788,10 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	else
 		snprintf(locationtxt, 40, "Unknown");
 
-	memset(png_infotext, 0x00, sizeof(png_infotext));
+	memset(png_infotext,0x00,sizeof (png_infotext));
 
 	for (i = 0; i < SRB2PNGTXT; i++)
-		png_infotext[i].key = keytxt[i];
+		png_infotext[i].key  = keytxt[i];
 
 	png_infotext[0].text = titletxt;
 	if (movie)
@@ -804,15 +804,9 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	png_infotext[5].text = locationtxt;
 	png_infotext[6].text = interfacetxt;
 	png_infotext[7].text = rendermodetxt;
-	strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
-	ctrevision[sizeof(ctrevision)-1] = '\0';
-	png_infotext[8].text = ctrevision;
-	strncpy(ctdate, compdate, sizeof(ctdate)-1);
-	ctdate[sizeof(ctdate)-1] = '\0';
-	png_infotext[9].text = ctdate;
-	strncpy(cttime, comptime, sizeof(cttime)-1);
-	cttime[sizeof(cttime)-1] = '\0';
-	png_infotext[10].text = cttime;
+	png_infotext[8].text = strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
+	png_infotext[9].text = strncpy(ctdate, compdate, sizeof(ctdate)-1);
+	png_infotext[10].text = strncpy(cttime, comptime, sizeof(cttime)-1);
 
 	png_set_text(png_ptr, png_info_ptr, png_infotext, SRB2PNGTXT);
 #undef SRB2PNGTXT
@@ -1460,9 +1454,9 @@ INT32 axtoi(const char *hexStg)
 
 void CopyCaretColors(char *p, const char *s, int n)
 {
-	gconst char *t;
-	int          m;
-	int          c;
+	char *t;
+	int   m;
+	int   c;
 
 	if (!n)
 		return;
@@ -1570,7 +1564,6 @@ char *M_GetToken(const char *inputString)
 	{
 		startPos = endPos;
 	}
-
 	if (stringToUse == NULL)
 		return NULL;
 
@@ -1641,8 +1634,7 @@ char *M_GetToken(const char *inputString)
 	}
 
 	// If the end of the string is reached, no token is to be read
-	if (startPos == stringLength)
-	{
+	if (startPos == stringLength) {
 		endPos = stringLength;
 		return NULL;
 	}
@@ -1652,7 +1644,7 @@ char *M_GetToken(const char *inputString)
 			|| stringToUse[startPos] == '}')
 	{
 		endPos = startPos + 1;
-		texturesToken = (char *)Z_Malloc(2*sizeof(char), PU_STATIC, NULL);
+		texturesToken = (char *)Z_Malloc(2*sizeof(char),PU_STATIC,NULL);
 		texturesToken[0] = stringToUse[startPos];
 		texturesToken[1] = '\0';
 		return texturesToken;
@@ -1863,10 +1855,8 @@ int M_PathParts(const char *path)
 	int n;
 	const char *p;
 	const char *t;
-
 	if (path == NULL)
 		return 0;
-
 	for (n = 0, p = path ;; ++n)
 	{
 		t = p;
@@ -1879,7 +1869,6 @@ int M_PathParts(const char *path)
 			break;
 		}
 	}
-
 	return n;
 }
 
@@ -1922,9 +1911,7 @@ void M_MkdirEachUntil(const char *cpath, int start, int end, int mode)
 		if (!( p = strchr(p, PATHSEP[0]) ))
 			return;
 	}
-
 	p += strspn(p, PATHSEP);
-
 	for (;;)
 	{
 		if (end > 0 && !--end)
@@ -1969,22 +1956,6 @@ UINT32 FNV1a_Hash(const char *message, size_t size)
 	return hash;
 }
 
-// Behaves like the old quickncasehash
-// Stops either if it encounters null terminator
-// or reaches size
-UINT32 FNV1a_QuickCaseHash(const char *message, size_t size)
-{
-	UINT32 hash = FNV1A_OFFSET_BASIS;
-
-	for (size_t i = 0; i < size && message[i]; i++)
-	{
-		hash ^= tolower(message[i]);
-		hash *= FNV1A_PRIME;
-	}
-
-	return hash;
-}
-
 UINT32 FNV1a_HashString(const char *message)
 {
 	UINT32 hash = FNV1A_OFFSET_BASIS;

src/m_misc.h

@@ -123,7 +123,6 @@ FUNCMATH UINT8 M_CountBits(UINT32 num, UINT8 size);
 
 // Hashes some message using FNV-1a
 UINT32 FNV1a_Hash(const char *message, size_t size);
-UINT32 FNV1a_QuickCaseHash(const char *message, size_t size);
 UINT32 FNV1a_HashString(const char *message);
 UINT32 FNV1a_HashLowercaseString(const char *message);
 

src/m_textinput.c

@@ -256,7 +256,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
 		return true;
 	}
 
-	if (ctrldown && (cv_keyboardlayout.value != 3 || (cv_keyboardlayout.value == 3 && !altdown)))
+	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
 	{
 		if (key == 'x' || key == 'X')
 		{
@@ -392,7 +392,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
 		key = '/';
 
 	// same capslock code as hu_stuff.c's HU_responder. Check there for details.
-	key = CON_ShiftChar(key);
+	key = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(key) : CON_ShiftChar(key);
 
 	// enter a char into the command prompt
 	if (key < 32 || key > 127)

src/md5.h

@@ -16,10 +16,6 @@
 #ifndef _MD5_H
 #define _MD5_H 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include <stdio.h>
 
 #if defined (HAVE_LIMITS_H) || (defined (_LIBC) && _LIBC) || defined (_WIN32)
@@ -56,8 +52,4 @@ int md5_stream(FILE *stream, void *resblock) THROWFUNC;
 	digest.  */
 extern void *md5_buffer(const char *buffer, size_t len, void *resblock) THROWFUNC;
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif /* md5.h */

src/mserv.c

@@ -262,7 +262,6 @@ Finish_registration (void)
 	{
 		CONS_Printf("\n");
 		CONS_Alert(CONS_NOTICE, "%s\n", rules);
-		free(rules);
 	}
 
 	if (registered)

src/p_inter.c

@@ -831,7 +831,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 			{
 				S_StartSound(toucher, special->info->seesound);
 
-				if (UNLIKELY(player->pflags & PF_NIGHTSMODE))
+				if (player->pflags & PF_NIGHTSMODE)
 				{
 					player->bumpertime = TICRATE/2;
 					if (special->threshold > 0)
@@ -1131,7 +1131,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 					S_StartSound(toucher, special->info->painsound);
 					return;
 				}
-				else if (UNLIKELY((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
+				else if (((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
 						|| player->powers[pw_invulnerability] || player->powers[pw_super]) // Do you possess the ability to subdue the object?
 				{
 					// Shatter the shield!

src/p_local.h

@@ -30,6 +30,8 @@ extern "C" {
 
 #define FLOATSPEED (FRACUNIT*4)
 
+//#define VIEWHEIGHTS "41"
+
 // Maximum player score.
 #define MAXSCORE 999999990
 
@@ -237,10 +239,14 @@ void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move);
 boolean P_LookForEnemies(player_t *player);
 void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
 void P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
+//boolean P_SuperReady(player_t *player);
 boolean P_AnalogMove(player_t *player);
+/*boolean P_TransferToNextMare(player_t *player);
+UINT8 P_FindLowestMare(void);*/
 UINT8 P_FindLowestLap(void);
 UINT8 P_FindHighestLap(void);
 void P_FindEmerald(void);
+//void P_TransferToAxis(player_t *player, INT32 axisnum);
 boolean P_PlayerMoving(INT32 pnum);
 void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range);
 

src/p_mobj.c

@@ -122,6 +122,27 @@ static void P_CycleMobjState(mobj_t *mobj)
 	}
 }
 
+//
+// P_CycleMobjState for players.
+//
+static void P_CyclePlayerMobjState(mobj_t *mobj)
+{
+	// state animations
+	P_CycleStateAnimation(mobj);
+
+	// cycle through states,
+	// calling action functions at transitions
+	if (mobj->tics != -1)
+	{
+		mobj->tics--;
+
+		// you can cycle through multiple states in a tic
+		if (!mobj->tics && mobj->state)
+			if (!P_SetPlayerMobjState(mobj, mobj->state->nextstate))
+				return; // freed itself
+	}
+}
+
 #define MAX_RECURSION 20
 
 //
@@ -898,7 +919,12 @@ static void P_PlayerFlip(mobj_t *mo)
 	G_GhostAddFlip((INT32) (mo->player - players));
 	// Flip aiming to match!
 
-	if (mo->player->pflags & PF_FLIPCAM)
+	if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
+	{
+		if (mo->tracer)
+			mo->tracer->eflags ^= MFE_VERTICALFLIP;
+	}
+	else if (mo->player->pflags & PF_FLIPCAM)
 	{
 		UINT8 i;
 
@@ -920,11 +946,6 @@ static void P_PlayerFlip(mobj_t *mo)
 				camera[i].z += FixedMul(20*FRACUNIT, mo->scale);
 		}
 	}
-	else if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
-	{
-		if (mo->tracer)
-			mo->tracer->eflags ^= MFE_VERTICALFLIP;
-	}
 }
 
 //
@@ -1649,14 +1670,6 @@ void P_XYMovement(mobj_t *mo)
 	if (mo->flags & MF_NOCLIPHEIGHT)
 		return; // no frictions for objects that can pass through floors
 
-	//{ SRB2kart stuff
-	if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
-		return;
-
-	if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
-		return;
-	//}
-
 	if (mo->flags & MF_MISSILE || mo->flags2 & MF2_SKULLFLY || mo->type == MT_SHELL || mo->type == MT_VULTURE)
 		return; // no friction for missiles ever
 
@@ -1670,6 +1683,14 @@ void P_XYMovement(mobj_t *mo)
 			&& (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8)) // Special exception for tumbleweeds on slopes
 		return;
 
+	//{ SRB2kart stuff
+	if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
+		return;
+
+	if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
+		return;
+	//}
+
 	if (((!(mo->eflags & MFE_VERTICALFLIP) && mo->z > mo->floorz) || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height < mo->ceilingz))
 		&& !(player && player->pflags & PF_SLIDING))
 		return; // no friction when airborne
@@ -3189,6 +3210,30 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
 	return false;
 }
 
+void P_DestroyRobots(void)
+{
+	// Search through all the thinkers for enemies.
+	mobj_t *mo;
+	thinker_t *think;
+
+	for (think = thinkercap.next; think != &thinkercap; think = think->next)
+	{
+		if (think->function != (actionf_p1)P_MobjThinker)
+			continue; // not a mobj thinker
+
+		mo = (mobj_t *)think;
+
+		if (mo->health <= 0 || !(mo->flags & MF_ENEMY || mo->flags & MF_BOSS))
+			continue; // not a valid enemy
+
+		if (mo->type == MT_PLAYER) // Don't chase after other players!
+			continue;
+
+		// Found a target enemy
+		P_KillMobj(mo, players[consoleplayer].mo, players[consoleplayer].mo);
+	}
+}
+
 // the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person
 void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
 {
@@ -3207,7 +3252,7 @@ void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
 		player_flipcam = cv_flipcam[pnum].value;
 	}
 
-	const boolean flipcam = (player_flipcam && player->mo->eflags & MFE_VERTICALFLIP && LIKELY(!(player->pflags & PF_NIGHTSMODE)));
+	const boolean flipcam = (player_flipcam && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
 	UINT8 postimgtype = 0;
 
 	if (encoremode)
@@ -8508,7 +8553,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 				if (mobj->tracer && mobj->tracer->player)
 				{
-					if (LIKELY(!(mobj->tracer->player->pflags & PF_NIGHTSMODE)))
+					if (!(mobj->tracer->player->pflags & PF_NIGHTSMODE))
 					{
 						mobj->flags &= ~MF_NOGRAVITY;
 						mobj->flags2 &= ~MF2_DONTDRAW;
@@ -8532,7 +8577,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 						P_SetTarget(&mobj->target, NULL);
 					}
 
-					if (UNLIKELY(mobj->tracer->player->pflags & PF_NIGHTSMODE))
+					if (mobj->tracer->player->pflags & PF_NIGHTSMODE)
 					{
 						if (mobj->tracer->player->bonustime)
 						{
@@ -9176,7 +9221,10 @@ void P_MobjThinker(mobj_t *mobj)
 	}
 
 	// Can end up here if a player dies.
-	P_CycleMobjState(mobj);
+	if (mobj->player)
+		P_CyclePlayerMobjState(mobj);
+	else
+		P_CycleMobjState(mobj);
 
 	if (P_MobjWasRemoved(mobj))
 		return;
@@ -11070,6 +11118,8 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	{
 		if (!cv_powerstones.value || !G_BattleGametype())
 			return;
+
+		runemeraldmanager = true;
 	}
 
 	if (!G_RaceGametype()) // No enemies in match or CTF modes

src/p_mobj.h

@@ -499,6 +499,7 @@ void P_SpawnPrecipitation(void);
 void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter);
 boolean P_BossTargetPlayer(mobj_t *actor, boolean closest);
 boolean P_SupermanLook4Players(mobj_t *actor);
+void P_DestroyRobots(void);
 boolean P_PrecipThinker(precipmobj_t *mobj);
 void P_NullPrecipThinker(precipmobj_t *mobj);
 void P_FreePrecipMobj(precipmobj_t *mobj);
@@ -509,6 +510,7 @@ void P_EmeraldManager(void);
 #define MAXHUNTEMERALDS 64
 extern mapthing_t *huntemeralds[MAXHUNTEMERALDS];
 extern INT32 numhuntemeralds;
+extern boolean runemeraldmanager;
 extern INT32 numstarposts;
 
 #ifdef __cplusplus

src/p_setup.c

@@ -218,6 +218,8 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
 	mapheaderinfo[num]->musname[6] = 0;
 	mapheaderinfo[num]->mustrack = 0;
 	mapheaderinfo[num]->muspos = 0;
+	mapheaderinfo[num]->musinterfadeout = 0;
+	mapheaderinfo[num]->musintername[0] = '\0';
 	mapheaderinfo[num]->forcecharacter[0] = '\0';
 	mapheaderinfo[num]->weather = 0;
 	mapheaderinfo[num]->skynum = 1;
@@ -235,10 +237,16 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
 	mapheaderinfo[num]->numlaps = NUMLAPS_DEFAULT;
 	mapheaderinfo[num]->unlockrequired = -1;
 	mapheaderinfo[num]->levelselect = 0;
+	mapheaderinfo[num]->bonustype = 0;
+	mapheaderinfo[num]->saveoverride = SAVE_DEFAULT;
 	mapheaderinfo[num]->levelflags = 0;
 	mapheaderinfo[num]->menuflags = (mainwads ? 0 : LF2_EXISTSHACK); // see p_setup.c - prevents replacing maps in addons with easier versions
 
+	// TODO grades support for delfile (pfft yeah right)
+	P_DeleteGrades(num);
+
 	// SRB2Kart
+	//mapheaderinfo[num]->automap = false;
 	mapheaderinfo[num]->mobj_scale = FRACUNIT;
 
 	mapheaderinfo[num]->customopts = NULL;
@@ -258,11 +266,107 @@ void P_AllocMapHeader(INT16 i)
 	if (!mapheaderinfo[i])
 	{
 		mapheaderinfo[i] = Z_Malloc(sizeof(mapheader_t), PU_STATIC, NULL);
+		mapheaderinfo[i]->grades = NULL;
 	}
 
 	P_ClearSingleMapHeaderInfo(i + 1);
 }
 
+/** NiGHTS Grades are a special structure,
+  * we initialize them here.
+  *
+  * \param i Index of header to allocate grades for
+  * \param mare The mare we're adding grades for
+  * \param grades the string from DeHackEd, we work with it ourselves
+  */
+void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext)
+{
+	INT32 g;
+	char *spos = gtext;
+
+	CONS_Debug(DBG_SETUP, "Map %d Mare %d: ", i+1, (UINT16)mare+1);
+
+	if (mapheaderinfo[i]->numGradedMares < mare+1)
+	{
+		mapheaderinfo[i]->numGradedMares = mare+1;
+		mapheaderinfo[i]->grades = Z_Realloc(mapheaderinfo[i]->grades, sizeof(nightsgrades_t) * mapheaderinfo[i]->numGradedMares, PU_STATIC, NULL);
+	}
+
+	for (g = 0; g < 6; ++g)
+	{
+		// Allow "partial" grading systems
+		if (spos != NULL)
+		{
+			mapheaderinfo[i]->grades[mare].grade[g] = atoi(spos);
+			CONS_Debug(DBG_SETUP, "%u ", atoi(spos));
+			// Grab next comma
+			spos = strchr(spos, ',');
+			if (spos)
+				++spos;
+		}
+		else
+		{
+			// Grade not reachable
+			mapheaderinfo[i]->grades[mare].grade[g] = UINT32_MAX;
+		}
+	}
+
+	CONS_Debug(DBG_SETUP, "\n");
+}
+
+/** And this removes the grades safely.
+  *
+  * \param i The header to remove grades from
+  */
+void P_DeleteGrades(INT16 i)
+{
+	Z_Free(mapheaderinfo[i]->grades);
+	mapheaderinfo[i]->grades = NULL;
+	mapheaderinfo[i]->numGradedMares = 0;
+}
+
+/** And this fetches the grades
+  *
+  * \param pscore The player's score.
+  * \param map The game map.
+  * \param mare The mare to test.
+  */
+UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare)
+{
+	INT32 i;
+
+	// Determining the grade
+	if (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades && mapheaderinfo[map-1]->numGradedMares >= mare + 1)
+	{
+		INT32 pgrade = 0;
+		for (i = 0; i < 6; ++i)
+		{
+			if (pscore >= mapheaderinfo[map-1]->grades[mare].grade[i])
+				++pgrade;
+		}
+
+		return (UINT8)pgrade;
+	}
+
+	return 0;
+}
+
+UINT8 P_HasGrades(INT16 map, UINT8 mare)
+{
+	// Determining the grade
+	// Mare 0 is treated as overall and is true if ANY grades exist
+	return (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades
+	&& (mare == 0 || mapheaderinfo[map-1]->numGradedMares >= mare));
+}
+
+UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade)
+{
+	// Get the score for the grade... if it exists
+	if (grade == GRADE_F || grade > GRADE_S || !P_HasGrades(map, mare)) return 0;
+
+	return mapheaderinfo[map-1]->grades[mare].grade[grade-1];
+}
+
 // Loads the vertexes for a level.
 FUNCINLINE static ATTRINLINE void P_LoadVertices(UINT8 *data)
 {
@@ -310,7 +414,7 @@ void P_UpdateSegLightOffset(seg_t *li)
 		angle_t liAngle = R_PointToAngle2(0, 0, (li->v1->x - li->v2->x), (li->v1->y - li->v2->y)) - ANGLE_90;
 
 		light = FixedMul(FINECOSINE(liAngle >> ANGLETOFINESHIFT), FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
-			  + FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
+		+ FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
 		light = (light + FRACUNIT) / 2;
 	}
 	else
@@ -1810,7 +1914,7 @@ static void P_LoadMapBSP(const virtres_t* virt)
 	if (numsubsectors <= 0)
 		I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
 	if (numnodes <= 0)
-		I_Error("Level has no nodes (does your map have at least 2 sectors?)");
+		I_Error("Level has no nodes");
 	if (numsegs <= 0)
 		I_Error("Level has no segs");
 
@@ -1943,6 +2047,7 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
 
 	// special stage tokens, emeralds, and ring total
 	tokenbits = 0;
+	runemeraldmanager = false;
 	nummaprings = nummapboxes = numgotboxes = 0;
 
 	// emerald hunt
@@ -1972,10 +2077,10 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
 	stagefailed = false;
 
 	// earthquake camera
-	memset(&quake, 0, sizeof(struct quake));
+	memset(&quake,0,sizeof(struct quake));
 
 	// song credit init
-	memset(&cursongcredit, 0, sizeof(struct cursongcredit));
+	memset(&cursongcredit,0,sizeof(struct cursongcredit));
 	cursongcredit.trans = NUMTRANSMAPS;
 
 	for (i = 0; i < MAXPLAYERS; i++)
@@ -2069,14 +2174,14 @@ static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
 	memset(resblock, 0x00, 16);
 	return 1;
 #else
-	precise_t t = I_GetPreciseTime();
+	tic_t t = I_GetTime();
 
 	CONS_Debug(DBG_SETUP, "Making MD5\n");
 
 	if (md5_buffer(buffer, len, resblock) == NULL)
 		return 1;
 
-	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
+	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
 
 	return 0;
 #endif
@@ -2098,10 +2203,10 @@ static void P_MakeMapMD5(virtres_t *virt, void *dest)
 	virtlump_t* virtmthings = vres_Find(virt, "THINGS");
 	virtlump_t* virtsides   = vres_Find(virt, "SIDEDEFS");
 
-	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size,   linemd5);
-	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size, sectormd5);
-	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size, thingmd5);
-	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size,   sidedefmd5);
+	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size, linemd5);
+	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size,  sectormd5);
+	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size,   thingmd5);
+	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size, sidedefmd5);
 
 	for (i = 0; i < 16; i++)
 		resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;

src/p_setup.h

@@ -114,6 +114,13 @@ size_t P_PrecacheLevelFlats(void);
 
 void P_AllocMapHeader(INT16 i);
 
+// Needed for NiGHTS
+void P_DeleteGrades(INT16 i);
+void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext);
+UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare);
+UINT8 P_HasGrades(INT16 map, UINT8 mare);
+UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/p_slopes.c

@@ -76,8 +76,8 @@ static void P_UpdateSlopeLightOffset(pslope_t *slope)
 		 */
 
 		light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
-			  + FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
-				light = (light + FRACUNIT) / 2;
+		+ FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
+		light = (light + FRACUNIT) / 2;
 	}
 	else
 	{

src/p_spec.c

@@ -4399,7 +4399,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 
 	// The list of specials that activate without floor touch
 	// Check Section 1
-	switch (GETSECSPECIAL(sector->special, 1))
+	switch(GETSECSPECIAL(sector->special, 1))
 	{
 		//case 2: // Damage (water)
 		case 8: // Instant kill
@@ -4410,7 +4410,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 2
-	switch (GETSECSPECIAL(sector->special, 2))
+	switch(GETSECSPECIAL(sector->special, 2))
 	{
 		case 2: // Linedef executor (All players needed)
 		case 4: // Linedef executor
@@ -4421,7 +4421,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 4
-	switch (GETSECSPECIAL(sector->special, 4))
+	switch(GETSECSPECIAL(sector->special, 4))
 	{
 		case 2: // Level Exit / GOAL Sector / Flag Return
 		case 1: // Starpost activator

src/p_user.c

@@ -1992,23 +1992,20 @@ static void P_3dMovement(player_t *player)
 		K_MomentumToFacing(player);
 	}
 
-	const fixed_t kartspd = K_GetKartSpeed(player, true);
-
 	// Sideways movement
 	if (cmd->sidemove != 0 && !((player->exiting || mapreset) || player->kartstuff[k_spinouttimer]))
 	{
 		if (cmd->sidemove > 0)
-			movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, kartspd);
+			movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, K_GetKartSpeed(player, true));
 		else
-			movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, kartspd);
+			movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, K_GetKartSpeed(player, true));
 
 		totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside);
 		totalthrust.y += P_ReturnThrustY(player->mo, movepushsideangle, movepushside);
 	}
 
 	if ((totalthrust.x || totalthrust.y)
-		&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2)
-	{
+		&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2) {
 		// Factor thrust to slope, but only for the part pushing up it!
 		// The rest is unaffected.
 		angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-player->mo->standingslope->xydirection;
@@ -2044,11 +2041,11 @@ static void P_3dMovement(player_t *player)
 	// -Shadow Hog
 	newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
 
-	if (newMagnitude > kartspd) //topspeed)
+	if (newMagnitude > K_GetKartSpeed(player, true)) //topspeed)
 	{
 		fixed_t tempmomx, tempmomy;
 
-		if (oldMagnitude > kartspd && onground) // SRB2Kart: onground check for air speed cap
+		if (oldMagnitude > K_GetKartSpeed(player, true) && onground) // SRB2Kart: onground check for air speed cap
 		{
 			if (newMagnitude > oldMagnitude)
 			{
@@ -2061,8 +2058,8 @@ static void P_3dMovement(player_t *player)
 		}
 		else
 		{
-			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), kartspd); //topspeed)
-			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), kartspd); //topspeed)
+			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
+			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
 			player->mo->momx = tempmomx + player->cmomx;
 			player->mo->momy = tempmomy + player->cmomy;
 		}
@@ -2477,10 +2474,9 @@ static void P_MovePlayer(player_t *player)
 		const fixed_t runnyspeed = 20*FRACUNIT;
 
 		speed = R_PointToDist2(player->rmomx, player->rmomy, 0, 0);
-		const fixed_t kartspd = K_GetKartSpeed(player, false);
 
-		if (speed > kartspd-(5<<FRACBITS))
-			speed = kartspd-(5<<FRACBITS);
+		if (speed > K_GetKartSpeed(player, false)-(5<<FRACBITS))
+			speed = K_GetKartSpeed(player, false)-(5<<FRACBITS);
 
 		if (speed >= runnyspeed)
 			player->fovadd = speed-runnyspeed;
@@ -4113,7 +4109,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
 			angle -= (angle - thiscam->pitch)/2;
 	}
 
-	if (player->playerstate != PST_DEAD && LIKELY(!((player->pflags & PF_NIGHTSMODE) && player->exiting)))
+	if (player->playerstate != PST_DEAD && !((player->pflags & PF_NIGHTSMODE) && player->exiting))
 		angle += (focusaiming < ANGLE_180 ? focusaiming/2 : InvAngle(InvAngle(focusaiming)/2)); // overcomplicated version of '((signed)focusaiming)/2;'
 
 	if (!camstill && !timeover) // Keep the view still...
@@ -4588,7 +4584,7 @@ void P_PlayerThink(player_t *player)
 	}
 
 #ifdef SEENAMES
-	if (netgame && !splitscreen && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)))
+	if (netgame && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)) && !splitscreen)
 	{
 		seenplayer = NULL;
 

src/r_data.c

@@ -622,7 +622,7 @@ Rloadtextures (INT32 i, INT32 w)
 
 		// Set texture properties.
 		memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
-		texture->hash = FNV1a_QuickCaseHash(texture->name, 8);
+		texture->hash = quickncasehash(texture->name, 8);
 
 		texture->width = SHORT(patchlump.width);
 		texture->height = SHORT(patchlump.height);
@@ -1066,7 +1066,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
 			// Allocate memory for a zero-patch texture. Obviously, we'll be adding patches momentarily.
 			resultTexture = (texture_t *)Z_Calloc(sizeof(texture_t), PU_STATIC, NULL);
 			memcpy(resultTexture->name, newTextureName, 8);
-			resultTexture->hash = FNV1a_QuickCaseHash(newTextureName, 8);
+			resultTexture->hash = quickncasehash(newTextureName, 8);
 			resultTexture->width = newTextureWidth;
 			resultTexture->height = newTextureHeight;
 			resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1755,7 +1755,7 @@ INT32 R_CheckTextureNumForName(const char *name)
 	if (name[0] == '-')
 		return 0;
 
-	hash = FNV1a_QuickCaseHash(name, 8);
+	hash = quickncasehash(name, 8);
 
 	for (i = 0; i < tidcachelen; i++)
 		if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))

src/r_draw.cpp

@@ -400,7 +400,7 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 			case TC_ALLWHITE:   skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
 			case TC_RAINBOW:    skintableindex = RAINBOW_TT_CACHE_INDEX; break;
 			case TC_BLINK:      skintableindex = BLINK_TT_CACHE_INDEX; break;
-			default:            skintableindex = skinnum; break;
+			default:       skintableindex = skinnum; break;
 		}
 	}
 
@@ -437,7 +437,8 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
 
 UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local)
 {
-	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
+	const INT32 skinnum = localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
+	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
 }
 
 patch_t* R_GetSkinFaceRank(player_t* ply)

src/r_main.cpp

@@ -280,22 +280,22 @@ static void Fov_OnChange(void)
 
 static void FlipCam_OnChange(void)
 {
-	SendWeaponPref(0);
+	SendWeaponPref();
 }
 
 static void FlipCam2_OnChange(void)
 {
-	SendWeaponPref(1);
+	SendWeaponPref2();
 }
 
 static void FlipCam3_OnChange(void)
 {
-	SendWeaponPref(2);
+	SendWeaponPref3();
 }
 
 static void FlipCam4_OnChange(void)
 {
-	SendWeaponPref(3);
+	SendWeaponPref4();
 }
 
 static void Precipstuff_OnChange(void)

src/r_segs.cpp

@@ -1222,15 +1222,6 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
 		if (yl < top)
 			yl = top;
 
-		// insanely shitty hack to fix flickering on some maps
-		// for god knows why, on secret slide the renderer assumes some double sided linedefs have insanely tall walls
-		// since such tall walls are effectively nonsense in any case
-		// just skip them
-		if (yl > FRACUNIT*3)
-		{
-			continue;
-		}
-
 		if (markceiling)
 		{
 			bottom = yl > floorclip[rw_x] ? floorclip[rw_x] : yl;

src/r_skins.h

@@ -92,7 +92,6 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local);
 // had to move those here Zzz...
 INT32 K_GetSkinNum(player_t *player);
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local);
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local);
 skin_t *K_GetPlayerSkin(player_t *player);
 skin_t *K_GetMobjSkin(const mobj_t *mobj);
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);

src/r_things.cpp

@@ -1662,7 +1662,7 @@ static void R_ProjectSprite(mobj_t *thing)
 
 	if (thing->frame & FF_ABSOLUTELIGHTLEVEL)
 	{
-		const UINT8 n = static_cast<UINT8>(R_ThingLightLevel(thing));
+		const UINT8 n = R_ThingLightLevel(thing);
 		// n = uint8 aka 0 - 255, so the shift will always be 0 - LIGHTLEVELS - 1
 		lights_array = scalelight[n >> LIGHTSEGSHIFT];
 	}
@@ -2960,24 +2960,21 @@ fixed_t R_DoPlayerFade(mobj_t *thing)
 	fixed_t fadealpha = FRACUNIT;
 	static constexpr tic_t countdownstarttime = (15 * TICRATE) / 4; // starttime - (3*TICRATE)
 
-	if (thing->player == viewplayer || viewplayer->exiting || viewplayer->spectator || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
+	if (thing->player == viewplayer || viewplayer->exiting || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
 		return fadealpha;
 
-	const INT32 otherplayerdist = (FixedMul((thing->x - viewx), viewcos) + FixedMul((thing->y - viewy), viewsin)) >> FRACBITS;
-	const INT32 viewplayerdist  = (FixedMul((viewplayer->mo->x - viewx), viewcos) + FixedMul((viewplayer->mo->y - viewy), viewsin)) >> FRACBITS;
+	const INT32 playerdist     = (FixedMul((thing->x - viewx), viewcos) + FixedMul((thing->y - viewy), viewsin)) >> FRACBITS;
+	const INT32 viewplayerdist = (FixedMul((viewplayer->mo->x - viewx), viewcos) + FixedMul((viewplayer->mo->y - viewy), viewsin)) >> FRACBITS;
 
-	if (viewplayerdist < 2)
-		return fadealpha; // avoid zero division
-
-	if (otherplayerdist < viewplayerdist)
+	if (playerdist < viewplayerdist)
 	{
-		if (otherplayerdist < viewplayerdist / 2) // stronger fade when very close
+		if (playerdist < viewplayerdist / 2) // stronger fade when very close
 		{
-			fadealpha = (otherplayerdist * FRACUNIT) / (viewplayerdist / 2) / 3;
+			fadealpha = (playerdist * FRACUNIT) / (viewplayerdist / 2) / 3;
 		}
 		else
 		{
-			fadealpha = (otherplayerdist * FRACUNIT) / viewplayerdist;
+			fadealpha = (playerdist * FRACUNIT) / viewplayerdist;
 		}
 	}
 

src/s_sound.c

@@ -116,7 +116,9 @@ consvar_t cv_skipintromusic = {"skipintromusic", "No", CV_SAVE, CV_YesNo, NULL,
 
 boolean keepmapmusic = false; // keep the current music on map restart
 boolean skipintromus = false; // skip the intro fanfare
+static boolean resumekeepmusic = false;
 static music_t keepmusic;
+static void S_SetKeepMusResume(void);
 
 #ifdef HAVE_OPENMPT
 openmpt_module *openmpt_mhandle = NULL;
@@ -1299,7 +1301,7 @@ static boolean ReadMusicDefFields(UINT16 wadnum, int line, char *stoken, musicde
 
 				STRBUFCPY(def->name, value);
 				strlwr(def->name);
-				def->hash = FNV1a_QuickCaseHash(def->name, 6);
+				def->hash = quickncasehash (def->name, 6);
 			}
 
 			(*defp) = def;
@@ -1436,7 +1438,7 @@ void S_LoadMusicDefs(UINT16 wadnum)
 			stoken = strtok(stoken, " ");
 			if (stoken)
 			{
-				if (!ReadMusicDefFields(wadnum, line, stoken, &def))
+				if (! ReadMusicDefFields(wadnum, line, stoken, &def))
 					break;
 			}
 
@@ -1481,7 +1483,7 @@ void S_InitMusicDefs(void)
 //
 musicdef_t *S_FindMusicCredit(const char *musname)
 {
-	UINT32 hash = FNV1a_QuickCaseHash(musname, 6);
+	UINT32 hash = quickncasehash(musname, 6);
 	musicdef_t *def;
 
 	for (INT32 i = 0; i < nummusicdefs; ++i)
@@ -1846,6 +1848,8 @@ void S_StopMusic(void)
 
 	mapmusic.resume = (cv_resume.value && fasticmp(music.name, mapmusic.name)) ? I_GetSongPosition() : 0;
 
+	S_SetKeepMusResume();
+
 	if (I_SongPaused())
 		I_ResumeSong();
 
@@ -1972,6 +1976,17 @@ void S_ResetKeepAndSpecialMus(void)
 	keepmapmusic = skipintromus = false;
 }
 
+// saves the current song position everytime a song stops
+// so we can resume it in some cases
+static void S_SetKeepMusResume(void)
+{
+	keepmusic.resume = 0;
+
+	if (fasticmp(music.name, mapmusic.name))
+	{
+		keepmusic.resume = I_GetSongPosition();
+	}
+}
 
 // determine if we should keep the music on a map restart
 // this gets called BEFORE the level gets loaded in G_DoLoadLevel
@@ -1980,7 +1995,7 @@ void S_KeepMusic(void)
 	static INT16 oldmap = -1;
 	static boolean oldencore = false;
 
-	keepmapmusic = false;
+	keepmapmusic = resumekeepmusic = false;
 
 	if (!cv_keepmusic.value)
 	{
@@ -1994,7 +2009,9 @@ void S_KeepMusic(void)
 
 	if (oldmap == gamemap && oldencore == encoremode)
 	{
-		keepmapmusic = (S_CheckMusicException() == false);
+		const boolean musicchanged = S_CheckMusicException();
+		resumekeepmusic = (musicchanged && keepmusic.resume);
+		keepmapmusic = (!musicchanged || resumekeepmusic);
 	}
 
 	oldencore = encoremode;
@@ -2055,6 +2072,12 @@ void S_InitMapMusic(void)
 
 	if (keepmapmusic)
 	{
+		// this is kinda silly, but we can use it to fade back into the map song at the saved point, should the current music be different from the map music
+		if (resumekeepmusic)
+		{
+			S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, keepmusic.resume, 0, 500);
+		}
+
 		return;
 	}
 

src/sdl/i_system.cpp

@@ -1577,7 +1577,7 @@ static void write_backtrace(bt_crash_reason_t reason)
 static std::thread::id g_main_thread_id;
 #endif
 
-static volatile sig_atomic_t g_in_exiting_signal_handler = false;
+boolean g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg, char *signal_name)
 {
@@ -1712,11 +1712,6 @@ static void I_ReportSignal(int num, int coredumped)
 	I_ShowErrorBox(sigttl, sigmsg);
 }
 
-boolean I_In_Exiting_Signal_Handler(void)
-{
-	return g_in_exiting_signal_handler;
-}
-
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1746,17 +1741,21 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-static volatile sig_atomic_t interrupted = false;
-
-boolean I_Interrupted(void)
+FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
 {
-	return interrupted;
-}
+#ifdef HAVE_THREADS
+	if (g_main_thread_id != std::this_thread::get_id())
+	{
+		// Do not attempt any sort of recovery if this signal triggers off the main thread
+		signal(num, SIG_DFL);
+		raise(num);
+		exit(-2);
+	}
+#endif
 
-static void quit_handler(int num)
-{
-	(void)num;
-	interrupted = true;
+	signal(num, SIG_DFL); //default signal action
+	raise(num);
+	I_Quit();
 }
 
 static void I_RegisterSignals(void)
@@ -1886,9 +1885,6 @@ INT32 I_StartupSystem(void)
 	SDL_version SDLlinked;
 	SDL_VERSION(&SDLcompiled)
 	SDL_GetVersion(&SDLlinked);
-
-	W_Startup();
-
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to

src/sdl/i_video.c

@@ -2027,8 +2027,7 @@ void I_ShutdownGraphics(void)
 		SDL_DestroyWindow(window);
 	window = NULL;
 
-	if (SDL_WasInit(SDL_INIT_VIDEO) == SDL_INIT_VIDEO)
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
 	framebuffer = SDL_FALSE;
 }
 

src/sdl/mixer_sound.c

@@ -216,13 +216,8 @@ void I_StartupSound(void)
 				SDLmixlinked->major, SDLmixlinked->minor, SDLmixlinked->patch);
 
 #ifdef HAVE_OPENMPT
-	const char *openmptstr;
-	openmptstr = openmpt_get_string("library_version");
-	I_OutputMsg("libopenmpt version: %s\n", openmptstr);
-	openmpt_free_string(openmptstr);
-	openmptstr = openmpt_get_string("build");
-	I_OutputMsg("libopenmpt build date: %s\n", openmptstr);
-	openmpt_free_string(openmptstr);
+	I_OutputMsg("libopenmpt version: %s\n", openmpt_get_string("library_version"));
+	I_OutputMsg("libopenmpt build date: %s\n", openmpt_get_string("build"));
 #endif
 
 	sound_started = true;
@@ -242,8 +237,7 @@ void I_ShutdownSound(void)
 	Mix_Quit();
 #endif
 
-	if (SDL_WasInit(SDL_INIT_AUDIO) == SDL_INIT_AUDIO)
-		SDL_QuitSubSystem(SDL_INIT_AUDIO);
+	SDL_QuitSubSystem(SDL_INIT_AUDIO);
 
 #ifdef HAVE_LIBGME
 	if (gme)

src/st_stuff.c

@@ -180,7 +180,7 @@ static void ST_doPaletteStuff(void)
 	INT32 palette = 0;
 
 #ifdef HWRENDER
-	if (rendermode == render_opengl && !HWR_ShouldUsePaletteRendering())
+	if (rendermode == render_opengl && !HWR_PalRenderFlashpal())
 		return;
 #endif
 

src/strcasestr.c

@@ -23,26 +23,24 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef _GNU_SOURCE
-
 #include <string.h>
 #include <ctype.h>
 #include <stddef.h>
 
-static inline int trycmp(char **pp, char *cp, const char *q, size_t qn)
+static inline int
+trycmp (char **pp, char *cp,
+		const char *q, size_t qn)
 {
 	char *p;
 	p = (*pp);
-
 	if (strncasecmp(p, q, qn) == 0)
 		return 0;
-
 	(*pp) = strchr(&p[1], (*cp));
-
 	return 1;
 }
 
-static inline void swapp(char ***ppap, char ***ppbp, char **cpap, char **cpbp)
+static inline void
+swapp (char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 {
 	char **pp;
 	char  *p;
@@ -56,7 +54,8 @@ static inline void swapp(char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 	*cpbp =   p;
 }
 
-char *nongnu_strcasestr(const char *s, const char *q)
+char *
+nongnu_strcasestr (const char *s, const char *q)
 {
 	size_t  qn;
 
@@ -114,5 +113,3 @@ char *nongnu_strcasestr(const char *s, const char *q)
 
 	return NULL;
 }
-
-#endif

src/v_paldeltas.h

@@ -1,525 +0,0 @@
-#ifndef H_PALDELTA
-#define H_PALDELTA
-
-// those are the differences in palette indices between the main srb2 playpal and its white and nuke subpalettes
-// this is probably not the best way of doing any of this, but it works lol
-
-static const INT16 pPaletteDeltaFlash[256][3] = {
-    {   6,   6,   6},
-    {  12,  12,  12},
-    {  18,  18,  18},
-    {  24,  24,  24},
-    {  30,  30,  30},
-    {  36,  36,  36},
-    {  42,  42,  42},
-    {  48,  48,  48},
-    {  54,  54,  54},
-    {  60,  60,  60},
-    {  66,  66,  66},
-    {  72,  72,  72},
-    {  78,  78,  78},
-    {  84,  84,  84},
-    {  90,  90,  90},
-    {  95,  95,  95},
-    { 101, 101, 101},
-    { 107, 107, 107},
-    { 113, 113, 113},
-    { 119, 119, 119},
-    { 125, 125, 125},
-    { 131, 131, 131},
-    { 137, 137, 137},
-    { 143, 143, 143},
-    { 149, 149, 149},
-    { 155, 155, 155},
-    { 161, 161, 161},
-    { 167, 167, 167},
-    { 173, 173, 173},
-    { 179, 179, 179},
-    { 185, 185, 185},
-    { 191, 191, 191},
-    {  48,  66,  84},
-    {  54,  71,  89},
-    {  60,  77,  95},
-    {  66,  83, 100},
-    {  72,  88, 105},
-    {  79,  94, 111},
-    {  85,  99, 117},
-    {  91, 105, 123},
-    {  96, 111, 129},
-    { 102, 117, 135},
-    { 108, 123, 141},
-    { 114, 128, 146},
-    { 120, 134, 152},
-    { 127, 140, 158},
-    { 133, 145, 163},
-    { 140, 152, 170},
-    {  48,  98, 134},
-    {  57, 104, 137},
-    {  63, 107, 140},
-    {  69, 110, 143},
-    {  75, 116, 146},
-    {  84, 119, 149},
-    {  90, 125, 152},
-    {  95, 128, 155},
-    { 101, 131, 158},
-    { 110, 137, 161},
-    { 119, 140, 164},
-    { 128, 143, 167},
-    { 134, 149, 170},
-    { 143, 155, 173},
-    { 152, 158, 176},
-    { 158, 164, 179},
-    {   0,  15,  24},
-    {   0,  21,  33},
-    {   0,  27,  42},
-    {   0,  33,  51},
-    {   0,  36,  57},
-    {   0,  42,  66},
-    {   0,  48,  75},
-    {   0,  51,  81},
-    {   0,  57,  93},
-    {   6,  63,  98},
-    {  12,  69, 104},
-    {  18,  75, 110},
-    {  24,  81, 116},
-    {  30,  87, 122},
-    {  36,  93, 128},
-    {  39,  95, 131},
-    {   0,  12,  26},
-    {   0,  26,  52},
-    {   0,  39,  78},
-    {   0,  52, 102},
-    {   0,  65, 127},
-    {   0,  78, 150},
-    {   0,  91, 172},
-    {   0, 102, 191},
-    {   9, 108, 191},
-    {  19, 114, 191},
-    {  29, 120, 191},
-    {  39, 127, 191},
-    {  48, 133, 191},
-    {  58, 139, 191},
-    {  68, 145, 191},
-    {  78, 150, 191},
-    {   0,   0,  12},
-    {   0,   0,  36},
-    {   0,   0,  60},
-    {   0,   0,  84},
-    {   0,   0, 107},
-    {   0,   0, 131},
-    {   0,   0, 155},
-    {   0,   0, 179},
-    {   0,   0, 191},
-    {  36,  36, 191},
-    {  60,  60, 191},
-    {  84,  84, 191},
-    { 107, 107, 191},
-    { 131, 131, 191},
-    { 155, 155, 191},
-    { 179, 179, 191},
-    {   0,   0, 104},
-    {  15,  27, 125},
-    {  30,  51, 140},
-    {  45,  75, 155},
-    {  60,  98, 167},
-    {  75, 122, 176},
-    {  90, 140, 185},
-    { 104, 158, 191},
-    {   0,   0,   0},
-    {   0,  24,  24},
-    {   0,  48,  48},
-    {   0,  72,  72},
-    {   0,  95,  95},
-    {   0, 119, 119},
-    {   0, 143, 143},
-    {   0, 167, 167},
-    {   0, 191, 191},
-    {  12, 191, 191},
-    {  24, 191, 191},
-    {  36, 191, 191},
-    {  48, 191, 191},
-    {  60, 191, 191},
-    {  72, 191, 191},
-    {  84, 191, 191},
-    {  95, 191, 191},
-    { 107, 191, 191},
-    { 119, 191, 191},
-    { 131, 191, 191},
-    { 143, 191, 191},
-    { 155, 191, 191},
-    { 167, 191, 191},
-    { 179, 191, 191},
-    {   0,  54,  54},
-    {   9,  69,  69},
-    {  18,  84,  84},
-    {  27,  98,  98},
-    {  39, 110, 110},
-    {  48, 122, 122},
-    {  57, 131, 131},
-    {  66, 143, 143},
-    {  85, 156, 191},
-    {  91, 161, 191},
-    {  96, 166, 191},
-    { 102, 172, 191},
-    { 108, 177, 191},
-    { 114, 182, 191},
-    { 120, 187, 191},
-    { 127, 191, 191},
-    { 101,   0, 131},
-    { 106,  11, 134},
-    { 111,  23, 138},
-    { 117,  35, 142},
-    { 123,  47, 145},
-    { 129,  59, 149},
-    { 134,  71, 153},
-    { 140,  83, 157},
-    { 145,  95, 160},
-    { 151, 106, 164},
-    { 157, 118, 168},
-    { 162, 130, 172},
-    { 168, 142, 175},
-    { 173, 154, 179},
-    { 179, 166, 183},
-    { 185, 179, 187},
-    {  24,   0,  65},
-    {  42,  20,  80},
-    {  61,  41,  95},
-    {  79,  61, 110},
-    {  97,  82, 124},
-    { 115, 101, 139},
-    { 135, 123, 154},
-    { 153, 143, 169},
-    { 191,   0, 191},
-    { 191,  24, 191},
-    { 191,  48, 191},
-    { 191,  72, 191},
-    { 191,  95, 191},
-    { 191, 119, 191},
-    { 191, 143, 191},
-    { 191, 167, 191},
-    {   0, 107,   0},
-    {   0, 191,   0},
-    {  24, 191,  24},
-    {  48, 191,  48},
-    {  72, 191,  72},
-    {  95, 191,  95},
-    { 119, 191, 119},
-    { 143, 191, 143},
-    {  16,  16,   9},
-    {  44,  44,  22},
-    {  73,  73,  36},
-    { 101, 101,  51},
-    { 127, 127,  66},
-    { 142, 142,  93},
-    { 156, 156, 121},
-    { 170, 170, 151},
-    {  31,  10,   0},
-    {  48,  15,   0},
-    {  64,  21,   0},
-    {  79,  25,   0},
-    {  95,  30,   0},
-    { 111,  36,   0},
-    { 127,  41,   0},
-    { 143,  48,   0},
-    { 149,  73,  24},
-    { 155,  84,  48},
-    { 161, 101,  72},
-    { 167, 119,  95},
-    { 191,  48,  48},
-    { 191,  95,  95},
-    { 191, 119, 119},
-    { 191, 143, 143},
-    {  18,  18,   0},
-    {  42,  42,   0},
-    {  61,  61,   0},
-    {  86,  86,   0},
-    { 104, 104,   0},
-    { 129, 129,   0},
-    { 154, 154,   0},
-    { 172, 172,   0},
-    { 191, 191,   0},
-    { 191, 191,  18},
-    { 191, 191,  36},
-    { 191, 191,  55},
-    { 191, 191,  74},
-    { 191, 191,  92},
-    { 191, 191, 110},
-    { 191, 191, 129},
-    { 191, 191, 131},
-    { 191, 191, 143},
-    { 191, 191, 149},
-    { 191, 191, 161},
-    { 191, 191, 167},
-    { 191, 191, 179},
-    { 191, 191, 185},
-    { 191,   0,   0},
-    {  36,  95,  36},
-    {  54, 107,  54},
-    {  72, 119,  72},
-    {  90, 131,  90},
-    { 107, 143, 107},
-    { 125, 155, 125},
-    { 143, 167, 143},
-    { 161, 179, 161}
-};
-
-static const INT16 pPaletteDeltaNuke[256][3] = {
-    {   6,-133,-133},
-    {  12,-125,-125},
-    {  18,-117,-117},
-    {  24,-109,-109},
-    {  30,-101,-101},
-    {  36, -93, -93},
-    {  42, -85, -85},
-    {  48, -77, -77},
-    {  54, -69, -69},
-    {  60, -61, -61},
-    {  66, -53, -53},
-    {  72, -45, -45},
-    {  78, -37, -37},
-    {  84, -29, -29},
-    {  90, -21, -21},
-    {  95, -14, -14},
-    { 101,  -6,  -6},
-    { 107,   2,   2},
-    { 113,  10,  10},
-    { 119,  18,  18},
-    { 125,  26,  26},
-    { 131,  34,  34},
-    { 137,  42,  42},
-    { 143,  50,  50},
-    { 149,  58,  58},
-    { 155,  66,  66},
-    { 161,  74,  74},
-    { 167,  82,  82},
-    { 173,  90,  90},
-    { 179,  98,  98},
-    { 185, 106, 106},
-    { 191, 113, 113},
-    {  48, -53, -29},
-    {  54, -46, -22},
-    {  60, -38, -14},
-    {  66, -30,  -7},
-    {  72, -23,   0},
-    {  79, -15,   8},
-    {  85,  -8,  16},
-    {  91,  -1,  23},
-    {  96,   7,  31},
-    { 102,  15,  39},
-    { 108,  23,  47},
-    { 114,  30,  54},
-    { 120,  38,  62},
-    { 127,  46,  70},
-    { 133,  53,  77},
-    { 140,  62,  86},
-    {  48, -10,  38},
-    {  57,  -2,  42},
-    {  63,   2,  46},
-    {  69,   6,  50},
-    {  75,  14,  54},
-    {  84,  18,  58},
-    {  90,  26,  62},
-    {  95,  30,  66},
-    { 101,  34,  70},
-    { 110,  42,  74},
-    { 119,  46,  78},
-    { 128,  50,  82},
-    { 134,  58,  86},
-    { 143,  66,  90},
-    { 152,  70,  94},
-    { 158,  78,  98},
-    {   0,-121,-109},
-    {   0,-113, -97},
-    {   0,-105, -85},
-    {   0, -97, -73},
-    {   0, -93, -65},
-    {   0, -85, -53},
-    {   0, -77, -41},
-    {   0, -73, -33},
-    {   0, -65, -17},
-    {   6, -57, -10},
-    {  12, -49,  -2},
-    {  18, -41,   6},
-    {  24, -33,  14},
-    {  30, -25,  22},
-    {  36, -17,  30},
-    {  39, -14,  34},
-    {   0,-124,-106},
-    {   0,-106, -71},
-    {   0, -89, -37},
-    {   0, -71,  -4},
-    {   0, -54,  28},
-    {   0, -37,  59},
-    {   0, -20,  88},
-    {   0,  -4, 113},
-    {   9,   4, 113},
-    {  19,  12, 113},
-    {  29,  20, 113},
-    {  39,  28, 113},
-    {  48,  36, 113},
-    {  58,  44, 113},
-    {  68,  52, 113},
-    {  78,  59, 113},
-    {   0,-141,-125},
-    {   0,-141, -93},
-    {   0,-141, -61},
-    {   0,-141, -29},
-    {   0,-141,   2},
-    {   0,-141,  34},
-    {   0,-141,  66},
-    {   0,-141,  98},
-    {   0,-141, 113},
-    {  36, -93, 113},
-    {  60, -61, 113},
-    {  84, -29, 113},
-    { 107,   2, 113},
-    { 131,  34, 113},
-    { 155,  66, 113},
-    { 179,  98, 113},
-    {   0,-141,  -2},
-    {  15,-105,  26},
-    {  30, -73,  46},
-    {  45, -41,  66},
-    {  60, -10,  82},
-    {  75,  22,  94},
-    {  90,  46, 106},
-    { 104,  70, 113},
-    {   0,-141,-141},
-    {   0,-109,-109},
-    {   0, -77, -77},
-    {   0, -45, -45},
-    {   0, -14, -14},
-    {   0,  18,  18},
-    {   0,  50,  50},
-    {   0,  82,  82},
-    {   0, 113, 113},
-    {  12, 113, 113},
-    {  24, 113, 113},
-    {  36, 113, 113},
-    {  48, 113, 113},
-    {  60, 113, 113},
-    {  72, 113, 113},
-    {  84, 113, 113},
-    {  95, 113, 113},
-    { 107, 113, 113},
-    { 119, 113, 113},
-    { 131, 113, 113},
-    { 143, 113, 113},
-    { 155, 113, 113},
-    { 167, 113, 113},
-    { 179, 113, 113},
-    {   0, -69, -69},
-    {   9, -49, -49},
-    {  18, -29, -29},
-    {  27, -10, -10},
-    {  39,   6,   6},
-    {  48,  22,  22},
-    {  57,  34,  34},
-    {  66,  50,  50},
-    {  85,  67, 113},
-    {  91,  74, 113},
-    {  96,  81, 113},
-    { 102,  88, 113},
-    { 108,  95, 113},
-    { 114, 102, 113},
-    { 120, 108, 113},
-    { 127, 113, 113},
-    { 101,-141,  34},
-    { 106,-126,  38},
-    { 111,-110,  43},
-    { 117, -94,  48},
-    { 123, -78,  53},
-    { 129, -62,  58},
-    { 134, -46,  63},
-    { 140, -30,  68},
-    { 145, -14,  73},
-    { 151,   1,  78},
-    { 157,  17,  83},
-    { 162,  33,  88},
-    { 168,  49,  93},
-    { 173,  65,  98},
-    { 179,  81, 103},
-    { 185,  98, 109},
-    {  24,-141, -54},
-    {  42,-114, -34},
-    {  61, -86, -14},
-    {  79, -59,   6},
-    {  97, -32,  25},
-    { 115,  -6,  45},
-    { 135,  23,  65},
-    { 153,  50,  84},
-    { 191,-141, 113},
-    { 191,-109, 113},
-    { 191, -77, 113},
-    { 191, -45, 113},
-    { 191, -14, 113},
-    { 191,  18, 113},
-    { 191,  50, 113},
-    { 191,  82, 113},
-    {   0,   2,-141},
-    {   0, 113,-141},
-    {  24, 113,-109},
-    {  48, 113, -77},
-    {  72, 113, -45},
-    {  95, 113, -14},
-    { 119, 113,  18},
-    { 143, 113,  50},
-    {  16,-119,-129},
-    {  44, -82,-111},
-    {  73, -43, -92},
-    { 101,  -6, -73},
-    { 127,  29, -53},
-    { 142,  48, -17},
-    { 156,  67,  21},
-    { 170,  86,  61},
-    {  31,-127,-141},
-    {  48,-121,-141},
-    {  64,-113,-141},
-    {  79,-107,-141},
-    {  95,-100,-141},
-    { 111, -93,-141},
-    { 127, -86,-141},
-    { 143, -77,-141},
-    { 149, -43,-109},
-    { 155, -29, -77},
-    { 161,  -6, -45},
-    { 167,  18, -14},
-    { 191, -77, -77},
-    { 191, -14, -14},
-    { 191,  18,  18},
-    { 191,  50,  50},
-    {  18,-117,-141},
-    {  42, -84,-141},
-    {  61, -59,-141},
-    {  86, -26,-141},
-    { 104,  -2,-141},
-    { 129,  31,-141},
-    { 154,  64,-141},
-    { 172,  89,-141},
-    { 191, 113,-141},
-    { 191, 113,-117},
-    { 191, 113, -92},
-    { 191, 113, -67},
-    { 191, 113, -42},
-    { 191, 113, -18},
-    { 191, 113,   6},
-    { 191, 113,  31},
-    { 191, 113,  34},
-    { 191, 113,  50},
-    { 191, 113,  58},
-    { 191, 113,  74},
-    { 191, 113,  82},
-    { 191, 113,  98},
-    { 191, 113, 106},
-    { 191,-141,-141},
-    {  36, -14, -93},
-    {  54,   2, -69},
-    {  72,  18, -45},
-    {  90,  34, -21},
-    { 107,  50,   2},
-    { 125,  66,  26},
-    { 143,  82,  50},
-    { 161,  98,  74}
-};
-
-#endif

src/v_video.c

@@ -91,7 +91,6 @@ consvar_t cv_menucaps = {"menucaps", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NUL
 // local copy of the palette for V_GetColor()
 RGBA_t *pLocalPalette = NULL;
 RGBA_t *pGammaCorrectedPalette = NULL;
-static RGBA_t *pFallbackFlashPal = NULL;
 
 static size_t currentPaletteSize;
 
@@ -410,58 +409,6 @@ UINT32 V_GammaCorrect(UINT32 input, double power)
 	return result.rgba;
 }
 
-#include "v_paldeltas.h"
-// remaps a palette with given "deltas"
-// this is used with premade deltas between the srb2 palette and its both flashpals
-// so we may approximate generate our own, should the current palette miss them
-static void ApplyPaletteDelta(const RGBA_t *pal_in, RGBA_t *pal_out, const INT16 pal_delta[][3])
-{
-	size_t i;
-
-	for (i = 0; i < 256; i++)
-	{
-		INT16 r = (INT16)pal_in[i].s.red   + pal_delta[i][0];
-		INT16 g = (INT16)pal_in[i].s.green + pal_delta[i][1];
-		INT16 b = (INT16)pal_in[i].s.blue  + pal_delta[i][2];
-		pal_out[i].s.red   = (UINT8)CLAMP(r, 0 , 255);
-		pal_out[i].s.green = (UINT8)CLAMP(g, 0 , 255);
-		pal_out[i].s.blue  = (UINT8)CLAMP(b, 0 , 255);
-		pal_out[i].s.alpha = 0xFF; // pal_in[i].s.alpha
-	}
-}
-
-static void GenerateFlashPalettes(void)
-{
-	size_t i, palsize;
-	RGBA_t *pFlashPalGammaCorrectedPalette = NULL;
-
-	// generate flashpalettes if the current palette does not provide any subpalettes
-	if (currentPaletteSize >= (14 * (256 * 3))) // 14 palettes are in playpal
-		return;
-
-	palsize = (2*256);
-
-	pFallbackFlashPal = Z_Malloc(sizeof(*pFallbackFlashPal)*palsize, PU_STATIC, NULL);
-	pFlashPalGammaCorrectedPalette = Z_Malloc(sizeof (*pFlashPalGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
-
-	// apply our deltas to the palettes to get the white and red "flashes"
-	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal, pPaletteDeltaFlash);
-	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal+256, pPaletteDeltaNuke);
-
-	// apply colour and gamma correction if needed
-	if (Cubeapply)
-	{
-		for (i = 0; i < palsize; i++)
-		{
-			pFlashPalGammaCorrectedPalette[i].rgba = V_GammaDecode(pFallbackFlashPal[i].rgba);
-			V_CubeApply(&pFlashPalGammaCorrectedPalette[i]);
-			pFallbackFlashPal[i].rgba = V_GammaEncode(pFlashPalGammaCorrectedPalette[i].rgba);
-		}
-	}
-
-	Z_Free(pFlashPalGammaCorrectedPalette);
-}
-
 // keep a copy of the palette so that we can get the RGB value for a color index at any time.
 static void LoadPalette(const char *lumpname)
 {
@@ -481,8 +428,6 @@ static void LoadPalette(const char *lumpname)
 
 	Z_Free(pLocalPalette);
 	Z_Free(pGammaCorrectedPalette);
-	Z_Free(pFallbackFlashPal);
-	pFallbackFlashPal = NULL;
 
 	pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
 	pGammaCorrectedPalette = Z_Malloc(sizeof (*pGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
@@ -502,19 +447,12 @@ static void LoadPalette(const char *lumpname)
 		pLocalPalette[i].s.alpha = 0xFF;
 
 		pGammaCorrectedPalette[i].rgba = V_GammaDecode(pLocalPalette[i].rgba);
-	}
 
-	GenerateFlashPalettes();
+		if (!Cubeapply)
+			continue;
 
-	// gotta apply any colour and gamma adjustments afterwards
-	// so we dont double apply it to the generated flashpals
-	if (Cubeapply)
-	{
-		for (i = 0; i < palsize; i++)
-		{
-			V_CubeApply(&pGammaCorrectedPalette[i]);
-			pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
-		}
+		V_CubeApply(&pGammaCorrectedPalette[i]);
+		pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
 	}
 }
 
@@ -605,7 +543,6 @@ void V_ReloadPalette(void)
 // -------------+
 void V_SetPalette(INT32 palettenum)
 {
-	RGBA_t *pal = NULL;
 	if (!pLocalPalette)
 		V_ReloadPalette();
 
@@ -617,47 +554,24 @@ void V_SetPalette(INT32 palettenum)
 		if (palettenum == 0)
 		{
 			palettenum = cv_palettenum.value;
-		}
-	}
 
-	// in many cases custom palettes do not provide the needed subpalettes for flashpals to work
-	// before this would mean the renderer gets passed random data out of allocated memory bounds
-	// which was not very cool :chonkbuncle:
-	// gladly 2.1 only actually has 2 different subpalettes
-	// one for "white flash" and one red/pinkish one for nuke
-	// since we checked the palette earlier we should have generated those ourselves
-	if (((size_t)palettenum >= currentPaletteSize / (256 * 3)))
-	{
-		CONS_Debug(DBG_RENDER, "palettenum %d out of range\n", palettenum);
-
-		// if for some reason we did not generate flashpals
-		// just fall back to the main palette i guess?
-		if (pFallbackFlashPal != NULL)
-		{
-			if (palettenum == PAL_NUKE)
-				pal = &pFallbackFlashPal[256];
-			else
-				pal = pFallbackFlashPal;
+			if (palettenum * 256U > currentPaletteSize - 256)
+			{
+				CONS_Alert(CONS_WARNING, "cv_palettenum %d out of range\n", palettenum);
+				palettenum = 0;
+			}
 		}
-		else
-		{
-			pal = pLocalPalette;
-		}
-	}
-	else
-	{
-		pal = &pLocalPalette[palettenum*256];
 	}
 
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_SetPalette(pal);
+		HWR_SetPalette(&pLocalPalette[palettenum*256]);
 #if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
 	else
 #endif
 #endif
 	if (rendermode != render_none)
-		I_SetPalette(pal);
+		I_SetPalette(&pLocalPalette[palettenum*256]);
 }
 
 void V_SetPaletteLump(const char *pal)
@@ -3395,6 +3309,167 @@ INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option)
 	return max(i-1, 0);
 }
 
+char V_GetSkincolorChar(INT32 color)
+{
+	char cstart = 0x80;
+
+	switch (color)
+	{
+		case SKINCOLOR_WHITE:
+		case SKINCOLOR_SILVER:
+		case SKINCOLOR_SLATE:
+			cstart = 0x80; // White
+			break;
+
+		case SKINCOLOR_GREY:
+		case SKINCOLOR_NICKEL:
+		case SKINCOLOR_BLACK:
+		case SKINCOLOR_SKUNK:
+		case SKINCOLOR_JET:
+			cstart = 0x86; // V_GRAYMAP
+			break;
+
+		case SKINCOLOR_SEPIA:
+		case SKINCOLOR_BEIGE:
+		case SKINCOLOR_WALNUT:
+		case SKINCOLOR_BROWN:
+		case SKINCOLOR_LEATHER:
+		case SKINCOLOR_RUST:
+		case SKINCOLOR_WRISTWATCH:
+			cstart = 0x8e; // V_BROWNMAP
+			break;
+
+		case SKINCOLOR_FAIRY:
+		case SKINCOLOR_SALMON:
+		case SKINCOLOR_PINK:
+		case SKINCOLOR_ROSE:
+		case SKINCOLOR_BRICK:
+		case SKINCOLOR_LEMONADE:
+		case SKINCOLOR_BUBBLEGUM:
+		case SKINCOLOR_LILAC:
+			cstart = 0x8d; // V_PINKMAP
+			break;
+
+		case SKINCOLOR_CINNAMON:
+		case SKINCOLOR_RUBY:
+		case SKINCOLOR_RASPBERRY:
+		case SKINCOLOR_CHERRY:
+		case SKINCOLOR_RED:
+		case SKINCOLOR_CRIMSON:
+		case SKINCOLOR_MAROON:
+		case SKINCOLOR_FLAME:
+		case SKINCOLOR_SCARLET:
+		case SKINCOLOR_KETCHUP:
+			cstart = 0x85; // V_REDMAP
+			break;
+
+		case SKINCOLOR_DAWN:
+		case SKINCOLOR_SUNSET:
+		case SKINCOLOR_CREAMSICLE:
+		case SKINCOLOR_ORANGE:
+		case SKINCOLOR_PUMPKIN:
+		case SKINCOLOR_ROSEWOOD:
+		case SKINCOLOR_BURGUNDY:
+		case SKINCOLOR_TANGERINE:
+			cstart = 0x87; // V_ORANGEMAP
+			break;
+
+		case SKINCOLOR_PEACH:
+		case SKINCOLOR_CARAMEL:
+		case SKINCOLOR_CREAM:
+			cstart = 0x8f; // V_PEACHMAP
+			break;
+
+		case SKINCOLOR_GOLD:
+		case SKINCOLOR_ROYAL:
+		case SKINCOLOR_BRONZE:
+		case SKINCOLOR_COPPER:
+		case SKINCOLOR_THUNDER:
+			cstart = 0x8a; // V_GOLDMAP
+			break;
+
+		case SKINCOLOR_POPCORN:
+		case SKINCOLOR_QUARRY:
+		case SKINCOLOR_YELLOW:
+		case SKINCOLOR_MUSTARD:
+		case SKINCOLOR_CROCODILE:
+		case SKINCOLOR_OLIVE:
+			cstart = 0x82; // V_YELLOWMAP
+			break;
+
+		case SKINCOLOR_ARTICHOKE:
+		case SKINCOLOR_VOMIT:
+		case SKINCOLOR_GARDEN:
+		case SKINCOLOR_TEA:
+		case SKINCOLOR_PISTACHIO:
+			cstart = 0x8b; // V_TEAMAP
+			break;
+
+		case SKINCOLOR_LIME:
+		case SKINCOLOR_HANDHELD:
+		case SKINCOLOR_MOSS:
+		case SKINCOLOR_CAMOUFLAGE:
+		case SKINCOLOR_ROBOHOOD:
+		case SKINCOLOR_MINT:
+		case SKINCOLOR_GREEN:
+		case SKINCOLOR_PINETREE:
+		case SKINCOLOR_EMERALD:
+		case SKINCOLOR_SWAMP:
+		case SKINCOLOR_DREAM:
+		case SKINCOLOR_PLAGUE:
+		case SKINCOLOR_ALGAE:
+			cstart = 0x83; // V_GREENMAP
+			break;
+
+		case SKINCOLOR_CARIBBEAN:
+		case SKINCOLOR_AZURE:
+		case SKINCOLOR_AQUA:
+		case SKINCOLOR_TEAL:
+		case SKINCOLOR_CYAN:
+		case SKINCOLOR_JAWZ:
+		case SKINCOLOR_CERULEAN:
+		case SKINCOLOR_NAVY:
+		case SKINCOLOR_SAPPHIRE:
+			cstart = 0x88; // V_SKYMAP
+			break;
+
+		case SKINCOLOR_PIGEON:
+		case SKINCOLOR_PLATINUM:
+		case SKINCOLOR_STEEL:
+			cstart = 0x8c; // V_STEELMAP
+			break;
+
+		case SKINCOLOR_PERIWINKLE:
+		case SKINCOLOR_BLUE:
+		case SKINCOLOR_BLUEBERRY:
+		case SKINCOLOR_NOVA:
+			cstart = 0x84; // V_BLUEMAP
+			break;
+
+		case SKINCOLOR_ULTRAVIOLET:
+		case SKINCOLOR_PURPLE:
+		case SKINCOLOR_FUCHSIA:
+			cstart = 0x81; // V_PURPLEMAP
+			break;
+
+		case SKINCOLOR_PASTEL:
+		case SKINCOLOR_MOONSLAM:
+		case SKINCOLOR_DUSK:
+		case SKINCOLOR_TOXIC:
+		case SKINCOLOR_MAUVE:
+		case SKINCOLOR_LAVENDER:
+		case SKINCOLOR_BYZANTIUM:
+		case SKINCOLOR_POMEGRANATE:
+			cstart = 0x89; // V_LAVENDERMAP
+			break;
+
+		default:
+			break;
+	}
+
+	return cstart;
+}
+
 INT32 V_SkinColorToHighlightcolor(skincolors_t color)
 {
 	switch (color)

src/v_video.h

@@ -287,6 +287,8 @@ INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 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);
+
 INT32 V_SkinColorToHighlightcolor(skincolors_t color);
 
 // this is pretty dumb, but has to be done like this, otherwise the fps counter just disappears sometimes for no reason lol

src/w_wad.c

@@ -87,32 +87,18 @@ typedef struct
 } lumpchecklist_t;
 
 // Must be a power of two
-#define LUMPNUMCACHESIZE 2048 // should be reasonable ig
+#define LUMPNUMCACHESIZE 64
 #define LUMPNUMCACHENAME 32
 
-#define NAME      lumpnum_map
-#define KEY_TY    char *
-#define KEY_GET_CONST
-#define VAL_TY    lumpnum_t
-#define HASH_FN   vt_hash_string
-#define CMPR_FN   vt_cmpr_string
-#define KEY_DTOR_FN free
-#include "verstable.h"
+typedef struct lumpnum_cache_s
+{
+	char lumpname[LUMPNUMCACHENAME];
+	lumpnum_t lumpnum;
+	UINT32 hash;
+} lumpnum_cache_t;
 
-#define NAME      folder_map
-#define KEY_TY    char *
-#define KEY_GET_CONST
-#define VAL_TY    UINT16
-#define HASH_FN   vt_hash_string
-#define CMPR_FN   vt_cmpr_string
-#define KEY_DTOR_FN free
-#include "verstable.h"
-
-static lumpnum_map lumpnumcache;
-
-typedef struct FolderCache {
-	folder_map map;
-} FolderCache;
+static lumpnum_cache_t lumpnumcache[LUMPNUMCACHESIZE];
+static UINT16 lumpnumcacheindex = 0;
 
 static const char pat_central[] = {0x50, 0x4b, 0x01, 0x02, 0x00};
 static const char pat_end[] = {0x50, 0x4b, 0x05, 0x06, 0x00};
@@ -130,8 +116,6 @@ wadfile_t *wadfiles[MAX_WADFILES] = {}; // 0 to numwadfiles-1 are valid
 // being ejected
 void W_Shutdown(void)
 {
-	lumpnum_map_cleanup(&lumpnumcache);
-
 	while (numwadfiles--)
 	{
 		wadfile_t *wad = wadfiles[numwadfiles];
@@ -143,28 +127,18 @@ void W_Shutdown(void)
 
 		while (wad->numlumps--)
 		{
-			//Z_Free(wad->lumpinfo[wad->numlumps].longname);
+			Z_Free(wad->lumpinfo[wad->numlumps].longname);
 			Z_Free(wad->lumpinfo[wad->numlumps].fullname);
 		}
 
-		folder_map_cleanup(&wad->startfolders->map);
-		free(wad->startfolders);
-		folder_map_cleanup(&wad->endfolders->map);
-		free(wad->endfolders);
+		M_AATreeFree(wad->startfolders);
+		M_AATreeFree(wad->endfolders);
 
 		Z_Free(wad->lumpinfo);
 		Z_Free(wad);
 	}
 }
 
-// the lumpnum cache needs to be initialized before use
-// call this as early as possible!
-void W_Startup(void)
-{
-	lumpnum_map_init(&lumpnumcache);
-	lumpnum_map_reserve(&lumpnumcache, LUMPNUMCACHESIZE);
-}
-
 //===========================================================================
 //                                                        LUMP BASED ROUTINES
 //===========================================================================
@@ -285,7 +259,7 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
 			lumpinfo_t *lump_p = &wadfiles[wadnum]->lumpinfo[posStart];
 
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = (char *)(malloc(length + 1));
+			char *name = malloc(length + 1);
 
 			if (!name)
 				I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
@@ -321,7 +295,7 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum)
 		if (memcmp(lump_p->name, "SOC_", 4) == 0) // Check for generic SOC lump
 		{   // shameless copy+paste of code from LUA_LoadLump
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = (char *)(malloc(length + 1));
+			char *name = malloc(length + 1);
 
 			if (!name)
 				I_Error("W_LoadDehackedLumps: Out of memory!\n");
@@ -365,7 +339,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 
 	if ((fhandle = fopen(filename, "rb")) != NULL)
 	{
-		precise_t t = I_GetPreciseTime();
+		tic_t t = I_GetTime();
 
 		CONS_Debug(DBG_SETUP, "Making MD5 for %s\n",filename);
 
@@ -376,7 +350,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 		}
 
 		CONS_Debug(DBG_SETUP, "MD5 calc for %s took %f seconds\n",
-			filename, (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
+			filename, (float)(I_GetTime() - t)/NEWTICRATE);
 
 		fclose(fhandle);
 		return 0;
@@ -386,12 +360,12 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 }
 
 // Invalidates the cache of lump numbers. Call this whenever a wad is added.
-FUNCINLINE static ATTRINLINE void W_InvalidateLumpnumCache(void)
+static void W_InvalidateLumpnumCache(void)
 {
-	lumpnum_map_clear(&lumpnumcache);
+	memset(lumpnumcache, 0, sizeof(lumpnumcache));
 }
 
-FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
+UINT32 W_HashLumpName(const char *name)
 {
 	return FNV1a_HashLowercaseString(name);
 }
@@ -417,28 +391,28 @@ static restype_t ResourceFileDetect(const char* filename)
  */
 static lumpinfo_t* ResGetLumpsStandalone(FILE* handle, UINT16* numlumps, const char* lumpname)
 {
-	lumpinfo_t* lumpinfo = (lumpinfo_t *)(Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL));
+	lumpinfo_t* lumpinfo = Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL);
 	lumpinfo->position = 0;
 	fseek(handle, 0, SEEK_END);
-	lumpinfo->size = (size_t)(ftell(handle));
+	lumpinfo->size = ftell(handle);
 	fseek(handle, 0, SEEK_SET);
 	strlcpy(lumpinfo->name, lumpname, sizeof(lumpinfo->name));
 	lumpinfo->namelength = strlen(lumpinfo->name);
 	lumpinfo->hash.name = W_HashLumpName(lumpname);
 
 	// Allocate the lump's long name.
-	/*lumpinfo->longname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
+	lumpinfo->longname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
 	strcpy(lumpinfo->longname, lumpname);
 	lumpinfo->longname[lumpinfo->namelength] = '\0';
 	lumpinfo->longnamelength = lumpinfo->namelength;
-	lumpinfo->hash.longname = lumpinfo->hash.name;*/
+	lumpinfo->hash.longname = lumpinfo->hash.name;
 
 	// Allocate the lump's full name.
-	lumpinfo->fullname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
+	lumpinfo->fullname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
 	strcpy(lumpinfo->fullname, lumpname);
 	lumpinfo->fullname[lumpinfo->namelength] = '\0';
 	lumpinfo->fullnamelength = lumpinfo->namelength;
-	//lumpinfo->hash.fullname = lumpinfo->hash.name;
+	lumpinfo->hash.fullname = lumpinfo->hash.name;
 
 	*numlumps = 1;
 	return lumpinfo;
@@ -482,7 +456,7 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 
 	// read wad file directory
 	i = header.numlumps * sizeof(*fileinfo);
-	fileinfov = fileinfo = (filelump_t *)(malloc(i));
+	fileinfov = fileinfo = malloc(i);
 
 	if (fseek(handle, header.infotableofs, SEEK_SET) == -1
 	 || fread(fileinfo, 1, i, handle) < i)
@@ -494,7 +468,7 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 	numlumps = header.numlumps;
 
 	// fill in lumpinfo for this wad
-	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
+	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
 
 	for (i = 0; i < numlumps; i++, lump_p++, fileinfo++)
 	{
@@ -538,18 +512,18 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
 		// Allocate the lump's long name.
-		/*lump_p->longname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
+		lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
 		strncpy(lump_p->longname, fileinfo->name, 8);
 		lump_p->longname[8] = '\0';
 		lump_p->longnamelength = lump_p->namelength;
-		lump_p->hash.longname = lump_p->hash.name;*/
+		lump_p->hash.longname = lump_p->hash.name;
 
 		// Allocate the lump's full name.
-		lump_p->fullname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
+		lump_p->fullname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
 		strncpy(lump_p->fullname, fileinfo->name, 8);
 		lump_p->fullname[8] = '\0';
 		lump_p->fullnamelength = lump_p->namelength;
-		//lump_p->hash.fullname = lump_p->hash.name;
+		lump_p->hash.fullname = lump_p->hash.name;
 	}
 
 	*nlmp = numlumps;
@@ -566,24 +540,24 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 	int c;
 
 	fseek(handle, 0, SEEK_END);
-	size_t len = (size_t)(ftell(handle));
+	size_t len = ftell(handle);
 
 	fseek(handle, startpos, SEEK_SET);
-	size_t remaining = (size_t)(len - startpos);
-	size_t chunkpos = (size_t)(startpos);
+	size_t remaining = len - startpos;
+	size_t chunkpos = startpos;
 
 	s = endPat;
 
 	//128k buffers
 	size_t buffer_size = min(128 * 1024 * sizeof(char), remaining);
-	CLEANUP(pfree) char* buffer = (char *)(malloc(buffer_size));
+	CLEANUP(pfree) char* buffer = (char*)(malloc(buffer_size));
 
 	size_t bytes_read = 0;
 	while ((bytes_read = fread(buffer, 1, buffer_size, handle)) > 0)
 	{
 		for (size_t i = 0; i < bytes_read; i++)
 		{
-			c = (int)(buffer[i]);
+			c = (int)buffer[i];
 
 			if (*s != c && s > endPat) // No match?
 				s = endPat; // We "reset" the counter by sending the s pointer back to the start of the array.
@@ -595,7 +569,7 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 				if (*s == 0x00) // The array pointer has reached the key char which marks the end. It means we have matched the signature.
 				{
 					//the original function would leave the FILE* seeked to the end of the match
-					size_t foundpos = (size_t)(chunkpos + i + 1);
+					size_t foundpos = chunkpos + i + 1;
 					fseek(handle, foundpos, SEEK_SET);
 					return true;
 				}
@@ -672,7 +646,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 	// Contains entry number (number of lumps), and central directory start offset.
 	fseek(handle, 0, SEEK_END);
 
-	const long startpos = ftell(handle) - (22 + 65536);
+	const long startpos = (ftell(handle) - (22 + 65536));
 	if (!ResFindSignature(handle, pat_end, max(0l, startpos)))
 	{
 		CONS_Alert(CONS_ERROR, "Missing central directory\n");
@@ -688,11 +662,11 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	numlumps = SHORT(zend.entries);
 
-	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
+	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
 
 	fseek(handle, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(Z_Pfree) char *cdir = (char *)(Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir));
+	CLEANUP(Z_Pfree) char *cdir = Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir);
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), handle) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -705,7 +679,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	for (i = 0; i < numlumps; i++, lump_p++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -721,9 +695,8 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->disksize = LONG(zentry->compsize);
 		lump_p->size = LONG(zentry->size);
 
-		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-		fullname[zentry->namelen] = 0;
+		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -739,15 +712,15 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->namelength = strlen(lump_p->name);
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
-		/*lump_p->longname = (char *)(Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL));
+		lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL);
 		strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
 		lump_p->longnamelength = strlen(lump_p->longname);
-		lump_p->hash.longname = W_HashLumpName(lump_p->longname);*/
+		lump_p->hash.longname = W_HashLumpName(lump_p->longname);
 
-		lump_p->fullname = (char *)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
+		lump_p->fullname = (char*)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
 		strncpy(lump_p->fullname, fullname, SHORT(zentry->namelen));
 		lump_p->fullnamelength = zentry->namelen;
-		//lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
+		lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
 
 		switch(SHORT(zentry->compression))
 		{
@@ -922,19 +895,17 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 	//
 	// link wad file to search files
 	//
-	wadfile = (wadfile_t *)(Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL));
+	wadfile = Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL);
 	wadfile->filename = Z_StrDup(filename);
 	wadfile->handle = handle;
-	wadfile->numlumps = (UINT16)(numlumps);
+	wadfile->numlumps = (UINT16)numlumps;
 	wadfile->lumpinfo = lumpinfo;
 	wadfile->important = important;
 	fseek(handle, 0, SEEK_END);
-	wadfile->filesize = (unsigned)(ftell(handle));
+	wadfile->filesize = (unsigned)ftell(handle);
 	wadfile->type = type;
-	wadfile->startfolders = (FolderCache *)malloc(sizeof(FolderCache));
-	folder_map_init(&wadfile->startfolders->map);
-	wadfile->endfolders = (FolderCache *)malloc(sizeof(FolderCache));
-	folder_map_init(&wadfile->endfolders->map);
+	wadfile->startfolders = M_AATreeAlloc(AATREE_STRING);
+	wadfile->endfolders = M_AATreeAlloc(AATREE_STRING);
 
 	// already generated, just copy it over
 	memcpy(&wadfile->md5sum, &md5sum, 16);
@@ -959,7 +930,7 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 #ifdef HWRENDER
 	// Read shaders from file
 	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
-		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (boolean)(type == RET_PK3));
+		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (type == RET_PK3));
 #endif
 
 	// TODO: HACK ALERT - Load Lua & SOC stuff right here. I feel like this should be out of this place, but... Let's stick with this for now.
@@ -1059,7 +1030,7 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames)
 /** Make sure a lump number is valid.
   * Compiles away to nothing if PARANOIA is not defined.
   */
-static inline boolean TestValidLump(UINT16 wad, UINT16 lump)
+static boolean TestValidLump(UINT16 wad, UINT16 lump)
 {
 	I_Assert(wad < MAX_WADFILES);
 	if (!wadfiles[wad]) // make sure the wad file exists
@@ -1082,7 +1053,7 @@ const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump)
 
 const char *W_CheckNameForNum(lumpnum_t lumpnum)
 {
-	return W_CheckNameForNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum));
+	return W_CheckNameForNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum));
 }
 
 //
@@ -1136,7 +1107,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
+UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 i;
 	UINT32 hash;
@@ -1168,46 +1139,43 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 
 	// not found.
 	return INT16_MAX;
-}*/
+}
 
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 marker;
-
 	marker = W_CheckNumForNamePwad(name, wad, startlump);
 	if (marker != INT16_MAX)
 		marker++; // Do not count the first marker
-
 	return marker;
 }
 
 // Look for the first lump from a folder.
 UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	size_t name_length;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
+	name_length = strlen(name);
 
-	folder_map_itr it = folder_map_get(&wadfiles[wad]->startfolders->map, name);
-	if (!folder_map_is_end(it))
-		return it.data->val;
-
-	namelen = strlen(name);
+	void *val = M_AATreeGetString(wadfiles[wad]->startfolders, name);
+	if (val != NULL)
+		return (uintptr_t)val;
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, namelen) == 0)
+		if (strnicmp(name, lump_p->fullname, name_length) == 0)
 		{
 			/* SLADE is special and puts a single directory entry. Skip that. */
-			if (lump_p->fullnamelength == namelen)
+			if (strlen(lump_p->fullname) == name_length)
 				i++;
 
-			folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), i);
+			M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)(uintptr_t)i);
 			return i;
 		}
 	}
 
-	folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), INT16_MAX);
+	M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)INT16_MAX);
 	return INT16_MAX;
 }
 
@@ -1216,23 +1184,21 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 // Returns the position of the lumpinfo entry.
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
+	size_t name_length = strlen(name);
 
-	folder_map_itr it = folder_map_get(&wadfiles[wad]->endfolders->map, name);
-	if (!folder_map_is_end(it))
-		return it.data->val;
-
-	namelen = strlen(name);
+	void *val = M_AATreeGetString(wadfiles[wad]->endfolders, name);
+	if (val != NULL)
+		return (uintptr_t)val;
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, namelen))
+		if (strnicmp(name, lump_p->fullname, name_length))
 			break;
 	}
 
-	folder_map_insert(&wadfiles[wad]->endfolders->map, strdup(name), i);
+	M_AATreeSetString(wadfiles[wad]->endfolders, name, (void *)(uintptr_t)i);
 	return i;
 }
 
@@ -1240,15 +1206,13 @@ UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 // Returns lump position in PK3's lumpinfo, or INT16_MAX if not found.
 UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
-
-	namelen = strlen(name);
+	size_t name_length = strlen(name);
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (!strnicmp(name, lump_p->fullname, namelen))
+		if (!strnicmp(name, lump_p->fullname, name_length))
 		{
 			return i;
 		}
@@ -1258,19 +1222,61 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 	return INT16_MAX;
 }
 
-FUNCINLINE static ATTRINLINE lumpnum_t CheckLumpInCache(const char *name)
+static lumpnum_t CheckLumpInCache(const char *name, boolean longname)
 {
-	lumpnum_map_itr it = lumpnum_map_get(&lumpnumcache, name);
-	if (!lumpnum_map_is_end(it))
-		return it.data->val;
+	if (longname)
+	{
+		UINT32 hash = quickncasehash(name, 32);
+
+		// Loop backwards so that we check most recent entries first
+		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+		{
+			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+				&& fasticmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name))
+			{
+				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+				return lumpnumcache[lumpnumcacheindex].lumpnum;
+			}
+		}
+	}
+	else
+	{
+		UINT32 hash = quickncasehash(name, 8);
+
+		// Loop backwards so that we check most recent entries first
+		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+		{
+			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+				&& lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8] == '\0'
+				&& strnicmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0)
+			{
+				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+				return lumpnumcache[lumpnumcacheindex].lumpnum;
+			}
+		}
+	}
 
 	return LUMPERROR;
 }
 
-FUNCINLINE static ATTRINLINE void AddLumpToCache(lumpnum_t lumpnum, const char *name)
+static void AddLumpToCache(lumpnum_t lumpnum, const char *name, boolean longname)
 {
-	I_Assert(strlen(name) <= 8); // we dont have longnames, so assume this is a non terminated string
-	lumpnum_map_insert(&lumpnumcache, strdup(name), lumpnum);
+	if (longname && strlen(name) >= LUMPNUMCACHENAME)
+		return;
+
+	lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
+	memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', LUMPNUMCACHENAME);
+	if (longname)
+	{
+		strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, LUMPNUMCACHENAME);
+		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, LUMPNUMCACHENAME);
+	}
+	else
+	{
+		strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8);
+		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, 8);
+	}
+	lumpnumcache[lumpnumcacheindex].lumpnum = lumpnum;
 }
 
 //
@@ -1286,14 +1292,14 @@ lumpnum_t W_CheckNumForName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
+	lumpnum_t cachenum = CheckLumpInCache(name, false);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForNamePwad(name, (UINT16)(i), 0);
+		check = W_CheckNumForNamePwad(name, (UINT16)i, 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1307,7 +1313,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name);
+		AddLumpToCache(lumpnum, name, false);
 
 		return lumpnum;
 	}
@@ -1319,7 +1325,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*lumpnum_t W_CheckNumForLongName(const char *name)
+lumpnum_t W_CheckNumForLongName(const char *name)
 {
 	INT32 i;
 	lumpnum_t check = INT16_MAX;
@@ -1328,14 +1334,14 @@ lumpnum_t W_CheckNumForName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
+	lumpnum_t cachenum = CheckLumpInCache(name, true);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForLongNamePwad(name, (UINT16)(i), 0);
+		check = W_CheckNumForLongNamePwad(name, (UINT16)i, 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1349,11 +1355,11 @@ lumpnum_t W_CheckNumForName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name);
+		AddLumpToCache(lumpnum, name, true);
 
 		return lumpnum;
 	}
-}*/
+}
 
 //
 // W_GetNumForName
@@ -1378,7 +1384,7 @@ lumpnum_t W_GetNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*lumpnum_t W_GetNumForLongName(const char *name)
+lumpnum_t W_GetNumForLongName(const char *name)
 {
 	lumpnum_t i;
 
@@ -1388,7 +1394,7 @@ lumpnum_t W_GetNumForName(const char *name)
 		I_Error("W_GetNumForLongName: %s not found!\n", name);
 
 	return i;
-}*/
+}
 
 //
 // W_CheckNumForNameInBlock
@@ -1405,49 +1411,32 @@ lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, con
 	{
 		if (wadfiles[i]->type == RET_WAD)
 		{
-			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)(i), 0);
+			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)i, 0);
 			if (bsid == INT16_MAX)
 				continue; // Start block doesn't exist?
-			beid = W_CheckNumForNamePwad(blockend, (UINT16)(i), 0);
+			beid = W_CheckNumForNamePwad(blockend, (UINT16)i, 0);
 			if (beid == INT16_MAX)
 				continue; // End block doesn't exist?
 
-			check = W_CheckNumForNamePwad(name, (UINT16)(i), bsid);
+			check = W_CheckNumForNamePwad(name, (UINT16)i, bsid);
 			if (check < beid)
-				return (i << 16)+check; // found it, in our constraints
+				return (i<<16)+check; // found it, in our constraints
 		}
 	}
-
 	return LUMPERROR;
 }
 
 // Used by Lua. Case sensitive lump checking, quickly...
 UINT8 W_LumpExists(const char *name)
 {
-	INT32 i, j;
-	UINT32 hash;
-	size_t namelen;
-
-	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
-	if (cachenum != LUMPERROR)
-		return true;
-
-	namelen = strlen(name);
-	hash = W_HashLumpName(name);
-
+	INT32 i,j;
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
 		lumpinfo_t *lump_p = wadfiles[i]->lumpinfo;
 		for (j = 0; j < wadfiles[i]->numlumps; ++j, ++lump_p)
-		{
-			if (lump_p->namelength == namelen
-			 && lump_p->hash.name == hash
-			 && fastcmp(lump_p->name, name))
+			if (fastcmp(lump_p->name, name))
 				return true;
-		}
 	}
-
 	return false;
 }
 
@@ -1607,13 +1596,13 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 	fseek(handle, (long)(l->position + offset), SEEK_SET);
 
 	// But let's not copy it yet. We support different compression formats on lumps, so we need to take that into account.
-	switch (wadfiles[wad]->lumpinfo[lump].compression)
+	switch(wadfiles[wad]->lumpinfo[lump].compression)
 	{
 	case CM_NOCOMPRESSION:		// If it's uncompressed, we directly write the data into our destination, and return the bytes read.
 #ifdef NO_PNG_LUMPS
 		{
 			size_t bytesread = fread(dest, 1, size, handle);
-			ErrorIfPNG((UINT8 *)(dest), bytesread, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, bytesread, wadfiles[wad]->filename, l->fullname);
 			return bytesread;
 		}
 #else
@@ -1626,8 +1615,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			char *decData; // Lump's decompressed real data.
 			size_t retval; // Helper var, lzf_decompress returns 0 when an error occurs.
 
-			rawData = (char *)(Z_Malloc(l->disksize, PU_STATIC, NULL));
-			decData = (char *)(Z_Malloc(l->size, PU_STATIC, NULL));
+			rawData = Z_Malloc(l->disksize, PU_STATIC, NULL);
+			decData = Z_Malloc(l->size, PU_STATIC, NULL);
 
 			if (fread(rawData, 1, l->disksize, handle) < l->disksize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1654,7 +1643,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 			Z_Free(decData);
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 #else
@@ -1674,8 +1663,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			unsigned long rawSize = l->disksize;
 			unsigned long decSize = size;
 
-			rawData = (UINT8 *)(Z_Malloc(rawSize, PU_STATIC, NULL));
-			decData = (UINT8 *)(dest);
+			rawData = Z_Malloc(rawSize, PU_STATIC, NULL);
+			decData = dest;
 
 			if (fread(rawData, 1, rawSize, handle) < rawSize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1711,7 +1700,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 		}
@@ -1899,7 +1888,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0);
 
 		dest = Z_Calloc(sizeof(patch_t), tag, &lumpcache[lump]);
-		Patch_Create((softwarepatch_t *)(lumpdata), len, dest);
+		Patch_Create((softwarepatch_t*)lumpdata, len, dest);
 
 		Z_Free(lumpdata);
 	}
@@ -1921,7 +1910,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 	if (!TestValidLump(wad, lump))
 		return NULL;
 
-	patch = (patch_t *)(W_CacheSoftwarePatchNumPwad(wad, lump, tag));
+	patch = (patch_t *)W_CacheSoftwarePatchNumPwad(wad, lump, tag);
 
 	if (patch == NULL)
 		return NULL;
@@ -1932,7 +1921,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		Patch_CreateGL(patch);
 #endif
 
-	return (void*)(patch);
+	return (void *)patch;
 }
 
 void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
@@ -1950,20 +1939,17 @@ void *W_GetCachedPatchNumPwad(UINT16 wad, UINT16 lump)
 
 #ifdef ROTSPRITE
 // Caches a rotsprite for patch rotation.
-void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump)
+void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 {
-	if (!TestValidLump(wad, lump))
-		return NULL;
+	lumpcache_t *rotcache = wadfiles[wadnum]->rotcache;
 
-	lumpcache_t *rotcache = wadfiles[wad]->rotcache;
-
-	if (!rotcache[lump])
+	if (!rotcache[lumpnum])
 	{
 		rotsprite_t *rspr = RotatedPatch_Create(ROTANGLES);
-		Z_SetUser(rspr, (void**)(&rotcache[lump]));
+		Z_SetUser(rspr, (void **)(&rotcache[lumpnum]));
 	}
 
-	return (void*)(rotcache[lump]);
+	return (void *)(rotcache[lumpnum]);
 }
 #endif // ROTSPRITE
 
@@ -1976,7 +1962,7 @@ void W_UnlockCachedPatch(void *patch)
 	// have different lifetimes from software's.
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_UnlockCachedPatch((GLPatch_t *)(((patch_t *)(patch))->hardware));
+		HWR_UnlockCachedPatch((GLPatch_t *)((patch_t *)patch)->hardware);
 	else
 #endif
 	Z_ChangeTag(patch, PU_PATCH);
@@ -2011,7 +1997,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	if (rotationangle < 1 || rotationangle >= ROTANGLES)
 		return W_CachePatchNum(num, tag);
 
-	rspr = (rotsprite_t *)(W_GetCachedRotPatchPwad(WADFILENUM(num), LUMPNUM(num)));
+	rspr = (rotsprite_t *)W_GetCachedRotPatchPwad(WADFILENUM(num),LUMPNUM(num));
 
 	if (rspr == NULL)
 		return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
@@ -2020,7 +2006,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	{
 		INT32 xpivot = 0, ypivot = 0;
 
-		ptr = (patch_t *)(W_CachePatchNum(num, PU_PATCH));
+		ptr = (patch_t *)W_CachePatchNum(num, PU_PATCH);
 		if (ptr == NULL)
 			return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
 
@@ -2213,7 +2199,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = file_size - (22 + 65536);
+	const long startpos = (file_size - (22 + 65536));
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2227,7 +2213,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2238,7 +2224,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -2250,9 +2236,8 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 		if (verified == true)
 		{
-			fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-			strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-			fullname[zentry->namelen] = 0;
+			fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+			strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 			// Strip away file address and extension for the 8char name.
 			if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2461,7 +2446,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = file_size - (22 + 65536);
+	const long startpos = (file_size - (22 + 65536));
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2475,7 +2460,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2486,7 +2471,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		CLEANUP(pfree) char* fullname = NULL;
 		char* trimname;
 		char* dotpos;
@@ -2496,9 +2481,8 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 			return false;
 		}
 
-		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-		fullname[zentry->namelen] = 0;
+		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2589,18 +2573,6 @@ static int W_CheckFileContains(const char *filename, lumpchecklist_t *checklist)
 	return contains;
 }
 
-int W_CheckAutoLoadContainsMap(const char *filename)
-{
-	// for now this checks for map marker
-	static lumpchecklist_t autoloadblacklist[] =
-	{
-		{"MAP", 3},
-		{NULL,  0},
-	};
-
-	return W_CheckFileContains(filename, autoloadblacklist);
-}
-
 int W_CheckPostLoadList(const char *filename)
 {
 	static lumpchecklist_t postloadlist[] =
@@ -2613,6 +2585,7 @@ int W_CheckPostLoadList(const char *filename)
 		{"SOC_", 		4},
 		{"MAINCFG",		7},
 		{"OBJCTCFG", 	8},
+		{"MAP",			3},
 
 		{NULL, 0},
 	};
@@ -2645,14 +2618,14 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		size_t *vsizecache;
 
 		// Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
-		UINT8 *wadData = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+		UINT8 *wadData = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		if (wadData == NULL)
 			I_Error("vres_GetMap: Invalid WadData!\n");
 
-		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)(wadData))->infotableofs));
+		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)wadData)->infotableofs));
 
-		i = LONG(((wadinfo_t *)(wadData))->numlumps);
-		vsizecache = (size_t *)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
+		i = LONG(((wadinfo_t *)wadData)->numlumps);
+		vsizecache = (size_t*)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
 
 		for (realentry = 0; realentry < i; realentry++)
 		{
@@ -2664,7 +2637,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			numlumps++;
 		}
 
-		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2673,12 +2646,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		{
 			if (vsizecache[realentry] == 0)
 				continue;
-
 			vlumps[i].size = vsizecache[realentry];
 
 			const char *name = (fileinfo + realentry)->name;
 
-			if (strnlen(name, 8) == 5 && memcmp(name, "MAP", 3) == 0)
+			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
@@ -2687,7 +2659,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			// Play it safe with the name in this case.
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8 *)(
+			vlumps[i].data = (UINT8*)(
 				Z_Malloc(vlumps[i].size, PU_LEVEL, NULL) // This is memory inefficient, sorry about that.
 			);
 			memcpy(vlumps[i].data, wadData + LONG((fileinfo + realentry)->filepos), vlumps[i].size);
@@ -2714,7 +2686,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		}
 		numlumps++;
 
-		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2735,11 +2707,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			vlumps[i].size = W_LumpLength(lumpnum);
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+			vlumps[i].data = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		}
 	}
 
-	vres = (virtres_t *)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
+	vres = (virtres_t*)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
 	vres->vlumps = vlumps;
 	vres->numlumps = numlumps;
 

src/w_wad.h

@@ -68,11 +68,11 @@ typedef struct
 	unsigned long position; // filelump_t filepos
 	unsigned long disksize; // filelump_t size
 	char name[9];           // filelump_t name[] e.g. "LongEntr"
-	//char *longname;         //                   e.g. "LongEntryName"
+	char *longname;         //                   e.g. "LongEntryName"
 	char *fullname;         //                   e.g. "Folder/Subfolder/LongEntryName.extension"
 
 	size_t namelength;      // length of name
-	//size_t longnamelength;  // length of longname
+	size_t longnamelength;  // length of longname
 	size_t fullnamelength;  // length of fullname
 
 	size_t size; // real (uncompressed) size
@@ -80,8 +80,8 @@ typedef struct
 
 	struct {
 		UINT32 name;        // hash of name
-		//UINT32 longname;    // hash of longname
-		//UINT32 fullname;    // hash of fullname
+		UINT32 longname;    // hash of longname
+		UINT32 fullname;    // hash of fullname
 	} hash;
 } lumpinfo_t;
 
@@ -126,6 +126,7 @@ typedef enum restype
 	RET_UNKNOWN,
 } restype_t;
 
+
 typedef struct wadfile_s
 {
 	char *filename;
@@ -136,8 +137,8 @@ typedef struct wadfile_s
 #ifdef ROTSPRITE
 	lumpcache_t *rotcache; // Cache rotsprites for rotating patches.
 #endif
-	struct FolderCache *startfolders;
-	struct FolderCache *endfolders;
+	aatree_t *startfolders;
+	aatree_t *endfolders;
 	UINT16 numlumps; // this wad's number of resources
 	FILE *handle;
 	UINT32 filesize; // for network
@@ -154,7 +155,6 @@ extern wadfile_t *wadfiles[MAX_WADFILES];
 
 // =========================================================================
 
-void W_Startup(void);
 void W_Shutdown(void);
 
 // Opens a WAD file. Returns the FILE * handle for the file, or NULL if not found or could not be opened
@@ -174,11 +174,13 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames);
 
 #define W_FileHasFolders(wadfile) ((wadfile)->type == RET_PK3)
 
+UINT32 W_HashLumpName(const char *name);
+
 const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump);
 const char *W_CheckNameForNum(lumpnum_t lumpnum);
 
 UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump); // checks only in one pwad
-//UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
+UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
 
 /* Find the first lump after F_START for instance. */
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump);
@@ -188,9 +190,9 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump);
 
 lumpnum_t W_CheckNumForName(const char *name);
-//lumpnum_t W_CheckNumForLongName(const char *name);
+lumpnum_t W_CheckNumForLongName(const char *name);
 lumpnum_t W_GetNumForName(const char *name); // like W_CheckNumForName but I_Error on LUMPERROR
-//lumpnum_t W_GetNumForLongName(const char *name);
+lumpnum_t W_GetNumForLongName(const char *name);
 lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, const char *blockend);
 UINT8 W_LumpExists(const char *name); // Lua uses this.
 UINT8 W_CheckMultipleLumps(const char* lump, ...); // variadic version of above lmao
@@ -231,7 +233,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag);
 void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag);
 
 #ifdef ROTSPRITE
-void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump); // Get patch-based rotsprites from the cache.
+void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum); // Get patch-based rotsprites from the cache.
 void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag);
 #endif
 
@@ -241,7 +243,6 @@ void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
 
 int W_VerifyNMUSlumps(const char *filename, FILE *handle, boolean exit_on_error);
 
-int W_CheckAutoLoadContainsMap(const char *filename);
 int W_CheckPostLoadList(const char *filename);
 
 #ifdef __cplusplus

src/z_zone.cpp

@@ -523,19 +523,11 @@ void Z_CheckHeap(INT32 tag)
 #ifdef VALGRIND_MEMPOOL_EXISTS
 		if (!VALGRIND_MEMPOOL_EXISTS(block))
 		{
-			I_Error("Z_CheckHeap :"
-#ifdef ZDEBUG
-				" %s %d"
-#endif
-				" block %u"
+			I_Error("Z_CheckHeap %d: block %u"
 #ifdef ZDEBUG
 				" (owned by %s:%d)"
 #endif
-				" should not exist"
-#ifdef ZDEBUG
-				, file, line
-#endif
-				, blocknumon
+				" should not exist", i, blocknumon
 #ifdef ZDEBUG
 				, block->ownerfile, block->ownerline
 #endif