diff --git a/src/Makefile b/src/Makefile
index 750e8ead5f98eea86e2f2f7eb32922d2b83b282d..7571c808933d254613c401fdfc5d75522b750933 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -64,6 +64,7 @@
#
# Netplay incompatible
# --------------------
+# NONET=1 - Disable online capability.
# NOMD5=1 - Disable MD5 checksum (validation tool).
# NOPOSTPROCESSING=1 - ?
# MOBJCONSISTANCY=1 - ??
@@ -207,7 +208,6 @@ objdir:=$(makedir)/objs
sources+=\
$(call List,Sourcefile)\
$(call List,blua/Sourcefile)\
- $(call List,netcode/Sourcefile)\
depends:=$(basename $(filter %.c %.s,$(sources)))
objects:=$(basename $(filter %.c %.s %.nas,$(sources)))
diff --git a/src/Makefile.d/features.mk b/src/Makefile.d/features.mk
index 9acbb4d862ec952de0b4f7b69773a337cce82393..8ba33383bb2f0c8169e92f91c6c8fea25c6c852f 100644
--- a/src/Makefile.d/features.mk
+++ b/src/Makefile.d/features.mk
@@ -3,7 +3,7 @@
#
passthru_opts+=\
- NO_IPV6 NOHW NOMD5 NOPOSTPROCESSING\
+ NONET NO_IPV6 NOHW NOMD5 NOPOSTPROCESSING\
MOBJCONSISTANCY PACKETDROP ZDEBUG\
HAVE_MINIUPNPC\
@@ -46,11 +46,13 @@ sources+=apng.c
endif
endif
+ifndef NONET
ifndef NOCURL
CURLCONFIG?=curl-config
$(eval $(call Configure,CURL,$(CURLCONFIG)))
opts+=-DHAVE_CURL
endif
+endif
ifdef HAVE_MINIUPNPC
libs+=-lminiupnpc
diff --git a/src/Makefile.d/win32.mk b/src/Makefile.d/win32.mk
index e7269e1e760fe7e0ac6411fffb25022d2fba0191..0e48ed68359523e70b4ba0a6d8eade4b81d1d9ca 100644
--- a/src/Makefile.d/win32.mk
+++ b/src/Makefile.d/win32.mk
@@ -35,10 +35,12 @@ libs+=-lws2_32
endif
endif
+ifndef NONET
ifndef MINGW64 # miniupnc is broken with MINGW64
opts+=-I../libs -DSTATIC_MINIUPNPC
libs+=-L../libs/miniupnpc/mingw$(32) -lws2_32 -liphlpapi
endif
+endif
ifndef MINGW64
32=32
diff --git a/src/Sourcefile b/src/Sourcefile
index 7d2146411369e475046a1d07c3190749210da43f..9de90eee48b51c0bebac1d3b4eba88a648246b50 100644
--- a/src/Sourcefile
+++ b/src/Sourcefile
@@ -1,5 +1,9 @@
string.c
d_main.c
+d_clisrv.c
+d_net.c
+d_netfil.c
+d_netcmd.c
dehacked.c
deh_soc.c
deh_lua.c
@@ -73,10 +77,12 @@ s_sound.c
sounds.c
w_wad.c
filesrch.c
+mserv.c
+http-mserv.c
+i_tcp.c
lzf.c
vid_copy.s
b_bot.c
-snake.c
lua_script.c
lua_baselib.c
lua_mathlib.c
diff --git a/src/android/i_net.c b/src/android/i_net.c
index 4c30dc767a04615b75e6badf68d3603bc475a575..f6e642022e4a54360d68004f69d61eaa5e3acb19 100644
--- a/src/android/i_net.c
+++ b/src/android/i_net.c
@@ -1,4 +1,4 @@
-#include "../netcode/i_net.h"
+#include "../i_net.h"
boolean I_InitNetwork(void)
{
diff --git a/src/blua/liolib.c b/src/blua/liolib.c
index bce8e87cc6be4d5ed71a20d3dcbe7a5421a590f5..e029650c0ced525f3bfc56fc9863d9816f6ebb63 100644
--- a/src/blua/liolib.c
+++ b/src/blua/liolib.c
@@ -19,8 +19,7 @@
#include "lualib.h"
#include "../i_system.h"
#include "../g_game.h"
-#include "../netcode/d_netfil.h"
-#include "../netcode/net_command.h"
+#include "../d_netfil.h"
#include "../lua_libs.h"
#include "../byteptr.h"
#include "../lua_script.h"
diff --git a/src/command.c b/src/command.c
index 58d69e24d7867ef09457a9b356fb442a914c7895..d1db9f9c99d59c38c0f95e8b9eec61d84fb97776 100644
--- a/src/command.c
+++ b/src/command.c
@@ -28,12 +28,11 @@
#include "byteptr.h"
#include "p_saveg.h"
#include "g_game.h" // for player_names
-#include "netcode/d_netcmd.h"
-#include "netcode/net_command.h"
+#include "d_netcmd.h"
#include "hu_stuff.h"
#include "p_setup.h"
#include "lua_script.h"
-#include "netcode/d_netfil.h" // findfile
+#include "d_netfil.h" // findfile
#include "r_data.h" // Color_cons_t
//========
diff --git a/src/d_clisrv.c b/src/d_clisrv.c
new file mode 100755
index 0000000000000000000000000000000000000000..3091f33440053c445dae6f2688f22d15e6adbe21
--- /dev/null
+++ b/src/d_clisrv.c
@@ -0,0 +1,5590 @@
+// SONIC ROBO BLAST 2
+//-----------------------------------------------------------------------------
+// Copyright (C) 1998-2000 by DooM Legacy Team.
+// Copyright (C) 1999-2022 by Sonic Team Junior.
+//
+// This program is free software distributed under the
+// terms of the GNU General Public License, version 2.
+// See the 'LICENSE' file for more details.
+//-----------------------------------------------------------------------------
+/// \file d_clisrv.c
+/// \brief SRB2 Network game communication and protocol, all OS independent parts.
+
+#include <time.h>
+#ifdef __GNUC__
+#include <unistd.h> //for unlink
+#endif
+
+#include "i_time.h"
+#include "i_net.h"
+#include "i_system.h"
+#include "i_video.h"
+#include "d_net.h"
+#include "d_main.h"
+#include "g_game.h"
+#include "st_stuff.h"
+#include "hu_stuff.h"
+#include "keys.h"
+#include "g_input.h"
+#include "i_gamepad.h"
+#include "m_menu.h"
+#include "console.h"
+#include "d_netfil.h"
+#include "byteptr.h"
+#include "p_saveg.h"
+#include "z_zone.h"
+#include "p_local.h"
+#include "p_haptic.h"
+#include "m_misc.h"
+#include "am_map.h"
+#include "m_random.h"
+#include "mserv.h"
+#include "y_inter.h"
+#include "r_local.h"
+#include "m_argv.h"
+#include "p_setup.h"
+#include "lzf.h"
+#include "lua_script.h"
+#include "lua_hook.h"
+#include "lua_libs.h"
+#include "md5.h"
+#include "m_perfstats.h"
+
+// aaaaaa
+#include "i_gamepad.h"
+
+#ifndef NONET
+// cl loading screen
+#include "v_video.h"
+#include "f_finale.h"
+#endif
+
+//
+// NETWORKING
+//
+// gametic is the tic about to (or currently being) run
+// Server:
+// maketic is the tic that hasn't had control made for it yet
+// nettics is the tic for each node
+// firstticstosend is the lowest value of nettics
+// Client:
+// neededtic is the tic needed by the client to run the game
+// firstticstosend is used to optimize a condition
+// Normally maketic >= gametic > 0
+
+#define PREDICTIONQUEUE BACKUPTICS
+#define PREDICTIONMASK (PREDICTIONQUEUE-1)
+#define MAX_REASONLENGTH 30
+
+boolean server = true; // true or false but !server == client
+#define client (!server)
+boolean nodownload = false;
+boolean serverrunning = false;
+INT32 serverplayer = 0;
+char motd[254], server_context[8]; // Message of the Day, Unique Context (even without Mumble support)
+
+// Server specific vars
+UINT8 playernode[MAXPLAYERS];
+char playeraddress[MAXPLAYERS][64];
+
+// Minimum timeout for sending the savegame
+// The actual timeout will be longer depending on the savegame length
+tic_t jointimeout = (10*TICRATE);
+static boolean sendingsavegame[MAXNETNODES]; // Are we sending the savegame?
+static boolean resendingsavegame[MAXNETNODES]; // Are we resending the savegame?
+static tic_t savegameresendcooldown[MAXNETNODES]; // How long before we can resend again?
+static tic_t freezetimeout[MAXNETNODES]; // Until when can this node freeze the server before getting a timeout?
+
+// Incremented by cv_joindelay when a client joins, decremented each tic.
+// If higher than cv_joindelay * 2 (3 joins in a short timespan), joins are temporarily disabled.
+static tic_t joindelay = 0;
+
+UINT16 pingmeasurecount = 1;
+UINT32 realpingtable[MAXPLAYERS]; //the base table of ping where an average will be sent to everyone.
+UINT32 playerpingtable[MAXPLAYERS]; //table of player latency values.
+SINT8 nodetoplayer[MAXNETNODES];
+SINT8 nodetoplayer2[MAXNETNODES]; // say the numplayer for this node if any (splitscreen)
+UINT8 playerpernode[MAXNETNODES]; // used specialy for scplitscreen
+boolean nodeingame[MAXNETNODES]; // set false as nodes leave game
+tic_t servermaxping = 800; // server's max ping. Defaults to 800
+static tic_t nettics[MAXNETNODES]; // what tic the client have received
+static tic_t supposedtics[MAXNETNODES]; // nettics prevision for smaller packet
+static UINT8 nodewaiting[MAXNETNODES];
+static tic_t firstticstosend; // min of the nettics
+static tic_t tictoclear = 0; // optimize d_clearticcmd
+static tic_t maketic;
+
+static INT16 consistancy[BACKUPTICS];
+
+static UINT8 player_joining = false;
+UINT8 hu_redownloadinggamestate = 0;
+
+// true when a player is connecting or disconnecting so that the gameplay has stopped in its tracks
+boolean hu_stopped = false;
+
+UINT8 adminpassmd5[16];
+boolean adminpasswordset = false;
+
+// Client specific
+static ticcmd_t localcmds;
+static ticcmd_t localcmds2;
+static boolean cl_packetmissed;
+// here it is for the secondary local player (splitscreen)
+static UINT8 mynode; // my address pointofview server
+static boolean cl_redownloadinggamestate = false;
+
+static UINT8 localtextcmd[MAXTEXTCMD];
+static UINT8 localtextcmd2[MAXTEXTCMD]; // splitscreen
+static tic_t neededtic;
+SINT8 servernode = 0; // the number of the server node
+
+/// \brief do we accept new players?
+/// \todo WORK!
+boolean acceptnewnode = true;
+
+static boolean serverisfull = false; //lets us be aware if the server was full after we check files, but before downloading, so we can ask if the user still wants to download or not
+static tic_t firstconnectattempttime = 0;
+
+// engine
+
+// Must be a power of two
+#define TEXTCMD_HASH_SIZE 4
+
+typedef struct textcmdplayer_s
+{
+ INT32 playernum;
+ UINT8 cmd[MAXTEXTCMD];
+ struct textcmdplayer_s *next;
+} textcmdplayer_t;
+
+typedef struct textcmdtic_s
+{
+ tic_t tic;
+ textcmdplayer_t *playercmds[TEXTCMD_HASH_SIZE];
+ struct textcmdtic_s *next;
+} textcmdtic_t;
+
+ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS];
+static textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE] = {NULL};
+
+
+consvar_t cv_showjoinaddress = CVAR_INIT ("showjoinaddress", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
+
+static CV_PossibleValue_t playbackspeed_cons_t[] = {{1, "MIN"}, {10, "MAX"}, {0, NULL}};
+consvar_t cv_playbackspeed = CVAR_INIT ("playbackspeed", "1", 0, playbackspeed_cons_t, NULL);
+
+static inline void *G_DcpyTiccmd(void* dest, const ticcmd_t* src, const size_t n)
+{
+ const size_t d = n / sizeof(ticcmd_t);
+ const size_t r = n % sizeof(ticcmd_t);
+ UINT8 *ret = dest;
+
+ if (r)
+ M_Memcpy(dest, src, n);
+ else if (d)
+ G_MoveTiccmd(dest, src, d);
+ return ret+n;
+}
+
+static inline void *G_ScpyTiccmd(ticcmd_t* dest, void* src, const size_t n)
+{
+ const size_t d = n / sizeof(ticcmd_t);
+ const size_t r = n % sizeof(ticcmd_t);
+ UINT8 *ret = src;
+
+ if (r)
+ M_Memcpy(dest, src, n);
+ else if (d)
+ G_MoveTiccmd(dest, src, d);
+ return ret+n;
+}
+
+
+
+// Some software don't support largest packet
+// (original sersetup, not exactely, but the probability of sending a packet
+// of 512 bytes is like 0.1)
+UINT16 software_MAXPACKETLENGTH;
+
+/** Guesses the full value of a tic from its lowest byte, for a specific node
+ *
+ * \param low The lowest byte of the tic value
+ * \param node The node to deduce the tic for
+ * \return The full tic value
+ *
+ */
+tic_t ExpandTics(INT32 low, INT32 node)
+{
+ INT32 delta;
+
+ delta = low - (nettics[node] & UINT8_MAX);
+
+ if (delta >= -64 && delta <= 64)
+ return (nettics[node] & ~UINT8_MAX) + low;
+ else if (delta > 64)
+ return (nettics[node] & ~UINT8_MAX) - 256 + low;
+ else //if (delta < -64)
+ return (nettics[node] & ~UINT8_MAX) + 256 + low;
+}
+
+// -----------------------------------------------------------------
+// Some extra data function for handle textcmd buffer
+// -----------------------------------------------------------------
+
+static void (*listnetxcmd[MAXNETXCMD])(UINT8 **p, INT32 playernum);
+
+void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum))
+{
+#ifdef PARANOIA
+ if (id >= MAXNETXCMD)
+ I_Error("Command id %d too big", id);
+ if (listnetxcmd[id] != 0)
+ I_Error("Command id %d already used", id);
+#endif
+ listnetxcmd[id] = cmd_f;
+}
+
+void SendNetXCmd(netxcmd_t id, const void *param, size_t nparam)
+{
+ if (localtextcmd[0]+2+nparam > MAXTEXTCMD)
+ {
+ // for future reference: if (cv_debug) != debug disabled.
+ CONS_Alert(CONS_ERROR, M_GetText("NetXCmd buffer full, cannot add netcmd %d! (size: %d, needed: %s)\n"), id, localtextcmd[0], sizeu1(nparam));
+ return;
+ }
+ localtextcmd[0]++;
+ localtextcmd[localtextcmd[0]] = (UINT8)id;
+ if (param && nparam)
+ {
+ M_Memcpy(&localtextcmd[localtextcmd[0]+1], param, nparam);
+ localtextcmd[0] = (UINT8)(localtextcmd[0] + (UINT8)nparam);
+ }
+}
+
+// splitscreen player
+void SendNetXCmd2(netxcmd_t id, const void *param, size_t nparam)
+{
+ if (localtextcmd2[0]+2+nparam > MAXTEXTCMD)
+ {
+ I_Error("No more place in the buffer for netcmd %d\n",id);
+ return;
+ }
+ localtextcmd2[0]++;
+ localtextcmd2[localtextcmd2[0]] = (UINT8)id;
+ if (param && nparam)
+ {
+ M_Memcpy(&localtextcmd2[localtextcmd2[0]+1], param, nparam);
+ localtextcmd2[0] = (UINT8)(localtextcmd2[0] + (UINT8)nparam);
+ }
+}
+
+UINT8 GetFreeXCmdSize(void)
+{
+ // -1 for the size and another -1 for the ID.
+ return (UINT8)(localtextcmd[0] - 2);
+}
+
+// Frees all textcmd memory for the specified tic
+static void D_FreeTextcmd(tic_t tic)
+{
+ textcmdtic_t **tctprev = &textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
+ textcmdtic_t *textcmdtic = *tctprev;
+
+ while (textcmdtic && textcmdtic->tic != tic)
+ {
+ tctprev = &textcmdtic->next;
+ textcmdtic = textcmdtic->next;
+ }
+
+ if (textcmdtic)
+ {
+ INT32 i;
+
+ // Remove this tic from the list.
+ *tctprev = textcmdtic->next;
+
+ // Free all players.
+ for (i = 0; i < TEXTCMD_HASH_SIZE; i++)
+ {
+ textcmdplayer_t *textcmdplayer = textcmdtic->playercmds[i];
+
+ while (textcmdplayer)
+ {
+ textcmdplayer_t *tcpnext = textcmdplayer->next;
+ Z_Free(textcmdplayer);
+ textcmdplayer = tcpnext;
+ }
+ }
+
+ // Free this tic's own memory.
+ Z_Free(textcmdtic);
+ }
+}
+
+// Gets the buffer for the specified ticcmd, or NULL if there isn't one
+static UINT8* D_GetExistingTextcmd(tic_t tic, INT32 playernum)
+{
+ textcmdtic_t *textcmdtic = textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
+ while (textcmdtic && textcmdtic->tic != tic) textcmdtic = textcmdtic->next;
+
+ // Do we have an entry for the tic? If so, look for player.
+ if (textcmdtic)
+ {
+ textcmdplayer_t *textcmdplayer = textcmdtic->playercmds[playernum & (TEXTCMD_HASH_SIZE - 1)];
+ while (textcmdplayer && textcmdplayer->playernum != playernum) textcmdplayer = textcmdplayer->next;
+
+ if (textcmdplayer) return textcmdplayer->cmd;
+ }
+
+ return NULL;
+}
+
+// Gets the buffer for the specified ticcmd, creating one if necessary
+static UINT8* D_GetTextcmd(tic_t tic, INT32 playernum)
+{
+ textcmdtic_t *textcmdtic = textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
+ textcmdtic_t **tctprev = &textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
+ textcmdplayer_t *textcmdplayer, **tcpprev;
+
+ // Look for the tic.
+ while (textcmdtic && textcmdtic->tic != tic)
+ {
+ tctprev = &textcmdtic->next;
+ textcmdtic = textcmdtic->next;
+ }
+
+ // If we don't have an entry for the tic, make it.
+ if (!textcmdtic)
+ {
+ textcmdtic = *tctprev = Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL);
+ textcmdtic->tic = tic;
+ }
+
+ tcpprev = &textcmdtic->playercmds[playernum & (TEXTCMD_HASH_SIZE - 1)];
+ textcmdplayer = *tcpprev;
+
+ // Look for the player.
+ while (textcmdplayer && textcmdplayer->playernum != playernum)
+ {
+ tcpprev = &textcmdplayer->next;
+ textcmdplayer = textcmdplayer->next;
+ }
+
+ // If we don't have an entry for the player, make it.
+ if (!textcmdplayer)
+ {
+ textcmdplayer = *tcpprev = Z_Calloc(sizeof (textcmdplayer_t), PU_STATIC, NULL);
+ textcmdplayer->playernum = playernum;
+ }
+
+ return textcmdplayer->cmd;
+}
+
+static void ExtraDataTicker(void)
+{
+ INT32 i;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] || i == 0)
+ {
+ UINT8 *bufferstart = D_GetExistingTextcmd(gametic, i);
+
+ if (bufferstart)
+ {
+ UINT8 *curpos = bufferstart;
+ UINT8 *bufferend = &curpos[curpos[0]+1];
+
+ curpos++;
+ while (curpos < bufferend)
+ {
+ if (*curpos < MAXNETXCMD && listnetxcmd[*curpos])
+ {
+ const UINT8 id = *curpos;
+ curpos++;
+ DEBFILE(va("executing x_cmd %s ply %u ", netxcmdnames[id - 1], i));
+ (listnetxcmd[id])(&curpos, i);
+ DEBFILE("done\n");
+ }
+ else
+ {
+ if (server)
+ {
+ SendKick(i, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ DEBFILE(va("player %d kicked [gametic=%u] reason as follows:\n", i, gametic));
+ }
+ CONS_Alert(CONS_WARNING, M_GetText("Got unknown net command [%s]=%d (max %d)\n"), sizeu1(curpos - bufferstart), *curpos, bufferstart[0]);
+ break;
+ }
+ }
+ }
+ }
+
+ // If you are a client, you can safely forget the net commands for this tic
+ // If you are the server, you need to remember them until every client has been acknowledged,
+ // because if you need to resend a PT_SERVERTICS packet, you will need to put the commands in it
+ if (client)
+ D_FreeTextcmd(gametic);
+}
+
+static void D_Clearticcmd(tic_t tic)
+{
+ INT32 i;
+
+ D_FreeTextcmd(tic);
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ netcmds[tic%BACKUPTICS][i].angleturn = 0;
+
+ DEBFILE(va("clear tic %5u (%2u)\n", tic, tic%BACKUPTICS));
+}
+
+void D_ResetTiccmds(void)
+{
+ INT32 i;
+
+ memset(&localcmds, 0, sizeof(ticcmd_t));
+ memset(&localcmds2, 0, sizeof(ticcmd_t));
+
+ // Reset the net command list
+ for (i = 0; i < TEXTCMD_HASH_SIZE; i++)
+ while (textcmds[i])
+ D_Clearticcmd(textcmds[i]->tic);
+}
+
+void SendKick(UINT8 playernum, UINT8 msg)
+{
+ UINT8 buf[2];
+
+ if (!(server && cv_rejointimeout.value))
+ msg &= ~KICK_MSG_KEEP_BODY;
+
+ buf[0] = playernum;
+ buf[1] = msg;
+ SendNetXCmd(XD_KICK, &buf, 2);
+}
+
+// -----------------------------------------------------------------
+// end of extra data function
+// -----------------------------------------------------------------
+
+// -----------------------------------------------------------------
+// extra data function for lmps
+// -----------------------------------------------------------------
+
+// if extradatabit is set, after the ziped tic you find this:
+//
+// type | description
+// ---------+--------------
+// byte | size of the extradata
+// byte | the extradata (xd) bits: see XD_...
+// with this byte you know what parameter folow
+// if (xd & XDNAMEANDCOLOR)
+// byte | color
+// char[MAXPLAYERNAME] | name of the player
+// endif
+// if (xd & XD_WEAPON_PREF)
+// byte | original weapon switch: boolean, true if use the old
+// | weapon switch methode
+// char[NUMWEAPONS] | the weapon switch priority
+// byte | autoaim: true if use the old autoaim system
+// endif
+/*boolean AddLmpExtradata(UINT8 **demo_point, INT32 playernum)
+{
+ UINT8 *textcmd = D_GetExistingTextcmd(gametic, playernum);
+
+ if (!textcmd)
+ return false;
+
+ M_Memcpy(*demo_point, textcmd, textcmd[0]+1);
+ *demo_point += textcmd[0]+1;
+ return true;
+}
+
+void ReadLmpExtraData(UINT8 **demo_pointer, INT32 playernum)
+{
+ UINT8 nextra;
+ UINT8 *textcmd;
+
+ if (!demo_pointer)
+ return;
+
+ textcmd = D_GetTextcmd(gametic, playernum);
+ nextra = **demo_pointer;
+ M_Memcpy(textcmd, *demo_pointer, nextra + 1);
+ // increment demo pointer
+ *demo_pointer += nextra + 1;
+}*/
+
+// -----------------------------------------------------------------
+// end extra data function for lmps
+// -----------------------------------------------------------------
+
+static INT16 Consistancy(void);
+
+typedef enum
+{
+ CL_SEARCHING,
+ CL_CHECKFILES,
+ CL_DOWNLOADFILES,
+ CL_ASKJOIN,
+ CL_LOADFILES,
+ CL_WAITJOINRESPONSE,
+ CL_DOWNLOADSAVEGAME,
+ CL_CONNECTED,
+ CL_ABORTED,
+ CL_ASKFULLFILELIST,
+ CL_CONFIRMCONNECT
+} cl_mode_t;
+
+static void GetPackets(void);
+
+static cl_mode_t cl_mode = CL_SEARCHING;
+
+static UINT16 cl_lastcheckedfilecount = 0; // used for full file list
+
+#ifndef NONET
+#define SNAKE_SPEED 5
+
+#define SNAKE_NUM_BLOCKS_X 20
+#define SNAKE_NUM_BLOCKS_Y 10
+#define SNAKE_BLOCK_SIZE 12
+#define SNAKE_BORDER_SIZE 12
+
+#define SNAKE_MAP_WIDTH (SNAKE_NUM_BLOCKS_X * SNAKE_BLOCK_SIZE)
+#define SNAKE_MAP_HEIGHT (SNAKE_NUM_BLOCKS_Y * SNAKE_BLOCK_SIZE)
+
+#define SNAKE_LEFT_X ((BASEVIDWIDTH - SNAKE_MAP_WIDTH) / 2 - SNAKE_BORDER_SIZE)
+#define SNAKE_RIGHT_X (SNAKE_LEFT_X + SNAKE_MAP_WIDTH + SNAKE_BORDER_SIZE * 2 - 1)
+#define SNAKE_BOTTOM_Y (BASEVIDHEIGHT - 48)
+#define SNAKE_TOP_Y (SNAKE_BOTTOM_Y - SNAKE_MAP_HEIGHT - SNAKE_BORDER_SIZE * 2 + 1)
+
+enum snake_bonustype_s {
+ SNAKE_BONUS_NONE = 0,
+ SNAKE_BONUS_SLOW,
+ SNAKE_BONUS_FAST,
+ SNAKE_BONUS_GHOST,
+ SNAKE_BONUS_NUKE,
+ SNAKE_BONUS_SCISSORS,
+ SNAKE_BONUS_REVERSE,
+ SNAKE_BONUS_EGGMAN,
+ SNAKE_NUM_BONUSES,
+};
+
+static const char *snake_bonuspatches[] = {
+ NULL,
+ "DL_SLOW",
+ "TVSSC0",
+ "TVIVC0",
+ "TVARC0",
+ "DL_SCISSORS",
+ "TVRCC0",
+ "TVEGC0",
+};
+
+static const char *snake_backgrounds[] = {
+ "RVPUMICF",
+ "FRSTRCKF",
+ "TAR",
+ "MMFLRB4",
+ "RVDARKF1",
+ "RVZWALF1",
+ "RVZWALF4",
+ "RVZWALF5",
+ "RVZGRS02",
+ "RVZGRS04",
+};
+
+typedef struct snake_s
+{
+ boolean paused;
+ boolean pausepressed;
+ tic_t time;
+ tic_t nextupdate;
+ boolean gameover;
+ UINT8 background;
+
+ UINT16 snakelength;
+ enum snake_bonustype_s snakebonus;
+ tic_t snakebonustime;
+ UINT8 snakex[SNAKE_NUM_BLOCKS_X * SNAKE_NUM_BLOCKS_Y];
+ UINT8 snakey[SNAKE_NUM_BLOCKS_X * SNAKE_NUM_BLOCKS_Y];
+ UINT8 snakedir[SNAKE_NUM_BLOCKS_X * SNAKE_NUM_BLOCKS_Y];
+
+ UINT8 applex;
+ UINT8 appley;
+
+ enum snake_bonustype_s bonustype;
+ UINT8 bonusx;
+ UINT8 bonusy;
+} snake_t;
+
+static snake_t *snake = NULL;
+
+static void Snake_Initialise(void)
+{
+ if (!snake)
+ snake = malloc(sizeof(snake_t));
+
+ snake->paused = false;
+ snake->pausepressed = false;
+ snake->time = 0;
+ snake->nextupdate = SNAKE_SPEED;
+ snake->gameover = false;
+ snake->background = M_RandomKey(sizeof(snake_backgrounds) / sizeof(*snake_backgrounds));
+
+ snake->snakelength = 1;
+ snake->snakebonus = SNAKE_BONUS_NONE;
+ snake->snakex[0] = M_RandomKey(SNAKE_NUM_BLOCKS_X);
+ snake->snakey[0] = M_RandomKey(SNAKE_NUM_BLOCKS_Y);
+ snake->snakedir[0] = 0;
+ snake->snakedir[1] = 0;
+
+ snake->applex = M_RandomKey(SNAKE_NUM_BLOCKS_X);
+ snake->appley = M_RandomKey(SNAKE_NUM_BLOCKS_Y);
+
+ snake->bonustype = SNAKE_BONUS_NONE;
+}
+
+static UINT8 Snake_GetOppositeDir(UINT8 dir)
+{
+ if (dir == 1 || dir == 3)
+ return dir + 1;
+ else if (dir == 2 || dir == 4)
+ return dir - 1;
+ else
+ return 12 + 5 - dir;
+}
+
+static void Snake_FindFreeSlot(UINT8 *freex, UINT8 *freey, UINT8 headx, UINT8 heady)
+{
+ UINT8 x, y;
+ UINT16 i;
+
+ do
+ {
+ x = M_RandomKey(SNAKE_NUM_BLOCKS_X);
+ y = M_RandomKey(SNAKE_NUM_BLOCKS_Y);
+
+ for (i = 0; i < snake->snakelength; i++)
+ if (x == snake->snakex[i] && y == snake->snakey[i])
+ break;
+ } while (i < snake->snakelength || (x == headx && y == heady)
+ || (x == snake->applex && y == snake->appley)
+ || (snake->bonustype != SNAKE_BONUS_NONE && x == snake->bonusx && y == snake->bonusy));
+
+ *freex = x;
+ *freey = y;
+}
+
+static void Snake_Handle(void)
+{
+ UINT8 x, y;
+ UINT8 oldx, oldy;
+ UINT16 i;
+ UINT16 joystate = 0;
+
+ // Handle retry
+ if (snake->gameover && (G_PlayerInputDown(0, GC_JUMP) || gamekeydown[KEY_ENTER]))
+ {
+ Snake_Initialise();
+ snake->pausepressed = true; // Avoid accidental pause on respawn
+ }
+
+ // Handle pause
+ if (G_PlayerInputDown(0, GC_PAUSE) || gamekeydown[KEY_ENTER])
+ {
+ if (!snake->pausepressed)
+ snake->paused = !snake->paused;
+ snake->pausepressed = true;
+ }
+ else
+ snake->pausepressed = false;
+
+ if (snake->paused)
+ return;
+
+ snake->time++;
+
+ x = snake->snakex[0];
+ y = snake->snakey[0];
+ oldx = snake->snakex[1];
+ oldy = snake->snakey[1];
+
+ // Update direction
+ if (G_PlayerInputDown(0, GC_STRAFELEFT) || gamekeydown[KEY_LEFTARROW] || joystate == 3)
+ {
+ if (snake->snakelength < 2 || x <= oldx)
+ snake->snakedir[0] = 1;
+ }
+ else if (G_PlayerInputDown(0, GC_STRAFERIGHT) || gamekeydown[KEY_RIGHTARROW] || joystate == 4)
+ {
+ if (snake->snakelength < 2 || x >= oldx)
+ snake->snakedir[0] = 2;
+ }
+ else if (G_PlayerInputDown(0, GC_FORWARD) || gamekeydown[KEY_UPARROW] || joystate == 1)
+ {
+ if (snake->snakelength < 2 || y <= oldy)
+ snake->snakedir[0] = 3;
+ }
+ else if (G_PlayerInputDown(0, GC_BACKWARD) || gamekeydown[KEY_DOWNARROW] || joystate == 2)
+ {
+ if (snake->snakelength < 2 || y >= oldy)
+ snake->snakedir[0] = 4;
+ }
+
+ if (snake->snakebonustime)
+ {
+ snake->snakebonustime--;
+ if (!snake->snakebonustime)
+ snake->snakebonus = SNAKE_BONUS_NONE;
+ }
+
+ snake->nextupdate--;
+ if (snake->nextupdate)
+ return;
+ if (snake->snakebonus == SNAKE_BONUS_SLOW)
+ snake->nextupdate = SNAKE_SPEED * 2;
+ else if (snake->snakebonus == SNAKE_BONUS_FAST)
+ snake->nextupdate = SNAKE_SPEED * 2 / 3;
+ else
+ snake->nextupdate = SNAKE_SPEED;
+
+ if (snake->gameover)
+ return;
+
+ // Find new position
+ switch (snake->snakedir[0])
+ {
+ case 1:
+ if (x > 0)
+ x--;
+ else
+ snake->gameover = true;
+ break;
+ case 2:
+ if (x < SNAKE_NUM_BLOCKS_X - 1)
+ x++;
+ else
+ snake->gameover = true;
+ break;
+ case 3:
+ if (y > 0)
+ y--;
+ else
+ snake->gameover = true;
+ break;
+ case 4:
+ if (y < SNAKE_NUM_BLOCKS_Y - 1)
+ y++;
+ else
+ snake->gameover = true;
+ break;
+ }
+
+ // Check collision with snake
+ if (snake->snakebonus != SNAKE_BONUS_GHOST)
+ for (i = 1; i < snake->snakelength - 1; i++)
+ if (x == snake->snakex[i] && y == snake->snakey[i])
+ {
+ if (snake->snakebonus == SNAKE_BONUS_SCISSORS)
+ {
+ snake->snakebonus = SNAKE_BONUS_NONE;
+ snake->snakelength = i;
+ S_StartSound(NULL, sfx_adderr);
+ }
+ else
+ snake->gameover = true;
+ }
+
+ if (snake->gameover)
+ {
+ S_StartSound(NULL, sfx_lose);
+ return;
+ }
+
+ // Check collision with apple
+ if (x == snake->applex && y == snake->appley)
+ {
+ if (snake->snakelength + 3 < SNAKE_NUM_BLOCKS_X * SNAKE_NUM_BLOCKS_Y)
+ {
+ snake->snakelength++;
+ snake->snakex [snake->snakelength - 1] = snake->snakex [snake->snakelength - 2];
+ snake->snakey [snake->snakelength - 1] = snake->snakey [snake->snakelength - 2];
+ snake->snakedir[snake->snakelength - 1] = snake->snakedir[snake->snakelength - 2];
+ }
+
+ // Spawn new apple
+ Snake_FindFreeSlot(&snake->applex, &snake->appley, x, y);
+
+ // Spawn new bonus
+ if (!(snake->snakelength % 5))
+ {
+ do
+ {
+ snake->bonustype = M_RandomKey(SNAKE_NUM_BONUSES - 1) + 1;
+ } while (snake->snakelength > SNAKE_NUM_BLOCKS_X * SNAKE_NUM_BLOCKS_Y * 3 / 4
+ && (snake->bonustype == SNAKE_BONUS_EGGMAN || snake->bonustype == SNAKE_BONUS_FAST || snake->bonustype == SNAKE_BONUS_REVERSE));
+
+ Snake_FindFreeSlot(&snake->bonusx, &snake->bonusy, x, y);
+ }
+
+ S_StartSound(NULL, sfx_s3k6b);
+ }
+
+ if (snake->snakelength > 1 && snake->snakedir[0])
+ {
+ UINT8 dir = snake->snakedir[0];
+
+ oldx = snake->snakex[1];
+ oldy = snake->snakey[1];
+
+ // Move
+ for (i = snake->snakelength - 1; i > 0; i--)
+ {
+ snake->snakex[i] = snake->snakex[i - 1];
+ snake->snakey[i] = snake->snakey[i - 1];
+ snake->snakedir[i] = snake->snakedir[i - 1];
+ }
+
+ // Handle corners
+ if (x < oldx && dir == 3)
+ dir = 5;
+ else if (x > oldx && dir == 3)
+ dir = 6;
+ else if (x < oldx && dir == 4)
+ dir = 7;
+ else if (x > oldx && dir == 4)
+ dir = 8;
+ else if (y < oldy && dir == 1)
+ dir = 9;
+ else if (y < oldy && dir == 2)
+ dir = 10;
+ else if (y > oldy && dir == 1)
+ dir = 11;
+ else if (y > oldy && dir == 2)
+ dir = 12;
+ snake->snakedir[1] = dir;
+ }
+
+ snake->snakex[0] = x;
+ snake->snakey[0] = y;
+
+ // Check collision with bonus
+ if (snake->bonustype != SNAKE_BONUS_NONE && x == snake->bonusx && y == snake->bonusy)
+ {
+ S_StartSound(NULL, sfx_ncchip);
+
+ switch (snake->bonustype)
+ {
+ case SNAKE_BONUS_SLOW:
+ snake->snakebonus = SNAKE_BONUS_SLOW;
+ snake->snakebonustime = 20 * TICRATE;
+ break;
+ case SNAKE_BONUS_FAST:
+ snake->snakebonus = SNAKE_BONUS_FAST;
+ snake->snakebonustime = 20 * TICRATE;
+ break;
+ case SNAKE_BONUS_GHOST:
+ snake->snakebonus = SNAKE_BONUS_GHOST;
+ snake->snakebonustime = 10 * TICRATE;
+ break;
+ case SNAKE_BONUS_NUKE:
+ for (i = 0; i < snake->snakelength; i++)
+ {
+ snake->snakex [i] = snake->snakex [0];
+ snake->snakey [i] = snake->snakey [0];
+ snake->snakedir[i] = snake->snakedir[0];
+ }
+
+ S_StartSound(NULL, sfx_bkpoof);
+ break;
+ case SNAKE_BONUS_SCISSORS:
+ snake->snakebonus = SNAKE_BONUS_SCISSORS;
+ snake->snakebonustime = 60 * TICRATE;
+ break;
+ case SNAKE_BONUS_REVERSE:
+ for (i = 0; i < (snake->snakelength + 1) / 2; i++)
+ {
+ UINT16 i2 = snake->snakelength - 1 - i;
+ UINT8 tmpx = snake->snakex [i];
+ UINT8 tmpy = snake->snakey [i];
+ UINT8 tmpdir = snake->snakedir[i];
+
+ // Swap first segment with last segment
+ snake->snakex [i] = snake->snakex [i2];
+ snake->snakey [i] = snake->snakey [i2];
+ snake->snakedir[i] = Snake_GetOppositeDir(snake->snakedir[i2]);
+ snake->snakex [i2] = tmpx;
+ snake->snakey [i2] = tmpy;
+ snake->snakedir[i2] = Snake_GetOppositeDir(tmpdir);
+ }
+
+ snake->snakedir[0] = 0;
+
+ S_StartSound(NULL, sfx_gravch);
+ break;
+ default:
+ if (snake->snakebonus != SNAKE_BONUS_GHOST)
+ {
+ snake->gameover = true;
+ S_StartSound(NULL, sfx_lose);
+ }
+ }
+
+ snake->bonustype = SNAKE_BONUS_NONE;
+ }
+}
+
+static void Snake_Draw(void)
+{
+ INT16 i;
+
+ // Background
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
+
+ V_DrawFlatFill(
+ SNAKE_LEFT_X + SNAKE_BORDER_SIZE,
+ SNAKE_TOP_Y + SNAKE_BORDER_SIZE,
+ SNAKE_MAP_WIDTH,
+ SNAKE_MAP_HEIGHT,
+ W_GetNumForName(snake_backgrounds[snake->background])
+ );
+
+ // Borders
+ V_DrawFill(SNAKE_LEFT_X, SNAKE_TOP_Y, SNAKE_BORDER_SIZE + SNAKE_MAP_WIDTH, SNAKE_BORDER_SIZE, 242); // Top
+ V_DrawFill(SNAKE_LEFT_X + SNAKE_BORDER_SIZE + SNAKE_MAP_WIDTH, SNAKE_TOP_Y, SNAKE_BORDER_SIZE, SNAKE_BORDER_SIZE + SNAKE_MAP_HEIGHT, 242); // Right
+ V_DrawFill(SNAKE_LEFT_X + SNAKE_BORDER_SIZE, SNAKE_TOP_Y + SNAKE_BORDER_SIZE + SNAKE_MAP_HEIGHT, SNAKE_BORDER_SIZE + SNAKE_MAP_WIDTH, SNAKE_BORDER_SIZE, 242); // Bottom
+ V_DrawFill(SNAKE_LEFT_X, SNAKE_TOP_Y + SNAKE_BORDER_SIZE, SNAKE_BORDER_SIZE, SNAKE_BORDER_SIZE + SNAKE_MAP_HEIGHT, 242); // Left
+
+ // Apple
+ V_DrawFixedPatch(
+ (SNAKE_LEFT_X + SNAKE_BORDER_SIZE + snake->applex * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2) * FRACUNIT,
+ (SNAKE_TOP_Y + SNAKE_BORDER_SIZE + snake->appley * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2) * FRACUNIT,
+ FRACUNIT / 4,
+ 0,
+ W_CachePatchLongName("DL_APPLE", PU_HUDGFX),
+ NULL
+ );
+
+ // Bonus
+ if (snake->bonustype != SNAKE_BONUS_NONE)
+ V_DrawFixedPatch(
+ (SNAKE_LEFT_X + SNAKE_BORDER_SIZE + snake->bonusx * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2 ) * FRACUNIT,
+ (SNAKE_TOP_Y + SNAKE_BORDER_SIZE + snake->bonusy * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2 + 4) * FRACUNIT,
+ FRACUNIT / 2,
+ 0,
+ W_CachePatchLongName(snake_bonuspatches[snake->bonustype], PU_HUDGFX),
+ NULL
+ );
+
+ // Snake
+ if (!snake->gameover || snake->time % 8 < 8 / 2) // Blink if game over
+ {
+ for (i = snake->snakelength - 1; i >= 0; i--)
+ {
+ const char *patchname;
+ UINT8 dir = snake->snakedir[i];
+
+ if (i == 0) // Head
+ {
+ switch (dir)
+ {
+ case 1: patchname = "DL_SNAKEHEAD_L"; break;
+ case 2: patchname = "DL_SNAKEHEAD_R"; break;
+ case 3: patchname = "DL_SNAKEHEAD_T"; break;
+ case 4: patchname = "DL_SNAKEHEAD_B"; break;
+ default: patchname = "DL_SNAKEHEAD_M";
+ }
+ }
+ else // Body
+ {
+ switch (dir)
+ {
+ case 1: patchname = "DL_SNAKEBODY_L"; break;
+ case 2: patchname = "DL_SNAKEBODY_R"; break;
+ case 3: patchname = "DL_SNAKEBODY_T"; break;
+ case 4: patchname = "DL_SNAKEBODY_B"; break;
+ case 5: patchname = "DL_SNAKEBODY_LT"; break;
+ case 6: patchname = "DL_SNAKEBODY_RT"; break;
+ case 7: patchname = "DL_SNAKEBODY_LB"; break;
+ case 8: patchname = "DL_SNAKEBODY_RB"; break;
+ case 9: patchname = "DL_SNAKEBODY_TL"; break;
+ case 10: patchname = "DL_SNAKEBODY_TR"; break;
+ case 11: patchname = "DL_SNAKEBODY_BL"; break;
+ case 12: patchname = "DL_SNAKEBODY_BR"; break;
+ default: patchname = "DL_SNAKEBODY_B";
+ }
+ }
+
+ V_DrawFixedPatch(
+ (SNAKE_LEFT_X + SNAKE_BORDER_SIZE + snake->snakex[i] * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2) * FRACUNIT,
+ (SNAKE_TOP_Y + SNAKE_BORDER_SIZE + snake->snakey[i] * SNAKE_BLOCK_SIZE + SNAKE_BLOCK_SIZE / 2) * FRACUNIT,
+ i == 0 && dir == 0 ? FRACUNIT / 5 : FRACUNIT / 2,
+ snake->snakebonus == SNAKE_BONUS_GHOST ? V_TRANSLUCENT : 0,
+ W_CachePatchLongName(patchname, PU_HUDGFX),
+ NULL
+ );
+ }
+ }
+
+ // Length
+ V_DrawString(SNAKE_RIGHT_X + 4, SNAKE_TOP_Y, V_MONOSPACE, va("%u", snake->snakelength));
+
+ // Bonus
+ if (snake->snakebonus != SNAKE_BONUS_NONE
+ && (snake->snakebonustime >= 3 * TICRATE || snake->time % 4 < 4 / 2))
+ V_DrawFixedPatch(
+ (SNAKE_RIGHT_X + 10) * FRACUNIT,
+ (SNAKE_TOP_Y + 24) * FRACUNIT,
+ FRACUNIT / 2,
+ 0,
+ W_CachePatchLongName(snake_bonuspatches[snake->snakebonus], PU_HUDGFX),
+ NULL
+ );
+}
+
+static void CL_DrawConnectionStatusBox(void)
+{
+ M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-16-8, 32, 1);
+ if (cl_mode != CL_CONFIRMCONNECT)
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-16, V_YELLOWMAP, "Press ESC to abort");
+}
+
+//
+// CL_DrawConnectionStatus
+//
+// Keep the local client informed of our status.
+//
+static inline void CL_DrawConnectionStatus(void)
+{
+ INT32 ccstime = I_GetTime();
+
+ // Draw background fade
+ V_DrawFadeScreen(0xFF00, 16); // force default
+
+ if (cl_mode != CL_DOWNLOADFILES && cl_mode != CL_LOADFILES)
+ {
+ INT32 i, animtime = ((ccstime / 4) & 15) + 16;
+ UINT8 palstart;
+ const char *cltext;
+
+ // Draw the bottom box.
+ CL_DrawConnectionStatusBox();
+
+ if (cl_mode == CL_SEARCHING)
+ palstart = 32; // Red
+ else if (cl_mode == CL_CONFIRMCONNECT)
+ palstart = 48; // Orange
+ else
+ palstart = 96; // Green
+
+ if (!(cl_mode == CL_DOWNLOADSAVEGAME && lastfilenum != -1))
+ for (i = 0; i < 16; ++i) // 15 pal entries total.
+ V_DrawFill((BASEVIDWIDTH/2-128) + (i * 16), BASEVIDHEIGHT-16, 16, 8, palstart + ((animtime - i) & 15));
+
+ switch (cl_mode)
+ {
+ case CL_DOWNLOADSAVEGAME:
+ if (fileneeded && lastfilenum != -1)
+ {
+ UINT32 currentsize = fileneeded[lastfilenum].currentsize;
+ UINT32 totalsize = fileneeded[lastfilenum].totalsize;
+ INT32 dldlength;
+
+ cltext = M_GetText("Downloading game state...");
+ Net_GetNetStat();
+
+ dldlength = (INT32)((currentsize/(double)totalsize) * 256);
+ if (dldlength > 256)
+ dldlength = 256;
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, dldlength, 8, 96);
+
+ V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
+ va(" %4uK/%4uK",currentsize>>10,totalsize>>10));
+
+ V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
+ va("%3.1fK/s ", ((double)getbps)/1024));
+ }
+ else
+ cltext = M_GetText("Waiting to download game state...");
+ break;
+ case CL_ASKFULLFILELIST:
+ case CL_CHECKFILES:
+ cltext = M_GetText("Checking server addon list...");
+ break;
+ case CL_CONFIRMCONNECT:
+ cltext = "";
+ break;
+ case CL_LOADFILES:
+ cltext = M_GetText("Loading server addons...");
+ break;
+ case CL_ASKJOIN:
+ case CL_WAITJOINRESPONSE:
+ if (serverisfull)
+ cltext = M_GetText("Server full, waiting for a slot...");
+ else
+ cltext = M_GetText("Requesting to join...");
+ break;
+ default:
+ cltext = M_GetText("Connecting to server...");
+ break;
+ }
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP, cltext);
+ }
+ else
+ {
+ if (cl_mode == CL_LOADFILES)
+ {
+ INT32 totalfileslength;
+ INT32 loadcompletednum = 0;
+ INT32 i;
+
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-16, V_YELLOWMAP, "Press ESC to abort");
+
+ //ima just count files here
+ if (fileneeded)
+ {
+ for (i = 0; i < fileneedednum; i++)
+ if (fileneeded[i].status == FS_OPEN)
+ loadcompletednum++;
+ }
+
+ // Loading progress
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP, "Loading server addons...");
+ totalfileslength = (INT32)((loadcompletednum/(double)(fileneedednum)) * 256);
+ M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-16-8, 32, 1);
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, totalfileslength, 8, 96);
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
+ va(" %2u/%2u Files",loadcompletednum,fileneedednum));
+ }
+ else if (lastfilenum != -1)
+ {
+ INT32 dldlength;
+ static char tempname[28];
+ fileneeded_t *file;
+ char *filename;
+
+ if (snake)
+ Snake_Draw();
+
+ // Draw the bottom box.
+ CL_DrawConnectionStatusBox();
+
+ if (fileneeded)
+ {
+ file = &fileneeded[lastfilenum];
+ filename = file->filename;
+ }
+ else
+ return;
+
+ Net_GetNetStat();
+ dldlength = (INT32)((file->currentsize/(double)file->totalsize) * 256);
+ if (dldlength > 256)
+ dldlength = 256;
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
+ V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, dldlength, 8, 96);
+
+ memset(tempname, 0, sizeof(tempname));
+ // offset filename to just the name only part
+ filename += strlen(filename) - nameonlylength(filename);
+
+ if (strlen(filename) > sizeof(tempname)-1) // too long to display fully
+ {
+ size_t endhalfpos = strlen(filename)-10;
+ // display as first 14 chars + ... + last 10 chars
+ // which should add up to 27 if our math(s) is correct
+ snprintf(tempname, sizeof(tempname), "%.14s...%.10s", filename, filename+endhalfpos);
+ }
+ else // we can copy the whole thing in safely
+ {
+ strncpy(tempname, filename, sizeof(tempname)-1);
+ }
+
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP,
+ va(M_GetText("Downloading \"%s\""), tempname));
+ V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
+ va(" %4uK/%4uK",fileneeded[lastfilenum].currentsize>>10,file->totalsize>>10));
+ V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
+ va("%3.1fK/s ", ((double)getbps)/1024));
+ }
+ else
+ {
+ if (snake)
+ Snake_Draw();
+
+ CL_DrawConnectionStatusBox();
+ V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP,
+ M_GetText("Waiting to download files..."));
+ }
+ }
+}
+#endif
+
+static boolean CL_AskFileList(INT32 firstfile)
+{
+ netbuffer->packettype = PT_TELLFILESNEEDED;
+ netbuffer->u.filesneedednum = firstfile;
+
+ return HSendPacket(servernode, false, 0, sizeof (INT32));
+}
+
+/** Sends a special packet to declare how many players in local
+ * Used only in arbitratrenetstart()
+ * Sends a PT_CLIENTJOIN packet to the server
+ *
+ * \return True if the packet was successfully sent
+ * \todo Improve the description...
+ *
+ */
+static boolean CL_SendJoin(void)
+{
+ UINT8 localplayers = 1;
+ if (netgame)
+ CONS_Printf(M_GetText("Sending join request...\n"));
+ netbuffer->packettype = PT_CLIENTJOIN;
+
+ netbuffer->u.clientcfg.modversion = MODVERSION;
+ strncpy(netbuffer->u.clientcfg.application,
+ SRB2APPLICATION,
+ sizeof netbuffer->u.clientcfg.application);
+
+ if (splitscreen || botingame)
+ localplayers++;
+ netbuffer->u.clientcfg.localplayers = localplayers;
+
+ CleanupPlayerName(consoleplayer, cv_playername.zstring);
+ if (splitscreen)
+ CleanupPlayerName(1, cv_playername2.zstring);/* 1 is a HACK? oh no */
+
+ strncpy(netbuffer->u.clientcfg.names[0], cv_playername.zstring, MAXPLAYERNAME);
+ strncpy(netbuffer->u.clientcfg.names[1], cv_playername2.zstring, MAXPLAYERNAME);
+
+ return HSendPacket(servernode, true, 0, sizeof (clientconfig_pak));
+}
+
+static INT32 FindRejoinerNum(SINT8 node)
+{
+ char strippednodeaddress[64];
+ const char *nodeaddress;
+ char *port;
+ INT32 i;
+
+ // Make sure there is no dead dress before proceeding to the stripping
+ if (!I_GetNodeAddress)
+ return -1;
+ nodeaddress = I_GetNodeAddress(node);
+ if (!nodeaddress)
+ return -1;
+
+ // Strip the address of its port
+ strcpy(strippednodeaddress, nodeaddress);
+ port = strchr(strippednodeaddress, ':');
+ if (port)
+ *port = '\0';
+
+ // Check if any player matches the stripped address
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i] && playeraddress[i][0] && playernode[i] == UINT8_MAX
+ && !strcmp(playeraddress[i], strippednodeaddress))
+ return i;
+ }
+
+ return -1;
+}
+
+static UINT8
+GetRefuseReason (INT32 node)
+{
+ if (!node || FindRejoinerNum(node) != -1)
+ return 0;
+ else if (bannednode && bannednode[node])
+ return REFUSE_BANNED;
+ else if (!cv_allownewplayer.value)
+ return REFUSE_JOINS_DISABLED;
+ else if (D_NumPlayers() >= cv_maxplayers.value)
+ return REFUSE_SLOTS_FULL;
+ else
+ return 0;
+}
+
+static void SV_SendServerInfo(INT32 node, tic_t servertime)
+{
+ UINT8 *p;
+
+ netbuffer->packettype = PT_SERVERINFO;
+ netbuffer->u.serverinfo._255 = 255;
+ netbuffer->u.serverinfo.packetversion = PACKETVERSION;
+ netbuffer->u.serverinfo.version = VERSION;
+ netbuffer->u.serverinfo.subversion = SUBVERSION;
+ strncpy(netbuffer->u.serverinfo.application, SRB2APPLICATION,
+ sizeof netbuffer->u.serverinfo.application);
+ // return back the time value so client can compute their ping
+ netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
+ netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
+
+ netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
+ netbuffer->u.serverinfo.maxplayer = (UINT8)cv_maxplayers.value;
+
+ netbuffer->u.serverinfo.refusereason = GetRefuseReason(node);
+
+ strncpy(netbuffer->u.serverinfo.gametypename, Gametype_Names[gametype],
+ sizeof netbuffer->u.serverinfo.gametypename);
+ netbuffer->u.serverinfo.modifiedgame = (UINT8)modifiedgame;
+ netbuffer->u.serverinfo.cheatsenabled = CV_CheatsEnabled();
+ netbuffer->u.serverinfo.flags = (dedicated ? SV_DEDICATED : 0);
+ strncpy(netbuffer->u.serverinfo.servername, cv_servername.string,
+ MAXSERVERNAME);
+ strncpy(netbuffer->u.serverinfo.mapname, G_BuildMapName(gamemap), 7);
+
+ M_Memcpy(netbuffer->u.serverinfo.mapmd5, mapmd5, 16);
+
+ memset(netbuffer->u.serverinfo.maptitle, 0, sizeof netbuffer->u.serverinfo.maptitle);
+
+ if (mapheaderinfo[gamemap-1] && *mapheaderinfo[gamemap-1]->lvlttl)
+ {
+ char *read = mapheaderinfo[gamemap-1]->lvlttl, *writ = netbuffer->u.serverinfo.maptitle;
+ while (writ < (netbuffer->u.serverinfo.maptitle+32) && *read != '\0')
+ {
+ if (!(*read & 0x80))
+ {
+ *writ = toupper(*read);
+ writ++;
+ }
+ read++;
+ }
+ *writ = '\0';
+ //strncpy(netbuffer->u.serverinfo.maptitle, (char *)mapheaderinfo[gamemap-1]->lvlttl, 33);
+ }
+ else
+ strncpy(netbuffer->u.serverinfo.maptitle, "UNKNOWN", 32);
+
+ if (mapheaderinfo[gamemap-1] && !(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
+ netbuffer->u.serverinfo.iszone = 1;
+ else
+ netbuffer->u.serverinfo.iszone = 0;
+
+ if (mapheaderinfo[gamemap-1])
+ netbuffer->u.serverinfo.actnum = mapheaderinfo[gamemap-1]->actnum;
+
+ p = PutFileNeeded(0);
+
+ HSendPacket(node, false, 0, p - ((UINT8 *)&netbuffer->u));
+}
+
+static void SV_SendPlayerInfo(INT32 node)
+{
+ UINT8 i;
+ netbuffer->packettype = PT_PLAYERINFO;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ {
+ netbuffer->u.playerinfo[i].num = 255; // This slot is empty.
+ continue;
+ }
+
+ netbuffer->u.playerinfo[i].num = i;
+ strncpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
+ netbuffer->u.playerinfo[i].name[MAXPLAYERNAME] = '\0';
+
+ //fetch IP address
+ //No, don't do that, you fuckface.
+ memset(netbuffer->u.playerinfo[i].address, 0, 4);
+
+ if (G_GametypeHasTeams())
+ {
+ if (!players[i].ctfteam)
+ netbuffer->u.playerinfo[i].team = 255;
+ else
+ netbuffer->u.playerinfo[i].team = (UINT8)players[i].ctfteam;
+ }
+ else
+ {
+ if (players[i].spectator)
+ netbuffer->u.playerinfo[i].team = 255;
+ else
+ netbuffer->u.playerinfo[i].team = 0;
+ }
+
+ netbuffer->u.playerinfo[i].score = LONG(players[i].score);
+ netbuffer->u.playerinfo[i].timeinserver = SHORT((UINT16)(players[i].jointime / TICRATE));
+ netbuffer->u.playerinfo[i].skin = (UINT8)(players[i].skin
+#ifdef DEVELOP // it's safe to do this only because PLAYERINFO isn't read by the game itself
+ % 3
+#endif
+ );
+
+ // Extra data
+ netbuffer->u.playerinfo[i].data = 0; //players[i].skincolor;
+
+ if (players[i].pflags & PF_TAGIT)
+ netbuffer->u.playerinfo[i].data |= 0x20;
+
+ if (players[i].gotflag)
+ netbuffer->u.playerinfo[i].data |= 0x40;
+
+ if (players[i].powers[pw_super])
+ netbuffer->u.playerinfo[i].data |= 0x80;
+ }
+
+ HSendPacket(node, false, 0, sizeof(plrinfo) * MAXPLAYERS);
+}
+
+/** Sends a PT_SERVERCFG packet
+ *
+ * \param node The destination
+ * \return True if the packet was successfully sent
+ *
+ */
+static boolean SV_SendServerConfig(INT32 node)
+{
+ boolean waspacketsent;
+
+ netbuffer->packettype = PT_SERVERCFG;
+
+ netbuffer->u.servercfg.serverplayer = (UINT8)serverplayer;
+ netbuffer->u.servercfg.totalslotnum = (UINT8)(doomcom->numslots);
+ netbuffer->u.servercfg.gametic = (tic_t)LONG(gametic);
+ netbuffer->u.servercfg.clientnode = (UINT8)node;
+ netbuffer->u.servercfg.gamestate = (UINT8)gamestate;
+ netbuffer->u.servercfg.gametype = (UINT8)gametype;
+ netbuffer->u.servercfg.modifiedgame = (UINT8)modifiedgame;
+
+ memcpy(netbuffer->u.servercfg.server_context, server_context, 8);
+
+ {
+ const size_t len = sizeof (serverconfig_pak);
+
+#ifdef DEBUGFILE
+ if (debugfile)
+ {
+ fprintf(debugfile, "ServerConfig Packet about to be sent, size of packet:%s to node:%d\n",
+ sizeu1(len), node);
+ }
+#endif
+
+ waspacketsent = HSendPacket(node, true, 0, len);
+ }
+
+#ifdef DEBUGFILE
+ if (debugfile)
+ {
+ if (waspacketsent)
+ {
+ fprintf(debugfile, "ServerConfig Packet was sent\n");
+ }
+ else
+ {
+ fprintf(debugfile, "ServerConfig Packet could not be sent right now\n");
+ }
+ }
+#endif
+
+ return waspacketsent;
+}
+
+#ifndef NONET
+#define SAVEGAMESIZE (768*1024)
+
+static boolean SV_ResendingSavegameToAnyone(void)
+{
+ INT32 i;
+
+ for (i = 0; i < MAXNETNODES; i++)
+ if (resendingsavegame[i])
+ return true;
+ return false;
+}
+
+static void SV_SendSaveGame(INT32 node, boolean resending)
+{
+ size_t length, compressedlen;
+ UINT8 *savebuffer;
+ UINT8 *compressedsave;
+ UINT8 *buffertosend;
+
+ // first save it in a malloced buffer
+ savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
+ if (!savebuffer)
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
+ return;
+ }
+
+ // Leave room for the uncompressed length.
+ save_p = savebuffer + sizeof(UINT32);
+
+ P_SaveNetGame(resending);
+
+ length = save_p - savebuffer;
+ if (length > SAVEGAMESIZE)
+ {
+ free(savebuffer);
+ save_p = NULL;
+ I_Error("Savegame buffer overrun");
+ }
+
+ // Allocate space for compressed save: one byte fewer than for the
+ // uncompressed data to ensure that the compression is worthwhile.
+ compressedsave = malloc(length - 1);
+ if (!compressedsave)
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
+ return;
+ }
+
+ // Attempt to compress it.
+ if((compressedlen = lzf_compress(savebuffer + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
+ {
+ // Compressing succeeded; send compressed data
+
+ free(savebuffer);
+
+ // State that we're compressed.
+ buffertosend = compressedsave;
+ WRITEUINT32(compressedsave, length - sizeof(UINT32));
+ length = compressedlen + sizeof(UINT32);
+ }
+ else
+ {
+ // Compression failed to make it smaller; send original
+
+ free(compressedsave);
+
+ // State that we're not compressed
+ buffertosend = savebuffer;
+ WRITEUINT32(savebuffer, 0);
+ }
+
+ AddRamToSendQueue(node, buffertosend, length, SF_RAM, 0);
+ save_p = NULL;
+
+ // Remember when we started sending the savegame so we can handle timeouts
+ sendingsavegame[node] = true;
+ freezetimeout[node] = I_GetTime() + jointimeout + length / 1024; // 1 extra tic for each kilobyte
+}
+
+#ifdef DUMPCONSISTENCY
+#define TMPSAVENAME "badmath.sav"
+static consvar_t cv_dumpconsistency = CVAR_INIT ("dumpconsistency", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
+
+static void SV_SavedGame(void)
+{
+ size_t length;
+ UINT8 *savebuffer;
+ char tmpsave[256];
+
+ if (!cv_dumpconsistency.value)
+ return;
+
+ sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
+
+ // first save it in a malloced buffer
+ save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
+ if (!save_p)
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
+ return;
+ }
+
+ P_SaveNetGame(false);
+
+ length = save_p - savebuffer;
+ if (length > SAVEGAMESIZE)
+ {
+ free(savebuffer);
+ save_p = NULL;
+ I_Error("Savegame buffer overrun");
+ }
+
+ // then save it!
+ if (!FIL_WriteFile(tmpsave, savebuffer, length))
+ CONS_Printf(M_GetText("Didn't save %s for netgame"), tmpsave);
+
+ free(savebuffer);
+ save_p = NULL;
+}
+
+#undef TMPSAVENAME
+#endif
+#define TMPSAVENAME "$$$.sav"
+
+
+static void CL_LoadReceivedSavegame(boolean reloading)
+{
+ UINT8 *savebuffer = NULL;
+ size_t length, decompressedlen;
+ char tmpsave[256];
+
+ FreeFileNeeded();
+
+ sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
+
+ length = FIL_ReadFile(tmpsave, &savebuffer);
+
+ CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(length));
+ if (!length)
+ {
+ I_Error("Can't read savegame sent");
+ return;
+ }
+
+ save_p = savebuffer;
+
+ // Decompress saved game if necessary.
+ decompressedlen = READUINT32(save_p);
+ if(decompressedlen > 0)
+ {
+ UINT8 *decompressedbuffer = Z_Malloc(decompressedlen, PU_STATIC, NULL);
+ lzf_decompress(save_p, length - sizeof(UINT32), decompressedbuffer, decompressedlen);
+ Z_Free(savebuffer);
+ save_p = savebuffer = decompressedbuffer;
+ }
+
+ paused = false;
+ demoplayback = false;
+ titlemapinaction = TITLEMAP_OFF;
+ titledemo = false;
+ automapactive = false;
+
+ P_StopRumble(NULL);
+
+ // load a base level
+ if (P_LoadNetGame(reloading))
+ {
+ const UINT8 actnum = mapheaderinfo[gamemap-1]->actnum;
+ CONS_Printf(M_GetText("Map is now \"%s"), G_BuildMapName(gamemap));
+ if (strcmp(mapheaderinfo[gamemap-1]->lvlttl, ""))
+ {
+ CONS_Printf(": %s", mapheaderinfo[gamemap-1]->lvlttl);
+ if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
+ CONS_Printf(M_GetText(" Zone"));
+ if (actnum > 0)
+ CONS_Printf(" %2d", actnum);
+ }
+ CONS_Printf("\"\n");
+ }
+
+ // done
+ Z_Free(savebuffer);
+ save_p = NULL;
+ if (unlink(tmpsave) == -1)
+ CONS_Alert(CONS_ERROR, M_GetText("Can't delete %s\n"), tmpsave);
+ consistancy[gametic%BACKUPTICS] = Consistancy();
+ CON_ToggleOff();
+
+ // Tell the server we have received and reloaded the gamestate
+ // so they know they can resume the game
+ netbuffer->packettype = PT_RECEIVEDGAMESTATE;
+ HSendPacket(servernode, true, 0, 0);
+}
+
+static void CL_ReloadReceivedSavegame(void)
+{
+ INT32 i;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ LUA_InvalidatePlayer(&players[i]);
+ sprintf(player_names[i], "Player %d", i + 1);
+ }
+
+ CL_LoadReceivedSavegame(true);
+
+ if (neededtic < gametic)
+ neededtic = gametic;
+ maketic = neededtic;
+
+ ticcmd_oldangleturn[0] = players[consoleplayer].oldrelangleturn;
+ P_ForceLocalAngle(&players[consoleplayer], (angle_t)(players[consoleplayer].angleturn << 16));
+ if (splitscreen)
+ {
+ ticcmd_oldangleturn[1] = players[secondarydisplayplayer].oldrelangleturn;
+ P_ForceLocalAngle(&players[secondarydisplayplayer], (angle_t)(players[secondarydisplayplayer].angleturn << 16));
+ }
+
+ camera.subsector = R_PointInSubsector(camera.x, camera.y);
+ camera2.subsector = R_PointInSubsector(camera2.x, camera2.y);
+
+ cl_redownloadinggamestate = false;
+
+ CONS_Printf(M_GetText("Game state reloaded\n"));
+}
+#endif
+
+#ifndef NONET
+static void SendAskInfo(INT32 node)
+{
+ const tic_t asktime = I_GetTime();
+ netbuffer->packettype = PT_ASKINFO;
+ netbuffer->u.askinfo.version = VERSION;
+ netbuffer->u.askinfo.time = (tic_t)LONG(asktime);
+
+ // Even if this never arrives due to the host being firewalled, we've
+ // now allowed traffic from the host to us in, so once the MS relays
+ // our address to the host, it'll be able to speak to us.
+ HSendPacket(node, false, 0, sizeof (askinfo_pak));
+}
+
+serverelem_t serverlist[MAXSERVERLIST];
+UINT32 serverlistcount = 0;
+
+#define FORCECLOSE 0x8000
+
+static void SL_ClearServerList(INT32 connectedserver)
+{
+ UINT32 i;
+
+ for (i = 0; i < serverlistcount; i++)
+ if (connectedserver != serverlist[i].node)
+ {
+ Net_CloseConnection(serverlist[i].node|FORCECLOSE);
+ serverlist[i].node = 0;
+ }
+ serverlistcount = 0;
+}
+
+static UINT32 SL_SearchServer(INT32 node)
+{
+ UINT32 i;
+ for (i = 0; i < serverlistcount; i++)
+ if (serverlist[i].node == node)
+ return i;
+
+ return UINT32_MAX;
+}
+
+static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
+{
+ UINT32 i;
+
+ // search if not already on it
+ i = SL_SearchServer(node);
+ if (i == UINT32_MAX)
+ {
+ // not found add it
+ if (serverlistcount >= MAXSERVERLIST)
+ return; // list full
+
+ /* check it later if connecting to this one */
+ if (node != servernode)
+ {
+ if (info->_255 != 255)
+ return;/* old packet format */
+
+ if (info->packetversion != PACKETVERSION)
+ return;/* old new packet format */
+
+ if (info->version != VERSION)
+ return; // Not same version.
+
+ if (info->subversion != SUBVERSION)
+ return; // Close, but no cigar.
+
+ if (strcmp(info->application, SRB2APPLICATION))
+ return;/* that's a different mod */
+ }
+
+ i = serverlistcount++;
+ }
+
+ serverlist[i].info = *info;
+ serverlist[i].node = node;
+
+ // resort server list
+ M_SortServerList();
+}
+
+#if defined (MASTERSERVER) && defined (HAVE_THREADS)
+struct Fetch_servers_ctx
+{
+ int room;
+ int id;
+};
+
+static void
+Fetch_servers_thread (struct Fetch_servers_ctx *ctx)
+{
+ msg_server_t *server_list;
+
+ server_list = GetShortServersList(ctx->room, ctx->id);
+
+ if (server_list)
+ {
+ I_lock_mutex(&ms_QueryId_mutex);
+ {
+ if (ctx->id != ms_QueryId)
+ {
+ free(server_list);
+ server_list = NULL;
+ }
+ }
+ I_unlock_mutex(ms_QueryId_mutex);
+
+ if (server_list)
+ {
+ I_lock_mutex(&m_menu_mutex);
+ {
+ if (m_waiting_mode == M_WAITING_SERVERS)
+ m_waiting_mode = M_NOT_WAITING;
+ }
+ I_unlock_mutex(m_menu_mutex);
+
+ I_lock_mutex(&ms_ServerList_mutex);
+ {
+ ms_ServerList = server_list;
+ }
+ I_unlock_mutex(ms_ServerList_mutex);
+ }
+ }
+
+ free(ctx);
+}
+#endif/*defined (MASTERSERVER) && defined (HAVE_THREADS)*/
+
+void CL_QueryServerList (msg_server_t *server_list)
+{
+ INT32 i;
+
+ for (i = 0; server_list[i].header.buffer[0]; i++)
+ {
+ // Make sure MS version matches our own, to
+ // thwart nefarious servers who lie to the MS.
+
+ /* lol bruh, that version COMES from the servers */
+ //if (strcmp(version, server_list[i].version) == 0)
+ {
+ INT32 node = I_NetMakeNodewPort(server_list[i].ip, server_list[i].port);
+ if (node == -1)
+ break; // no more node free
+ SendAskInfo(node);
+ // Force close the connection so that servers can't eat
+ // up nodes forever if we never get a reply back from them
+ // (usually when they've not forwarded their ports).
+ //
+ // Don't worry, we'll get in contact with the working
+ // servers again when they send SERVERINFO to us later!
+ //
+ // (Note: as a side effect this probably means every
+ // server in the list will probably be using the same node (e.g. node 1),
+ // not that it matters which nodes they use when
+ // the connections are closed afterwards anyway)
+ // -- Monster Iestyn 12/11/18
+ Net_CloseConnection(node|FORCECLOSE);
+ }
+ }
+}
+
+void CL_UpdateServerList(boolean internetsearch, INT32 room)
+{
+ (void)internetsearch;
+ (void)room;
+
+ SL_ClearServerList(0);
+
+ if (!netgame && I_NetOpenSocket)
+ {
+ if (I_NetOpenSocket())
+ {
+ netgame = true;
+ multiplayer = true;
+ }
+ }
+
+ // search for local servers
+ if (netgame)
+ SendAskInfo(BROADCASTADDR);
+
+#ifdef MASTERSERVER
+ if (internetsearch)
+ {
+#ifdef HAVE_THREADS
+ struct Fetch_servers_ctx *ctx;
+
+ ctx = malloc(sizeof *ctx);
+
+ /* This called from M_Refresh so I don't use a mutex */
+ m_waiting_mode = M_WAITING_SERVERS;
+
+ I_lock_mutex(&ms_QueryId_mutex);
+ {
+ ctx->id = ms_QueryId;
+ }
+ I_unlock_mutex(ms_QueryId_mutex);
+
+ ctx->room = room;
+
+ I_spawn_thread("fetch-servers", (I_thread_fn)Fetch_servers_thread, ctx);
+#else
+ msg_server_t *server_list;
+
+ server_list = GetShortServersList(room, 0);
+
+ if (server_list)
+ {
+ CL_QueryServerList(server_list);
+ free(server_list);
+ }
+#endif
+ }
+#endif/*MASTERSERVER*/
+}
+
+#endif // ifndef NONET
+
+static void M_ConfirmConnect(event_t *ev)
+{
+#ifndef NONET
+
+ if (ev->type == ev_keydown || ev->type == ev_gamepad_down)
+ {
+ if ((ev->type == ev_keydown && (ev->key == ' ' || ev->key == 'y' || ev->key == KEY_ENTER)) || (ev->type == ev_gamepad_down && ev->which == 0 && ev->key == GAMEPAD_BUTTON_A))
+ {
+ if (totalfilesrequestednum > 0)
+ {
+ if (CL_SendFileRequest())
+ {
+ cl_mode = CL_DOWNLOADFILES;
+ Snake_Initialise();
+ }
+ }
+ else
+ cl_mode = CL_LOADFILES;
+
+ M_ClearMenus(true);
+ }
+ else if ((ev->type == ev_keydown && (ev->key == 'n' || ev->key == KEY_ESCAPE)) || (ev->type == ev_gamepad_down && ev->which == 0 && ev->key == GAMEPAD_BUTTON_B))
+ {
+ cl_mode = CL_ABORTED;
+ M_ClearMenus(true);
+ }
+ }
+#else
+ (void)ev;
+#endif
+}
+
+static boolean CL_FinishedFileList(void)
+{
+ INT32 i;
+ char *downloadsize = NULL;
+
+ //CONS_Printf(M_GetText("Checking files...\n"));
+ i = CL_CheckFiles();
+ if (i == 4) // still checking ...
+ {
+ return true;
+ }
+ else if (i == 3) // too many files
+ {
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText(
+ "You have too many WAD files loaded\n"
+ "to add ones the server is using.\n"
+ "Please restart SRB2 before connecting.\n\n"
+ "Press ESC\n"
+ ), NULL, MM_NOTHING);
+ return false;
+ }
+ else if (i == 2) // cannot join for some reason
+ {
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText(
+ "You have the wrong addons loaded.\n\n"
+ "To play on this server, restart\n"
+ "the game and don't load any addons.\n"
+ "SRB2 will automatically add\n"
+ "everything you need when you join.\n\n"
+ "Press ESC\n"
+ ), NULL, MM_NOTHING);
+ return false;
+ }
+ else if (i == 1)
+ {
+ if (serverisfull)
+ {
+ M_StartMessage(M_GetText(
+ "This server is full!\n"
+ "\n"
+ "You may load server addons (if any), and wait for a slot.\n"
+ "\n"
+ "Press ENTER to continue\nor ESC to cancel.\n\n"
+ ), M_ConfirmConnect, MM_EVENTHANDLER);
+ cl_mode = CL_CONFIRMCONNECT;
+ curfadevalue = 0;
+ }
+ else
+ cl_mode = CL_LOADFILES;
+ }
+ else
+ {
+ // must download something
+ // can we, though?
+ if (!CL_CheckDownloadable()) // nope!
+ {
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText(
+ "An error occured when trying to\n"
+ "download missing addons.\n"
+ "(This is almost always a problem\n"
+ "with the server, not your game.)\n\n"
+ "See the console or log file\n"
+ "for additional details.\n\n"
+ "Press ESC\n"
+ ), NULL, MM_NOTHING);
+ return false;
+ }
+
+#ifndef NONET
+ downloadcompletednum = 0;
+ downloadcompletedsize = 0;
+ totalfilesrequestednum = 0;
+ totalfilesrequestedsize = 0;
+
+ if (fileneeded == NULL)
+ I_Error("CL_FinishedFileList: fileneeded == NULL");
+
+ for (i = 0; i < fileneedednum; i++)
+ if (fileneeded[i].status == FS_NOTFOUND || fileneeded[i].status == FS_MD5SUMBAD)
+ {
+ totalfilesrequestednum++;
+ totalfilesrequestedsize += fileneeded[i].totalsize;
+ }
+
+ if (totalfilesrequestedsize>>20 >= 100)
+ downloadsize = Z_StrDup(va("%uM",totalfilesrequestedsize>>20));
+ else
+ downloadsize = Z_StrDup(va("%uK",totalfilesrequestedsize>>10));
+#endif
+
+ if (serverisfull)
+ M_StartMessage(va(M_GetText(
+ "This server is full!\n"
+ "Download of %s additional content\nis required to join.\n"
+ "\n"
+ "You may download, load server addons,\nand wait for a slot.\n"
+ "\n"
+ "Press ENTER to continue\nor ESC to cancel.\n"
+ ), downloadsize), M_ConfirmConnect, MM_EVENTHANDLER);
+ else
+ M_StartMessage(va(M_GetText(
+ "Download of %s additional content\nis required to join.\n"
+ "\n"
+ "Press ENTER to continue\nor ESC to cancel.\n"
+ ), downloadsize), M_ConfirmConnect, MM_EVENTHANDLER);
+
+ Z_Free(downloadsize);
+ cl_mode = CL_CONFIRMCONNECT;
+ curfadevalue = 0;
+ }
+ return true;
+}
+
+#ifndef NONET
+static const char * InvalidServerReason (serverinfo_pak *info)
+{
+#define EOT "\nPress ESC\n"
+
+ /* magic number for new packet format */
+ if (info->_255 != 255)
+ {
+ return
+ "Outdated server (version unknown).\n" EOT;
+ }
+
+ if (strncmp(info->application, SRB2APPLICATION, sizeof
+ info->application))
+ {
+ return va(
+ "%s cannot connect\n"
+ "to %s servers.\n" EOT,
+ SRB2APPLICATION,
+ info->application);
+ }
+
+ if (
+ info->packetversion != PACKETVERSION ||
+ info->version != VERSION ||
+ info->subversion != SUBVERSION
+ ){
+ return va(
+ "Incompatible %s versions.\n"
+ "(server version %d.%d.%d)\n" EOT,
+ SRB2APPLICATION,
+ info->version / 100,
+ info->version % 100,
+ info->subversion);
+ }
+
+ switch (info->refusereason)
+ {
+ case REFUSE_BANNED:
+ return
+ "You have been banned\n"
+ "from the server.\n" EOT;
+ case REFUSE_JOINS_DISABLED:
+ return
+ "The server is not accepting\n"
+ "joins for the moment.\n" EOT;
+ case REFUSE_SLOTS_FULL:
+ return va(
+ "Maximum players reached: %d\n" EOT,
+ info->maxplayer);
+ default:
+ if (info->refusereason)
+ {
+ return
+ "You can't join.\n"
+ "I don't know why,\n"
+ "but you can't join.\n" EOT;
+ }
+ }
+
+ return NULL;
+
+#undef EOT
+}
+#endif // ifndef NONET
+
+/** Called by CL_ServerConnectionTicker
+ *
+ * \param asksent The last time we asked the server to join. We re-ask every second in case our request got lost in transmit.
+ * \return False if the connection was aborted
+ * \sa CL_ServerConnectionTicker
+ * \sa CL_ConnectToServer
+ *
+ */
+static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
+{
+#ifndef NONET
+ INT32 i;
+
+ // serverlist is updated by GetPacket function
+ if (serverlistcount > 0)
+ {
+ // this can be a responce to our broadcast request
+ if (servernode == -1 || servernode >= MAXNETNODES)
+ {
+ i = 0;
+ servernode = serverlist[i].node;
+ CONS_Printf(M_GetText("Found, "));
+ }
+ else
+ {
+ i = SL_SearchServer(servernode);
+ if (i < 0)
+ return true;
+ }
+
+ if (client)
+ {
+ serverinfo_pak *info = &serverlist[i].info;
+
+ if (info->refusereason == REFUSE_SLOTS_FULL)
+ serverisfull = true;
+ else
+ {
+ const char *reason = InvalidServerReason(info);
+
+ // Quit here rather than downloading files
+ // and being refused later.
+ if (reason)
+ {
+ char *message = Z_StrDup(reason);
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(message, NULL, MM_NOTHING);
+ Z_Free(message);
+ return false;
+ }
+ }
+
+ D_ParseFileneeded(info->fileneedednum, info->fileneeded, 0);
+
+ if (info->flags & SV_LOTSOFADDONS)
+ {
+ cl_mode = CL_ASKFULLFILELIST;
+ cl_lastcheckedfilecount = 0;
+ return true;
+ }
+
+ cl_mode = CL_CHECKFILES;
+ }
+ else
+ {
+ cl_mode = CL_ASKJOIN; // files need not be checked for the server.
+ *asksent = 0;
+ }
+
+ return true;
+ }
+
+ // Ask the info to the server (askinfo packet)
+ if (*asksent + NEWTICRATE < I_GetTime())
+ {
+ SendAskInfo(servernode);
+ *asksent = I_GetTime();
+ }
+#else
+ (void)asksent;
+ // No netgames, so we skip this state.
+ cl_mode = CL_ASKJOIN;
+#endif // ifndef NONET/else
+
+ return true;
+}
+
+/** Called by CL_ConnectToServer
+ *
+ * \param tmpsave The name of the gamestate file???
+ * \param oldtic Used for knowing when to poll events and redraw
+ * \param asksent ???
+ * \return False if the connection was aborted
+ * \sa CL_ServerConnectionSearchTicker
+ * \sa CL_ConnectToServer
+ *
+ */
+static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic_t *asksent)
+{
+ boolean waitmore;
+ INT32 i;
+
+#ifdef NONET
+ (void)tmpsave;
+#endif
+
+ switch (cl_mode)
+ {
+ case CL_SEARCHING:
+ if (!CL_ServerConnectionSearchTicker(asksent))
+ return false;
+ break;
+
+ case CL_ASKFULLFILELIST:
+ if (cl_lastcheckedfilecount == UINT16_MAX) // All files retrieved
+ cl_mode = CL_CHECKFILES;
+ else if (fileneedednum != cl_lastcheckedfilecount || I_GetTime() >= *asksent)
+ {
+ if (CL_AskFileList(fileneedednum))
+ {
+ cl_lastcheckedfilecount = fileneedednum;
+ *asksent = I_GetTime() + NEWTICRATE;
+ }
+ }
+ break;
+ case CL_CHECKFILES:
+ if (!CL_FinishedFileList())
+ return false;
+ break;
+ case CL_DOWNLOADFILES:
+ waitmore = false;
+ for (i = 0; i < fileneedednum; i++)
+ if (fileneeded[i].status == FS_DOWNLOADING
+ || fileneeded[i].status == FS_REQUESTED)
+ {
+ waitmore = true;
+ break;
+ }
+ if (waitmore)
+ break; // exit the case
+
+#ifndef NONET
+ if (snake)
+ {
+ free(snake);
+ snake = NULL;
+ }
+#endif
+
+ cl_mode = CL_LOADFILES;
+ break;
+ case CL_LOADFILES:
+ if (CL_LoadServerFiles())
+ {
+ FreeFileNeeded();
+ *asksent = 0; //This ensure the first join ask is right away
+ firstconnectattempttime = I_GetTime();
+ cl_mode = CL_ASKJOIN;
+ }
+ break;
+ case CL_ASKJOIN:
+ if (firstconnectattempttime + NEWTICRATE*300 < I_GetTime() && !server)
+ {
+ CONS_Printf(M_GetText("5 minute wait time exceeded.\n"));
+ CONS_Printf(M_GetText("Network game synchronization aborted.\n"));
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText(
+ "5 minute wait time exceeded.\n"
+ "You may retry connection.\n"
+ "\n"
+ "Press ESC\n"
+ ), NULL, MM_NOTHING);
+ return false;
+ }
+#ifndef NONET
+ // prepare structures to save the file
+ // WARNING: this can be useless in case of server not in GS_LEVEL
+ // but since the network layer doesn't provide ordered packets...
+ CL_PrepareDownloadSaveGame(tmpsave);
+#endif
+ if (I_GetTime() >= *asksent && CL_SendJoin())
+ {
+ *asksent = I_GetTime() + NEWTICRATE*3;
+ cl_mode = CL_WAITJOINRESPONSE;
+ }
+ break;
+ case CL_WAITJOINRESPONSE:
+ if (I_GetTime() >= *asksent)
+ {
+ cl_mode = CL_ASKJOIN;
+ }
+ break;
+#ifndef NONET
+ case CL_DOWNLOADSAVEGAME:
+ // At this state, the first (and only) needed file is the gamestate
+ if (fileneeded[0].status == FS_FOUND)
+ {
+ // Gamestate is now handled within CL_LoadReceivedSavegame()
+ CL_LoadReceivedSavegame(false);
+ cl_mode = CL_CONNECTED;
+ } // don't break case continue to CL_CONNECTED
+ else
+ break;
+#endif
+
+ case CL_CONNECTED:
+ case CL_CONFIRMCONNECT: //logic is handled by M_ConfirmConnect
+ default:
+ break;
+
+ // Connection closed by cancel, timeout or refusal.
+ case CL_ABORTED:
+ cl_mode = CL_SEARCHING;
+ return false;
+ }
+
+ GetPackets();
+ Net_AckTicker();
+
+ // Call it only once by tic
+ if (*oldtic != I_GetTime())
+ {
+ I_OsPolling();
+
+ if (cl_mode == CL_CONFIRMCONNECT)
+ D_ProcessEvents(); //needed for menu system to receive inputs
+ else
+ {
+ // my hand has been forced and I am dearly sorry for this awful hack :vomit:
+ for (; eventtail != eventhead; eventtail = (eventtail+1) & (MAXEVENTS-1))
+ {
+ G_MapEventsToControls(&events[eventtail]);
+ }
+ }
+
+ if (gamekeydown[KEY_ESCAPE] || gamepads[0].buttons[GAMEPAD_BUTTON_B] || cl_mode == CL_ABORTED)
+ {
+ CONS_Printf(M_GetText("Network game synchronization aborted.\n"));
+ M_StartMessage(M_GetText("Network game synchronization aborted.\n\nPress ESC\n"), NULL, MM_NOTHING);
+
+#ifndef NONET
+ if (snake)
+ {
+ free(snake);
+ snake = NULL;
+ }
+#endif
+
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ memset(gamekeydown, 0, NUMKEYS);
+ return false;
+ }
+#ifndef NONET
+ else if (cl_mode == CL_DOWNLOADFILES && snake)
+ Snake_Handle();
+#endif
+
+ if (client && (cl_mode == CL_DOWNLOADFILES || cl_mode == CL_DOWNLOADSAVEGAME))
+ FileReceiveTicker();
+
+ // why are these here? this is for servers, we're a client
+ //if (key == 's' && server)
+ // doomcom->numnodes = (INT16)pnumnodes;
+ //FileSendTicker();
+ *oldtic = I_GetTime();
+
+#ifndef NONET
+ if (client && cl_mode != CL_CONNECTED && cl_mode != CL_ABORTED)
+ {
+ if (!snake)
+ {
+ F_MenuPresTicker(true); // title sky
+ F_TitleScreenTicker(true);
+ F_TitleScreenDrawer();
+ }
+ CL_DrawConnectionStatus();
+#ifdef HAVE_THREADS
+ I_lock_mutex(&m_menu_mutex);
+#endif
+ M_Drawer(); //Needed for drawing messageboxes on the connection screen
+#ifdef HAVE_THREADS
+ I_unlock_mutex(m_menu_mutex);
+#endif
+ I_UpdateNoVsync(); // page flip or blit buffer
+ if (moviemode)
+ M_SaveFrame();
+ S_UpdateSounds();
+ S_UpdateClosedCaptions();
+ }
+#else
+ CON_Drawer();
+ I_UpdateNoVsync();
+#endif
+ }
+ else
+ {
+ I_Sleep(cv_sleep.value);
+ I_UpdateTime(cv_timescale.value);
+ }
+
+ return true;
+}
+
+/** Use adaptive send using net_bandwidth and stat.sendbytes
+ *
+ * \todo Better description...
+ *
+ */
+static void CL_ConnectToServer(void)
+{
+ INT32 pnumnodes, nodewaited = doomcom->numnodes, i;
+ tic_t oldtic;
+#ifndef NONET
+ tic_t asksent;
+ char tmpsave[256];
+
+ sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
+
+ lastfilenum = -1;
+#endif
+
+ cl_mode = CL_SEARCHING;
+
+#ifndef NONET
+ // Don't get a corrupt savegame error because tmpsave already exists
+ if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
+ I_Error("Can't delete %s\n", tmpsave);
+#endif
+
+ if (netgame)
+ {
+ if (servernode < 0 || servernode >= MAXNETNODES)
+ CONS_Printf(M_GetText("Searching for a server...\n"));
+ else
+ CONS_Printf(M_GetText("Contacting the server...\n"));
+ }
+
+ if (gamestate == GS_INTERMISSION)
+ Y_EndIntermission(); // clean up intermission graphics etc
+
+ DEBFILE(va("waiting %d nodes\n", doomcom->numnodes));
+ G_SetGamestate(GS_WAITINGPLAYERS);
+ wipegamestate = GS_WAITINGPLAYERS;
+
+ ClearAdminPlayers();
+ pnumnodes = 1;
+ oldtic = I_GetTime() - 1;
+
+#ifndef NONET
+ asksent = (tic_t) - TICRATE;
+ firstconnectattempttime = I_GetTime();
+
+ i = SL_SearchServer(servernode);
+
+ if (i != -1)
+ {
+ char *gametypestr = serverlist[i].info.gametypename;
+ CONS_Printf(M_GetText("Connecting to: %s\n"), serverlist[i].info.servername);
+ gametypestr[sizeof serverlist[i].info.gametypename - 1] = '\0';
+ CONS_Printf(M_GetText("Gametype: %s\n"), gametypestr);
+ CONS_Printf(M_GetText("Version: %d.%d.%u\n"), serverlist[i].info.version/100,
+ serverlist[i].info.version%100, serverlist[i].info.subversion);
+ }
+ SL_ClearServerList(servernode);
+#endif
+
+ do
+ {
+ // If the connection was aborted for some reason, leave
+#ifndef NONET
+ if (!CL_ServerConnectionTicker(tmpsave, &oldtic, &asksent))
+#else
+ if (!CL_ServerConnectionTicker((char*)NULL, &oldtic, (tic_t *)NULL))
+#endif
+ return;
+
+ if (server)
+ {
+ pnumnodes = 0;
+ for (i = 0; i < MAXNETNODES; i++)
+ if (nodeingame[i])
+ pnumnodes++;
+ }
+ }
+ while (!(cl_mode == CL_CONNECTED && (client || (server && nodewaited <= pnumnodes))));
+
+ DEBFILE(va("Synchronisation Finished\n"));
+
+ displayplayer = consoleplayer;
+}
+
+#ifndef NONET
+typedef struct banreason_s
+{
+ char *reason;
+ struct banreason_s *prev; //-1
+ struct banreason_s *next; //+1
+} banreason_t;
+
+static banreason_t *reasontail = NULL; //last entry, use prev
+static banreason_t *reasonhead = NULL; //1st entry, use next
+
+static void Command_ShowBan(void) //Print out ban list
+{
+ size_t i;
+ const char *address, *mask;
+ banreason_t *reasonlist = reasonhead;
+
+ if (I_GetBanAddress)
+ CONS_Printf(M_GetText("Ban List:\n"));
+ else
+ return;
+
+ for (i = 0;(address = I_GetBanAddress(i)) != NULL;i++)
+ {
+ if (!I_GetBanMask || (mask = I_GetBanMask(i)) == NULL)
+ CONS_Printf("%s: %s ", sizeu1(i+1), address);
+ else
+ CONS_Printf("%s: %s/%s ", sizeu1(i+1), address, mask);
+
+ if (reasonlist && reasonlist->reason)
+ CONS_Printf("(%s)\n", reasonlist->reason);
+ else
+ CONS_Printf("\n");
+
+ if (reasonlist) reasonlist = reasonlist->next;
+ }
+
+ if (i == 0 && !address)
+ CONS_Printf(M_GetText("(empty)\n"));
+}
+
+void D_SaveBan(void)
+{
+ FILE *f;
+ size_t i;
+ banreason_t *reasonlist = reasonhead;
+ const char *address, *mask;
+ const char *path = va("%s"PATHSEP"%s", srb2home, "ban.txt");
+
+ if (!reasonhead)
+ {
+ remove(path);
+ return;
+ }
+
+ f = fopen(path, "w");
+
+ if (!f)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("Could not save ban list into ban.txt\n"));
+ return;
+ }
+
+ for (i = 0;(address = I_GetBanAddress(i)) != NULL;i++)
+ {
+ if (!I_GetBanMask || (mask = I_GetBanMask(i)) == NULL)
+ fprintf(f, "%s 0", address);
+ else
+ fprintf(f, "%s %s", address, mask);
+
+ if (reasonlist && reasonlist->reason)
+ fprintf(f, " %s\n", reasonlist->reason);
+ else
+ fprintf(f, " %s\n", "NA");
+
+ if (reasonlist) reasonlist = reasonlist->next;
+ }
+
+ fclose(f);
+}
+
+static void Ban_Add(const char *reason)
+{
+ banreason_t *reasonlist = malloc(sizeof(*reasonlist));
+
+ if (!reasonlist)
+ return;
+ if (!reason)
+ reason = "NA";
+
+ reasonlist->next = NULL;
+ reasonlist->reason = Z_StrDup(reason);
+ if ((reasonlist->prev = reasontail) == NULL)
+ reasonhead = reasonlist;
+ else
+ reasontail->next = reasonlist;
+ reasontail = reasonlist;
+}
+
+static void Ban_Clear(void)
+{
+ banreason_t *temp;
+
+ I_ClearBans();
+
+ reasontail = NULL;
+
+ while (reasonhead)
+ {
+ temp = reasonhead->next;
+ Z_Free(reasonhead->reason);
+ free(reasonhead);
+ reasonhead = temp;
+ }
+}
+
+static void Command_ClearBans(void)
+{
+ if (!I_ClearBans)
+ return;
+
+ Ban_Clear();
+ D_SaveBan();
+}
+
+static void Ban_Load_File(boolean warning)
+{
+ FILE *f;
+ size_t i;
+ const char *address, *mask;
+ char buffer[MAX_WADPATH];
+
+ if (!I_ClearBans)
+ return;
+
+ f = fopen(va("%s"PATHSEP"%s", srb2home, "ban.txt"), "r");
+
+ if (!f)
+ {
+ if (warning)
+ CONS_Alert(CONS_WARNING, M_GetText("Could not open ban.txt for ban list\n"));
+ return;
+ }
+
+ Ban_Clear();
+
+ for (i=0; fgets(buffer, (int)sizeof(buffer), f); i++)
+ {
+ address = strtok(buffer, " \t\r\n");
+ mask = strtok(NULL, " \t\r\n");
+
+ I_SetBanAddress(address, mask);
+
+ Ban_Add(strtok(NULL, "\r\n"));
+ }
+
+ fclose(f);
+}
+
+static void Command_ReloadBan(void) //recheck ban.txt
+{
+ Ban_Load_File(true);
+}
+
+static void Command_connect(void)
+{
+ if (COM_Argc() < 2 || *COM_Argv(1) == 0)
+ {
+ CONS_Printf(M_GetText(
+ "Connect <serveraddress> (port): connect to a server\n"
+ "Connect ANY: connect to the first lan server found\n"
+ //"Connect SELF: connect to your own server.\n"
+ ));
+ return;
+ }
+
+ if (Playing() || titledemo)
+ {
+ CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
+ return;
+ }
+
+ // modified game check: no longer handled
+ // we don't request a restart unless the filelist differs
+
+ server = false;
+/*
+ if (!stricmp(COM_Argv(1), "self"))
+ {
+ servernode = 0;
+ server = true;
+ /// \bug should be but...
+ //SV_SpawnServer();
+ }
+ else
+*/
+ {
+ // used in menu to connect to a server in the list
+ if (netgame && !stricmp(COM_Argv(1), "node"))
+ {
+ servernode = (SINT8)atoi(COM_Argv(2));
+ }
+ else if (netgame)
+ {
+ CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
+ return;
+ }
+ else if (I_NetOpenSocket)
+ {
+ I_NetOpenSocket();
+ netgame = true;
+ multiplayer = true;
+
+ if (!stricmp(COM_Argv(1), "any"))
+ servernode = BROADCASTADDR;
+ else if (I_NetMakeNodewPort)
+ {
+ if (COM_Argc() >= 3) // address AND port
+ servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
+ else // address only, or address:port
+ servernode = I_NetMakeNode(COM_Argv(1));
+ }
+ else
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
+ D_CloseConnection();
+ return;
+ }
+ }
+ else
+ CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
+ }
+
+ splitscreen = false;
+ SplitScreen_OnChange();
+ botingame = false;
+ botskin = 0;
+ CL_ConnectToServer();
+}
+#endif
+
+static void ResetNode(INT32 node);
+
+//
+// CL_ClearPlayer
+//
+// Clears the player data so that a future client can use this slot
+//
+void CL_ClearPlayer(INT32 playernum)
+{
+ if (players[playernum].mo)
+ P_RemoveMobj(players[playernum].mo);
+ memset(&players[playernum], 0, sizeof (player_t));
+ memset(playeraddress[playernum], 0, sizeof(*playeraddress));
+}
+
+//
+// CL_RemovePlayer
+//
+// Removes a player from the current game
+//
+void CL_RemovePlayer(INT32 playernum, kickreason_t reason)
+{
+ // Sanity check: exceptional cases (i.e. c-fails) can cause multiple
+ // kick commands to be issued for the same player.
+ if (!playeringame[playernum])
+ return;
+
+ if (server && !demoplayback && playernode[playernum] != UINT8_MAX)
+ {
+ INT32 node = playernode[playernum];
+ playerpernode[node]--;
+ if (playerpernode[node] <= 0)
+ {
+ nodeingame[node] = false;
+ Net_CloseConnection(node);
+ ResetNode(node);
+ }
+ }
+
+ if (gametyperules & GTR_TEAMFLAGS)
+ P_PlayerFlagBurst(&players[playernum], false); // Don't take the flag with you!
+
+ // If in a special stage, redistribute the player's spheres across
+ // the remaining players.
+ if (G_IsSpecialStage(gamemap))
+ {
+ INT32 i, count, sincrement, spheres, rincrement, rings;
+
+ for (i = 0, count = 0; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i])
+ count++;
+ }
+
+ count--;
+ sincrement = spheres = players[playernum].spheres;
+ rincrement = rings = players[playernum].rings;
+
+ if (count)
+ {
+ sincrement /= count;
+ rincrement /= count;
+ }
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i] && i != playernum)
+ {
+ if (spheres < 2*sincrement)
+ {
+ P_GivePlayerSpheres(&players[i], spheres);
+ spheres = 0;
+ }
+ else
+ {
+ P_GivePlayerSpheres(&players[i], sincrement);
+ spheres -= sincrement;
+ }
+
+ if (rings < 2*rincrement)
+ {
+ P_GivePlayerRings(&players[i], rings);
+ rings = 0;
+ }
+ else
+ {
+ P_GivePlayerRings(&players[i], rincrement);
+ rings -= rincrement;
+ }
+ }
+ }
+ }
+
+ LUA_HookPlayerQuit(&players[playernum], reason); // Lua hook for player quitting
+
+ // don't look through someone's view who isn't there
+ if (playernum == displayplayer)
+ {
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ LUA_HookViewpointSwitch(&players[consoleplayer], &players[consoleplayer], true);
+ displayplayer = consoleplayer;
+ }
+
+ // Reset player data
+ CL_ClearPlayer(playernum);
+
+ // remove avatar of player
+ playeringame[playernum] = false;
+ playernode[playernum] = UINT8_MAX;
+ while (!playeringame[doomcom->numslots-1] && doomcom->numslots > 1)
+ doomcom->numslots--;
+
+ // Reset the name
+ sprintf(player_names[playernum], "Player %d", playernum+1);
+
+ player_name_changes[playernum] = 0;
+
+ if (IsPlayerAdmin(playernum))
+ {
+ RemoveAdminPlayer(playernum); // don't stay admin after you're gone
+ }
+
+ LUA_InvalidatePlayer(&players[playernum]);
+
+ if (G_TagGametype()) //Check if you still have a game. Location flexible. =P
+ P_CheckSurvivors();
+ else if (gametyperules & GTR_RACE)
+ P_CheckRacers();
+}
+
+void CL_Reset(void)
+{
+ if (metalrecording)
+ G_StopMetalRecording(false);
+ if (metalplayback)
+ G_StopMetalDemo();
+ if (demorecording)
+ G_CheckDemoStatus();
+
+ // reset client/server code
+ DEBFILE(va("\n-=-=-=-=-=-=-= Client reset =-=-=-=-=-=-=-\n\n"));
+
+ if (servernode > 0 && servernode < MAXNETNODES)
+ {
+ nodeingame[(UINT8)servernode] = false;
+ Net_CloseConnection(servernode);
+ }
+ D_CloseConnection(); // netgame = false
+ multiplayer = false;
+ servernode = 0;
+ server = true;
+ doomcom->numnodes = 1;
+ doomcom->numslots = 1;
+ SV_StopServer();
+ SV_ResetServer();
+
+ // make sure we don't leave any fileneeded gunk over from a failed join
+ FreeFileNeeded();
+ fileneedednum = 0;
+
+#ifndef NONET
+ totalfilesrequestednum = 0;
+ totalfilesrequestedsize = 0;
+#endif
+ firstconnectattempttime = 0;
+ serverisfull = false;
+ connectiontimeout = (tic_t)cv_nettimeout.value; //reset this temporary hack
+
+ // D_StartTitle should get done now, but the calling function will handle it
+}
+
+#ifndef NONET
+static void Command_GetPlayerNum(void)
+{
+ INT32 i;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i])
+ {
+ if (serverplayer == i)
+ CONS_Printf(M_GetText("num:%2d node:%2d %s\n"), i, playernode[i], player_names[i]);
+ else
+ CONS_Printf(M_GetText("\x82num:%2d node:%2d %s\n"), i, playernode[i], player_names[i]);
+ }
+}
+
+SINT8 nametonum(const char *name)
+{
+ INT32 playernum, i;
+
+ if (!strcmp(name, "0"))
+ return 0;
+
+ playernum = (SINT8)atoi(name);
+
+ if (playernum < 0 || playernum >= MAXPLAYERS)
+ return -1;
+
+ if (playernum)
+ {
+ if (playeringame[playernum])
+ return (SINT8)playernum;
+ else
+ return -1;
+ }
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && !stricmp(player_names[i], name))
+ return (SINT8)i;
+
+ CONS_Printf(M_GetText("There is no player named \"%s\"\n"), name);
+
+ return -1;
+}
+
+/** Lists all players and their player numbers.
+ *
+ * \sa Command_GetPlayerNum
+ */
+static void Command_Nodes(void)
+{
+ INT32 i;
+ size_t maxlen = 0;
+ const char *address;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ const size_t plen = strlen(player_names[i]);
+ if (playeringame[i] && plen > maxlen)
+ maxlen = plen;
+ }
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i])
+ {
+ CONS_Printf("%.2u: %*s", i, (int)maxlen, player_names[i]);
+
+ if (playernode[i] != UINT8_MAX)
+ {
+ CONS_Printf(" - node %.2d", playernode[i]);
+ if (I_GetNodeAddress && (address = I_GetNodeAddress(playernode[i])) != NULL)
+ CONS_Printf(" - %s", address);
+ }
+
+ if (IsPlayerAdmin(i))
+ CONS_Printf(M_GetText(" (verified admin)"));
+
+ if (players[i].spectator)
+ CONS_Printf(M_GetText(" (spectator)"));
+
+ CONS_Printf("\n");
+ }
+ }
+}
+
+static void Command_Ban(void)
+{
+ if (COM_Argc() < 2)
+ {
+ CONS_Printf(M_GetText("Ban <playername/playernum> <reason>: ban and kick a player\n"));
+ return;
+ }
+
+ if (!netgame) // Don't kick Tails in splitscreen!
+ {
+ CONS_Printf(M_GetText("This only works in a netgame.\n"));
+ return;
+ }
+
+ if (server || IsPlayerAdmin(consoleplayer))
+ {
+ UINT8 buf[3 + MAX_REASONLENGTH];
+ UINT8 *p = buf;
+ const SINT8 pn = nametonum(COM_Argv(1));
+ const INT32 node = playernode[(INT32)pn];
+
+ if (pn == -1 || pn == 0)
+ return;
+
+ WRITEUINT8(p, pn);
+
+ if (server && I_Ban && !I_Ban(node)) // only the server is allowed to do this right now
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("Too many bans! Geez, that's a lot of people you're excluding...\n"));
+ WRITEUINT8(p, KICK_MSG_GO_AWAY);
+ SendNetXCmd(XD_KICK, &buf, 2);
+ }
+ else
+ {
+ if (server) // only the server is allowed to do this right now
+ {
+ Ban_Add(COM_Argv(2));
+ D_SaveBan(); // save the ban list
+ }
+
+ if (COM_Argc() == 2)
+ {
+ WRITEUINT8(p, KICK_MSG_BANNED);
+ SendNetXCmd(XD_KICK, &buf, 2);
+ }
+ else
+ {
+ size_t i, j = COM_Argc();
+ char message[MAX_REASONLENGTH];
+
+ //Steal from the motd code so you don't have to put the reason in quotes.
+ strlcpy(message, COM_Argv(2), sizeof message);
+ for (i = 3; i < j; i++)
+ {
+ strlcat(message, " ", sizeof message);
+ strlcat(message, COM_Argv(i), sizeof message);
+ }
+
+ WRITEUINT8(p, KICK_MSG_CUSTOM_BAN);
+ WRITESTRINGN(p, message, MAX_REASONLENGTH);
+ SendNetXCmd(XD_KICK, &buf, p - buf);
+ }
+ }
+ }
+ else
+ CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
+
+}
+
+static void Command_BanIP(void)
+{
+ if (COM_Argc() < 2)
+ {
+ CONS_Printf(M_GetText("banip <ip> <reason>: ban an ip address\n"));
+ return;
+ }
+
+ if (server) // Only the server can use this, otherwise does nothing.
+ {
+ const char *address = (COM_Argv(1));
+ const char *reason;
+
+ if (COM_Argc() == 2)
+ reason = NULL;
+ else
+ reason = COM_Argv(2);
+
+
+ if (I_SetBanAddress && I_SetBanAddress(address, NULL))
+ {
+ if (reason)
+ CONS_Printf("Banned IP address %s for: %s\n", address, reason);
+ else
+ CONS_Printf("Banned IP address %s\n", address);
+
+ Ban_Add(reason);
+ D_SaveBan();
+ }
+ else
+ {
+ return;
+ }
+ }
+}
+
+static void Command_Kick(void)
+{
+ if (COM_Argc() < 2)
+ {
+ CONS_Printf(M_GetText("kick <playername/playernum> <reason>: kick a player\n"));
+ return;
+ }
+
+ if (!netgame) // Don't kick Tails in splitscreen!
+ {
+ CONS_Printf(M_GetText("This only works in a netgame.\n"));
+ return;
+ }
+
+ if (server || IsPlayerAdmin(consoleplayer))
+ {
+ UINT8 buf[3 + MAX_REASONLENGTH];
+ UINT8 *p = buf;
+ const SINT8 pn = nametonum(COM_Argv(1));
+
+ if (pn == -1 || pn == 0)
+ return;
+
+ // Special case if we are trying to kick a player who is downloading the game state:
+ // trigger a timeout instead of kicking them, because a kick would only
+ // take effect after they have finished downloading
+ if (server && playernode[pn] != UINT8_MAX && sendingsavegame[playernode[pn]])
+ {
+ Net_ConnectionTimeout(playernode[pn]);
+ return;
+ }
+
+ WRITESINT8(p, pn);
+
+ if (COM_Argc() == 2)
+ {
+ WRITEUINT8(p, KICK_MSG_GO_AWAY);
+ SendNetXCmd(XD_KICK, &buf, 2);
+ }
+ else
+ {
+ size_t i, j = COM_Argc();
+ char message[MAX_REASONLENGTH];
+
+ //Steal from the motd code so you don't have to put the reason in quotes.
+ strlcpy(message, COM_Argv(2), sizeof message);
+ for (i = 3; i < j; i++)
+ {
+ strlcat(message, " ", sizeof message);
+ strlcat(message, COM_Argv(i), sizeof message);
+ }
+
+ WRITEUINT8(p, KICK_MSG_CUSTOM_KICK);
+ WRITESTRINGN(p, message, MAX_REASONLENGTH);
+ SendNetXCmd(XD_KICK, &buf, p - buf);
+ }
+ }
+ else
+ CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
+}
+
+static void Command_ResendGamestate(void)
+{
+ SINT8 playernum;
+
+ if (COM_Argc() == 1)
+ {
+ CONS_Printf(M_GetText("resendgamestate <playername/playernum>: resend the game state to a player\n"));
+ return;
+ }
+ else if (client)
+ {
+ CONS_Printf(M_GetText("Only the server can use this.\n"));
+ return;
+ }
+
+ playernum = nametonum(COM_Argv(1));
+ if (playernum == -1 || playernum == 0)
+ return;
+
+ // Send a PT_WILLRESENDGAMESTATE packet to the client so they know what's going on
+ netbuffer->packettype = PT_WILLRESENDGAMESTATE;
+ if (!HSendPacket(playernode[playernum], true, 0, 0))
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("A problem occured, please try again.\n"));
+ return;
+ }
+}
+#endif
+
+static void Got_KickCmd(UINT8 **p, INT32 playernum)
+{
+ INT32 pnum, msg;
+ char buf[3 + MAX_REASONLENGTH];
+ char *reason = buf;
+ kickreason_t kickreason = KR_KICK;
+ boolean keepbody;
+
+ pnum = READUINT8(*p);
+ msg = READUINT8(*p);
+ keepbody = (msg & KICK_MSG_KEEP_BODY) != 0;
+ msg &= ~KICK_MSG_KEEP_BODY;
+
+ if (pnum == serverplayer && IsPlayerAdmin(playernum))
+ {
+ CONS_Printf(M_GetText("Server is being shut down remotely. Goodbye!\n"));
+
+ if (server)
+ COM_BufAddText("quit\n");
+
+ return;
+ }
+
+ // Is playernum authorized to make this kick?
+ if (playernum != serverplayer && !IsPlayerAdmin(playernum)
+ && !(playernode[playernum] != UINT8_MAX && playerpernode[playernode[playernum]] == 2
+ && nodetoplayer2[playernode[playernum]] == pnum))
+ {
+ // We received a kick command from someone who isn't the
+ // server or admin, and who isn't in splitscreen removing
+ // player 2. Thus, it must be someone with a modified
+ // binary, trying to kick someone but without having
+ // authorization.
+
+ // We deal with this by changing the kick reason to
+ // "consistency failure" and kicking the offending user
+ // instead.
+
+ // Note: Splitscreen in netgames is broken because of
+ // this. Only the server has any idea of which players
+ // are using splitscreen on the same computer, so
+ // clients cannot always determine if a kick is
+ // legitimate.
+
+ CONS_Alert(CONS_WARNING, M_GetText("Illegal kick command received from %s for player %d\n"), player_names[playernum], pnum);
+
+ // In debug, print a longer message with more details.
+ // TODO Callum: Should we translate this?
+/*
+ CONS_Debug(DBG_NETPLAY,
+ "So, you must be asking, why is this an illegal kick?\n"
+ "Well, let's take a look at the facts, shall we?\n"
+ "\n"
+ "playernum (this is the guy who did it), he's %d.\n"
+ "pnum (the guy he's trying to kick) is %d.\n"
+ "playernum's node is %d.\n"
+ "That node has %d players.\n"
+ "Player 2 on that node is %d.\n"
+ "pnum's node is %d.\n"
+ "That node has %d players.\n"
+ "Player 2 on that node is %d.\n"
+ "\n"
+ "If you think this is a bug, please report it, including all of the details above.\n",
+ playernum, pnum,
+ playernode[playernum], playerpernode[playernode[playernum]],
+ nodetoplayer2[playernode[playernum]],
+ playernode[pnum], playerpernode[playernode[pnum]],
+ nodetoplayer2[playernode[pnum]]);
+*/
+ pnum = playernum;
+ msg = KICK_MSG_CON_FAIL;
+ keepbody = true;
+ }
+
+ //CONS_Printf("\x82%s ", player_names[pnum]);
+
+ // If a verified admin banned someone, the server needs to know about it.
+ // If the playernum isn't zero (the server) then the server needs to record the ban.
+ if (server && playernum && (msg == KICK_MSG_BANNED || msg == KICK_MSG_CUSTOM_BAN))
+ {
+ if (I_Ban && !I_Ban(playernode[(INT32)pnum]))
+ CONS_Alert(CONS_WARNING, M_GetText("Too many bans! Geez, that's a lot of people you're excluding...\n"));
+#ifndef NONET
+ else
+ Ban_Add(reason);
+#endif
+ }
+
+ switch (msg)
+ {
+ case KICK_MSG_GO_AWAY:
+ if (!players[pnum].quittime)
+ HU_AddChatText(va("\x82*%s has been kicked (No reason given)", player_names[pnum]), false);
+ kickreason = KR_KICK;
+ break;
+ case KICK_MSG_PING_HIGH:
+ HU_AddChatText(va("\x82*%s left the game (Broke ping limit)", player_names[pnum]), false);
+ kickreason = KR_PINGLIMIT;
+ break;
+ case KICK_MSG_CON_FAIL:
+ HU_AddChatText(va("\x82*%s left the game (Synch failure)", player_names[pnum]), false);
+ kickreason = KR_SYNCH;
+
+ if (M_CheckParm("-consisdump")) // Helps debugging some problems
+ {
+ INT32 i;
+
+ CONS_Printf(M_GetText("Player kicked is #%d, dumping consistency...\n"), pnum);
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ continue;
+ CONS_Printf("-------------------------------------\n");
+ CONS_Printf("Player %d: %s\n", i, player_names[i]);
+ CONS_Printf("Skin: %d\n", players[i].skin);
+ CONS_Printf("Color: %d\n", players[i].skincolor);
+ CONS_Printf("Speed: %d\n",players[i].speed>>FRACBITS);
+ if (players[i].mo)
+ {
+ if (!players[i].mo->skin)
+ CONS_Printf("Mobj skin: NULL!\n");
+ else
+ CONS_Printf("Mobj skin: %s\n", ((skin_t *)players[i].mo->skin)->name);
+ CONS_Printf("Position: %d, %d, %d\n", players[i].mo->x, players[i].mo->y, players[i].mo->z);
+ if (!players[i].mo->state)
+ CONS_Printf("State: S_NULL\n");
+ else
+ CONS_Printf("State: %d\n", (statenum_t)(players[i].mo->state-states));
+ }
+ else
+ CONS_Printf("Mobj: NULL\n");
+ CONS_Printf("-------------------------------------\n");
+ }
+ }
+ break;
+ case KICK_MSG_TIMEOUT:
+ HU_AddChatText(va("\x82*%s left the game (Connection timeout)", player_names[pnum]), false);
+ kickreason = KR_TIMEOUT;
+ break;
+ case KICK_MSG_PLAYER_QUIT:
+ if (netgame && !players[pnum].quittime) // not splitscreen/bots or soulless body
+ HU_AddChatText(va("\x82*%s left the game", player_names[pnum]), false);
+ kickreason = KR_LEAVE;
+ break;
+ case KICK_MSG_BANNED:
+ HU_AddChatText(va("\x82*%s has been banned (No reason given)", player_names[pnum]), false);
+ kickreason = KR_BAN;
+ break;
+ case KICK_MSG_CUSTOM_KICK:
+ READSTRINGN(*p, reason, MAX_REASONLENGTH+1);
+ HU_AddChatText(va("\x82*%s has been kicked (%s)", player_names[pnum], reason), false);
+ kickreason = KR_KICK;
+ break;
+ case KICK_MSG_CUSTOM_BAN:
+ READSTRINGN(*p, reason, MAX_REASONLENGTH+1);
+ HU_AddChatText(va("\x82*%s has been banned (%s)", player_names[pnum], reason), false);
+ kickreason = KR_BAN;
+ break;
+ }
+
+ if (pnum == consoleplayer)
+ {
+ LUA_HookBool(false, HOOK(GameQuit));
+#ifdef DUMPCONSISTENCY
+ if (msg == KICK_MSG_CON_FAIL) SV_SavedGame();
+#endif
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ if (msg == KICK_MSG_CON_FAIL)
+ M_StartMessage(M_GetText("Server closed connection\n(synch failure)\nPress ESC\n"), NULL, MM_NOTHING);
+ else if (msg == KICK_MSG_PING_HIGH)
+ M_StartMessage(M_GetText("Server closed connection\n(Broke ping limit)\nPress ESC\n"), NULL, MM_NOTHING);
+ else if (msg == KICK_MSG_BANNED)
+ M_StartMessage(M_GetText("You have been banned by the server\n\nPress ESC\n"), NULL, MM_NOTHING);
+ else if (msg == KICK_MSG_CUSTOM_KICK)
+ M_StartMessage(va(M_GetText("You have been kicked\n(%s)\nPress ESC\n"), reason), NULL, MM_NOTHING);
+ else if (msg == KICK_MSG_CUSTOM_BAN)
+ M_StartMessage(va(M_GetText("You have been banned\n(%s)\nPress ESC\n"), reason), NULL, MM_NOTHING);
+ else
+ M_StartMessage(M_GetText("You have been kicked by the server\n\nPress ESC\n"), NULL, MM_NOTHING);
+ }
+ else if (keepbody)
+ {
+ if (server && !demoplayback && playernode[pnum] != UINT8_MAX)
+ {
+ INT32 node = playernode[pnum];
+ playerpernode[node]--;
+ if (playerpernode[node] <= 0)
+ {
+ nodeingame[node] = false;
+ Net_CloseConnection(node);
+ ResetNode(node);
+ }
+ }
+
+ playernode[pnum] = UINT8_MAX;
+
+ players[pnum].quittime = 1;
+ }
+ else
+ CL_RemovePlayer(pnum, kickreason);
+}
+
+static CV_PossibleValue_t netticbuffer_cons_t[] = {{0, "MIN"}, {3, "MAX"}, {0, NULL}};
+consvar_t cv_netticbuffer = CVAR_INIT ("netticbuffer", "1", CV_SAVE, netticbuffer_cons_t, NULL);
+
+consvar_t cv_allownewplayer = CVAR_INIT ("allowjoin", "On", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
+consvar_t cv_joinnextround = CVAR_INIT ("joinnextround", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL); /// \todo not done
+static CV_PossibleValue_t maxplayers_cons_t[] = {{2, "MIN"}, {32, "MAX"}, {0, NULL}};
+consvar_t cv_maxplayers = CVAR_INIT ("maxplayers", "8", CV_SAVE|CV_NETVAR, maxplayers_cons_t, NULL);
+static CV_PossibleValue_t joindelay_cons_t[] = {{1, "MIN"}, {3600, "MAX"}, {0, "Off"}, {0, NULL}};
+consvar_t cv_joindelay = CVAR_INIT ("joindelay", "10", CV_SAVE|CV_NETVAR, joindelay_cons_t, NULL);
+static CV_PossibleValue_t rejointimeout_cons_t[] = {{1, "MIN"}, {60 * FRACUNIT, "MAX"}, {0, "Off"}, {0, NULL}};
+consvar_t cv_rejointimeout = CVAR_INIT ("rejointimeout", "2", CV_SAVE|CV_NETVAR|CV_FLOAT, rejointimeout_cons_t, NULL);
+
+static CV_PossibleValue_t resynchattempts_cons_t[] = {{1, "MIN"}, {20, "MAX"}, {0, "No"}, {0, NULL}};
+consvar_t cv_resynchattempts = CVAR_INIT ("resynchattempts", "10", CV_SAVE|CV_NETVAR, resynchattempts_cons_t, NULL);
+consvar_t cv_blamecfail = CVAR_INIT ("blamecfail", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
+
+// max file size to send to a player (in kilobytes)
+static CV_PossibleValue_t maxsend_cons_t[] = {{0, "MIN"}, {204800, "MAX"}, {0, NULL}};
+consvar_t cv_maxsend = CVAR_INIT ("maxsend", "4096", CV_SAVE|CV_NETVAR, maxsend_cons_t, NULL);
+consvar_t cv_noticedownload = CVAR_INIT ("noticedownload", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
+
+// Speed of file downloading (in packets per tic)
+static CV_PossibleValue_t downloadspeed_cons_t[] = {{1, "MIN"}, {300, "MAX"}, {0, NULL}};
+consvar_t cv_downloadspeed = CVAR_INIT ("downloadspeed", "16", CV_SAVE|CV_NETVAR, downloadspeed_cons_t, NULL);
+
+static void Got_AddPlayer(UINT8 **p, INT32 playernum);
+
+// called one time at init
+void D_ClientServerInit(void)
+{
+ DEBFILE(va("- - -== SRB2 v%d.%.2d.%d "VERSIONSTRING" debugfile ==- - -\n",
+ VERSION/100, VERSION%100, SUBVERSION));
+
+#ifndef NONET
+ COM_AddCommand("getplayernum", Command_GetPlayerNum);
+ COM_AddCommand("kick", Command_Kick);
+ COM_AddCommand("ban", Command_Ban);
+ COM_AddCommand("banip", Command_BanIP);
+ COM_AddCommand("clearbans", Command_ClearBans);
+ COM_AddCommand("showbanlist", Command_ShowBan);
+ COM_AddCommand("reloadbans", Command_ReloadBan);
+ COM_AddCommand("connect", Command_connect);
+ COM_AddCommand("nodes", Command_Nodes);
+ COM_AddCommand("resendgamestate", Command_ResendGamestate);
+#ifdef PACKETDROP
+ COM_AddCommand("drop", Command_Drop);
+ COM_AddCommand("droprate", Command_Droprate);
+#endif
+#ifdef _DEBUG
+ COM_AddCommand("numnodes", Command_Numnodes);
+#endif
+#endif
+
+ RegisterNetXCmd(XD_KICK, Got_KickCmd);
+ RegisterNetXCmd(XD_ADDPLAYER, Got_AddPlayer);
+#ifndef NONET
+#ifdef DUMPCONSISTENCY
+ CV_RegisterVar(&cv_dumpconsistency);
+#endif
+ Ban_Load_File(false);
+#endif
+
+ gametic = 0;
+ localgametic = 0;
+
+ // do not send anything before the real begin
+ SV_StopServer();
+ SV_ResetServer();
+ if (dedicated)
+ SV_SpawnServer();
+}
+
+static void ResetNode(INT32 node)
+{
+ nodeingame[node] = false;
+ nodewaiting[node] = 0;
+
+ nettics[node] = gametic;
+ supposedtics[node] = gametic;
+
+ nodetoplayer[node] = -1;
+ nodetoplayer2[node] = -1;
+ playerpernode[node] = 0;
+
+ sendingsavegame[node] = false;
+ resendingsavegame[node] = false;
+ savegameresendcooldown[node] = 0;
+}
+
+void SV_ResetServer(void)
+{
+ INT32 i;
+
+ // +1 because this command will be executed in com_executebuffer in
+ // tryruntic so gametic will be incremented, anyway maketic > gametic
+ // is not an issue
+
+ maketic = gametic + 1;
+ neededtic = maketic;
+ tictoclear = maketic;
+
+ joindelay = 0;
+
+ for (i = 0; i < MAXNETNODES; i++)
+ ResetNode(i);
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ LUA_InvalidatePlayer(&players[i]);
+ playeringame[i] = false;
+ playernode[i] = UINT8_MAX;
+ memset(playeraddress[i], 0, sizeof(*playeraddress));
+ sprintf(player_names[i], "Player %d", i + 1);
+ adminplayers[i] = -1; // Populate the entire adminplayers array with -1.
+ }
+
+ memset(player_name_changes, 0, sizeof player_name_changes);
+
+ mynode = 0;
+ cl_packetmissed = false;
+ cl_redownloadinggamestate = false;
+
+ if (dedicated)
+ {
+ nodeingame[0] = true;
+ serverplayer = 0;
+ }
+ else
+ serverplayer = consoleplayer;
+
+ if (server)
+ servernode = 0;
+
+ doomcom->numslots = 0;
+
+ // clear server_context
+ memset(server_context, '-', 8);
+
+ CV_RevertNetVars();
+
+ DEBFILE("\n-=-=-=-=-=-=-= Server Reset =-=-=-=-=-=-=-\n\n");
+}
+
+static inline void SV_GenContext(void)
+{
+ UINT8 i;
+ // generate server_context, as exactly 8 bytes of randomly mixed A-Z and a-z
+ // (hopefully M_Random is initialized!! if not this will be awfully silly!)
+ for (i = 0; i < 8; i++)
+ {
+ const char a = M_RandomKey(26*2);
+ if (a < 26) // uppercase
+ server_context[i] = 'A'+a;
+ else // lowercase
+ server_context[i] = 'a'+(a-26);
+ }
+}
+
+//
+// D_QuitNetGame
+// Called before quitting to leave a net game
+// without hanging the other players
+//
+void D_QuitNetGame(void)
+{
+ mousegrabbedbylua = true;
+ I_UpdateMouseGrab();
+
+ if (!netgame || !netbuffer)
+ return;
+
+ DEBFILE("===========================================================================\n"
+ " Quitting Game, closing connection\n"
+ "===========================================================================\n");
+
+ // abort send/receive of files
+ CloseNetFile();
+ RemoveAllLuaFileTransfers();
+ waitingforluafiletransfer = false;
+ waitingforluafilecommand = false;
+
+ if (server)
+ {
+ INT32 i;
+
+ netbuffer->packettype = PT_SERVERSHUTDOWN;
+ for (i = 0; i < MAXNETNODES; i++)
+ if (nodeingame[i])
+ HSendPacket(i, true, 0, 0);
+#ifdef MASTERSERVER
+ if (serverrunning && ms_RoomId > 0)
+ UnregisterServer();
+#endif
+ }
+ else if (servernode > 0 && servernode < MAXNETNODES && nodeingame[(UINT8)servernode])
+ {
+ netbuffer->packettype = PT_CLIENTQUIT;
+ HSendPacket(servernode, true, 0, 0);
+ }
+
+ D_CloseConnection();
+ ClearAdminPlayers();
+
+ DEBFILE("===========================================================================\n"
+ " Log finish\n"
+ "===========================================================================\n");
+#ifdef DEBUGFILE
+ if (debugfile)
+ {
+ fclose(debugfile);
+ debugfile = NULL;
+ }
+#endif
+}
+
+// Adds a node to the game (player will follow at map change or at savegame....)
+static inline void SV_AddNode(INT32 node)
+{
+ nettics[node] = gametic;
+ supposedtics[node] = gametic;
+ // little hack because the server connects to itself and puts
+ // nodeingame when connected not here
+ if (node)
+ nodeingame[node] = true;
+}
+
+// Xcmd XD_ADDPLAYER
+static void Got_AddPlayer(UINT8 **p, INT32 playernum)
+{
+ INT16 node, newplayernum;
+ boolean splitscreenplayer;
+ boolean rejoined;
+ player_t *newplayer;
+
+ if (playernum != serverplayer && !IsPlayerAdmin(playernum))
+ {
+ // protect against hacked/buggy client
+ CONS_Alert(CONS_WARNING, M_GetText("Illegal add player command received from %s\n"), player_names[playernum]);
+ if (server)
+ SendKick(playernum, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ return;
+ }
+
+ node = READUINT8(*p);
+ newplayernum = READUINT8(*p);
+ splitscreenplayer = newplayernum & 0x80;
+ newplayernum &= ~0x80;
+
+ rejoined = playeringame[newplayernum];
+
+ if (!rejoined)
+ {
+ // Clear player before joining, lest some things get set incorrectly
+ // HACK: don't do this for splitscreen, it relies on preset values
+ if (!splitscreen && !botingame)
+ CL_ClearPlayer(newplayernum);
+ playeringame[newplayernum] = true;
+ G_AddPlayer(newplayernum);
+ if (newplayernum+1 > doomcom->numslots)
+ doomcom->numslots = (INT16)(newplayernum+1);
+
+ if (server && I_GetNodeAddress)
+ {
+ const char *address = I_GetNodeAddress(node);
+ char *port = NULL;
+ if (address) // MI: fix msvcrt.dll!_mbscat crash?
+ {
+ strcpy(playeraddress[newplayernum], address);
+ port = strchr(playeraddress[newplayernum], ':');
+ if (port)
+ *port = '\0';
+ }
+ }
+ }
+
+ newplayer = &players[newplayernum];
+
+ newplayer->jointime = 0;
+ newplayer->quittime = 0;
+
+ READSTRINGN(*p, player_names[newplayernum], MAXPLAYERNAME);
+
+ // the server is creating my player
+ if (node == mynode)
+ {
+ playernode[newplayernum] = 0; // for information only
+ if (!splitscreenplayer)
+ {
+ consoleplayer = newplayernum;
+ displayplayer = newplayernum;
+ secondarydisplayplayer = newplayernum;
+ DEBFILE("spawning me\n");
+ ticcmd_oldangleturn[0] = newplayer->oldrelangleturn;
+ }
+ else
+ {
+ secondarydisplayplayer = newplayernum;
+ DEBFILE("spawning my brother\n");
+ if (botingame)
+ newplayer->bot = 1;
+ ticcmd_oldangleturn[1] = newplayer->oldrelangleturn;
+ }
+ P_ForceLocalAngle(newplayer, (angle_t)(newplayer->angleturn << 16));
+ D_SendPlayerConfig();
+ addedtogame = true;
+
+ if (rejoined)
+ {
+ if (newplayer->mo)
+ {
+ newplayer->viewheight = 41*newplayer->height/48;
+
+ if (newplayer->mo->eflags & MFE_VERTICALFLIP)
+ newplayer->viewz = newplayer->mo->z + newplayer->mo->height - newplayer->viewheight;
+ else
+ newplayer->viewz = newplayer->mo->z + newplayer->viewheight;
+ }
+
+ // wake up the status bar
+ ST_Start();
+ // wake up the heads up text
+ HU_Start();
+
+ if (camera.chase && !splitscreenplayer)
+ P_ResetCamera(newplayer, &camera);
+ if (camera2.chase && splitscreenplayer)
+ P_ResetCamera(newplayer, &camera2);
+ }
+ }
+
+ if (netgame)
+ {
+ char joinmsg[256];
+
+ if (rejoined)
+ strcpy(joinmsg, M_GetText("\x82*%s has rejoined the game (player %d)"));
+ else
+ strcpy(joinmsg, M_GetText("\x82*%s has joined the game (player %d)"));
+ strcpy(joinmsg, va(joinmsg, player_names[newplayernum], newplayernum));
+
+ // Merge join notification + IP to avoid clogging console/chat
+ if (server && cv_showjoinaddress.value && I_GetNodeAddress)
+ {
+ const char *address = I_GetNodeAddress(node);
+ if (address)
+ strcat(joinmsg, va(" (%s)", address));
+ }
+
+ HU_AddChatText(joinmsg, false);
+ }
+
+ if (server && multiplayer && motd[0] != '\0')
+ COM_BufAddText(va("sayto %d %s\n", newplayernum, motd));
+
+ if (!rejoined)
+ LUA_HookInt(newplayernum, HOOK(PlayerJoin));
+}
+
+static boolean SV_AddWaitingPlayers(const char *name, const char *name2)
+{
+ INT32 node, n, newplayer = false;
+ UINT8 buf[2 + MAXPLAYERNAME];
+ UINT8 *p;
+ INT32 newplayernum;
+
+ for (node = 0; node < MAXNETNODES; node++)
+ {
+ // splitscreen can allow 2 player in one node
+ for (; nodewaiting[node] > 0; nodewaiting[node]--)
+ {
+ newplayer = true;
+
+ newplayernum = FindRejoinerNum(node);
+ if (newplayernum == -1)
+ {
+ // search for a free playernum
+ // we can't use playeringame since it is not updated here
+ for (newplayernum = dedicated ? 1 : 0; newplayernum < MAXPLAYERS; newplayernum++)
+ {
+ if (playeringame[newplayernum])
+ continue;
+ for (n = 0; n < MAXNETNODES; n++)
+ if (nodetoplayer[n] == newplayernum || nodetoplayer2[n] == newplayernum)
+ break;
+ if (n == MAXNETNODES)
+ break;
+ }
+ }
+
+ // should never happen since we check the playernum
+ // before accepting the join
+ I_Assert(newplayernum < MAXPLAYERS);
+
+ playernode[newplayernum] = (UINT8)node;
+
+ p = buf + 2;
+ buf[0] = (UINT8)node;
+ buf[1] = newplayernum;
+ if (playerpernode[node] < 1)
+ {
+ nodetoplayer[node] = newplayernum;
+ WRITESTRINGN(p, name, MAXPLAYERNAME);
+ }
+ else
+ {
+ nodetoplayer2[node] = newplayernum;
+ buf[1] |= 0x80;
+ WRITESTRINGN(p, name2, MAXPLAYERNAME);
+ }
+ playerpernode[node]++;
+
+ SendNetXCmd(XD_ADDPLAYER, &buf, p - buf);
+
+ DEBFILE(va("Server added player %d node %d\n", newplayernum, node));
+ }
+ }
+
+ return newplayer;
+}
+
+void CL_AddSplitscreenPlayer(void)
+{
+ if (cl_mode == CL_CONNECTED)
+ CL_SendJoin();
+}
+
+void CL_RemoveSplitscreenPlayer(void)
+{
+ if (cl_mode != CL_CONNECTED)
+ return;
+
+ SendKick(secondarydisplayplayer, KICK_MSG_PLAYER_QUIT);
+}
+
+// is there a game running
+boolean Playing(void)
+{
+ return (server && serverrunning) || (client && cl_mode == CL_CONNECTED);
+}
+
+boolean SV_SpawnServer(void)
+{
+ if (demoplayback)
+ G_StopDemo(); // reset engine parameter
+ if (metalplayback)
+ G_StopMetalDemo();
+
+ if (!serverrunning)
+ {
+ CONS_Printf(M_GetText("Starting Server....\n"));
+ serverrunning = true;
+ SV_ResetServer();
+ SV_GenContext();
+ if (netgame && I_NetOpenSocket)
+ {
+ I_NetOpenSocket();
+#ifdef MASTERSERVER
+ if (ms_RoomId > 0)
+ RegisterServer();
+#endif
+ }
+
+ // non dedicated server just connect to itself
+ if (!dedicated)
+ CL_ConnectToServer();
+ else doomcom->numslots = 1;
+ }
+
+ return SV_AddWaitingPlayers(cv_playername.zstring, cv_playername2.zstring);
+}
+
+void SV_StopServer(void)
+{
+ tic_t i;
+
+ if (gamestate == GS_INTERMISSION)
+ Y_EndIntermission();
+ gamestate = wipegamestate = GS_NULL;
+
+ localtextcmd[0] = 0;
+ localtextcmd2[0] = 0;
+
+ for (i = firstticstosend; i < firstticstosend + BACKUPTICS; i++)
+ D_Clearticcmd(i);
+
+ consoleplayer = 0;
+ cl_mode = CL_SEARCHING;
+ maketic = gametic+1;
+ neededtic = maketic;
+ serverrunning = false;
+}
+
+// called at singleplayer start and stopdemo
+void SV_StartSinglePlayerServer(void)
+{
+ server = true;
+ netgame = false;
+ multiplayer = false;
+ G_SetGametype(GT_COOP);
+
+ // no more tic the game with this settings!
+ SV_StopServer();
+
+ if (splitscreen)
+ multiplayer = true;
+}
+
+static void SV_SendRefuse(INT32 node, const char *reason)
+{
+ strcpy(netbuffer->u.serverrefuse.reason, reason);
+
+ netbuffer->packettype = PT_SERVERREFUSE;
+ HSendPacket(node, true, 0, strlen(netbuffer->u.serverrefuse.reason) + 1);
+ Net_CloseConnection(node);
+}
+
+// used at txtcmds received to check packetsize bound
+static size_t TotalTextCmdPerTic(tic_t tic)
+{
+ INT32 i;
+ size_t total = 1; // num of textcmds in the tic (ntextcmd byte)
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ UINT8 *textcmd = D_GetExistingTextcmd(tic, i);
+ if ((!i || playeringame[i]) && textcmd)
+ total += 2 + textcmd[0]; // "+2" for size and playernum
+ }
+
+ return total;
+}
+
+static const char *
+ConnectionRefused (SINT8 node, INT32 rejoinernum)
+{
+ clientconfig_pak *cc = &netbuffer->u.clientcfg;
+
+ boolean rejoining = (rejoinernum != -1);
+
+ if (!node)/* server connecting to itself */
+ return NULL;
+
+ if (
+ cc->modversion != MODVERSION ||
+ strncmp(cc->application, SRB2APPLICATION,
+ sizeof cc->application)
+ ){
+ return/* this is probably client's fault */
+ "Incompatible.";
+ }
+ else if (bannednode && bannednode[node])
+ {
+ return
+ "You have been banned\n"
+ "from the server.";
+ }
+ else if (cc->localplayers != 1)
+ {
+ return
+ "Wrong player count.";
+ }
+
+ if (!rejoining)
+ {
+ if (!cv_allownewplayer.value)
+ {
+ return
+ "The server is not accepting\n"
+ "joins for the moment.";
+ }
+ else if (D_NumPlayers() >= cv_maxplayers.value)
+ {
+ return va(
+ "Maximum players reached: %d",
+ cv_maxplayers.value);
+ }
+ }
+
+ if (luafiletransfers)
+ {
+ return
+ "The serveris broadcasting a file\n"
+ "requested by a Lua script.\n"
+ "Please wait a bit and then\n"
+ "try rejoining.";
+ }
+
+ if (netgame)
+ {
+ const tic_t th = 2 * cv_joindelay.value * TICRATE;
+
+ if (joindelay > th)
+ {
+ return va(
+ "Too many people are connecting.\n"
+ "Please wait %d seconds and then\n"
+ "try rejoining.",
+ (joindelay - th) / TICRATE);
+ }
+ }
+
+ return NULL;
+}
+
+/** Called when a PT_CLIENTJOIN packet is received
+ *
+ * \param node The packet sender
+ *
+ */
+static void HandleConnect(SINT8 node)
+{
+ char names[MAXSPLITSCREENPLAYERS][MAXPLAYERNAME + 1];
+ INT32 rejoinernum;
+ INT32 i;
+ const char *refuse;
+
+ rejoinernum = FindRejoinerNum(node);
+
+ refuse = ConnectionRefused(node, rejoinernum);
+
+ if (refuse)
+ SV_SendRefuse(node, refuse);
+ else
+ {
+#ifndef NONET
+ boolean newnode = false;
+#endif
+
+ for (i = 0; i < netbuffer->u.clientcfg.localplayers - playerpernode[node]; i++)
+ {
+ strlcpy(names[i], netbuffer->u.clientcfg.names[i], MAXPLAYERNAME + 1);
+ if (!EnsurePlayerNameIsGood(names[i], rejoinernum))
+ {
+ SV_SendRefuse(node, "Bad player name");
+ return;
+ }
+ }
+
+ // client authorised to join
+ nodewaiting[node] = (UINT8)(netbuffer->u.clientcfg.localplayers - playerpernode[node]);
+ if (!nodeingame[node])
+ {
+ gamestate_t backupstate = gamestate;
+#ifndef NONET
+ newnode = true;
+#endif
+ SV_AddNode(node);
+
+ if (cv_joinnextround.value && gameaction == ga_nothing)
+ G_SetGamestate(GS_WAITINGPLAYERS);
+ if (!SV_SendServerConfig(node))
+ {
+ G_SetGamestate(backupstate);
+ /// \note Shouldn't SV_SendRefuse be called before ResetNode?
+ ResetNode(node);
+ SV_SendRefuse(node, M_GetText("Server couldn't send info, please try again"));
+ /// \todo fix this !!!
+ return; // restart the while
+ }
+ //if (gamestate != GS_LEVEL) // GS_INTERMISSION, etc?
+ // SV_SendPlayerConfigs(node); // send bare minimum player info
+ G_SetGamestate(backupstate);
+ DEBFILE("new node joined\n");
+ }
+#ifndef NONET
+ if (nodewaiting[node])
+ {
+ if ((gamestate == GS_LEVEL || gamestate == GS_INTERMISSION) && newnode)
+ {
+ SV_SendSaveGame(node, false); // send a complete game state
+ DEBFILE("send savegame\n");
+ }
+ SV_AddWaitingPlayers(names[0], names[1]);
+ joindelay += cv_joindelay.value * TICRATE;
+ player_joining = true;
+ }
+#endif
+ }
+}
+
+/** Called when a PT_SERVERSHUTDOWN packet is received
+ *
+ * \param node The packet sender (should be the server)
+ *
+ */
+static void HandleShutdown(SINT8 node)
+{
+ (void)node;
+ LUA_HookBool(false, HOOK(GameQuit));
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText("Server has shutdown\n\nPress Esc\n"), NULL, MM_NOTHING);
+}
+
+/** Called when a PT_NODETIMEOUT packet is received
+ *
+ * \param node The packet sender (should be the server)
+ *
+ */
+static void HandleTimeout(SINT8 node)
+{
+ (void)node;
+ LUA_HookBool(false, HOOK(GameQuit));
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+ M_StartMessage(M_GetText("Server Timeout\n\nPress Esc\n"), NULL, MM_NOTHING);
+}
+
+#ifndef NONET
+/** Called when a PT_SERVERINFO packet is received
+ *
+ * \param node The packet sender
+ * \note What happens if the packet comes from a client or something like that?
+ *
+ */
+static void HandleServerInfo(SINT8 node)
+{
+ // compute ping in ms
+ const tic_t ticnow = I_GetTime();
+ const tic_t ticthen = (tic_t)LONG(netbuffer->u.serverinfo.time);
+ const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
+ netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
+ netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
+ netbuffer->u.serverinfo.application
+ [sizeof netbuffer->u.serverinfo.application - 1] = '\0';
+ netbuffer->u.serverinfo.gametypename
+ [sizeof netbuffer->u.serverinfo.gametypename - 1] = '\0';
+
+ SL_InsertServer(&netbuffer->u.serverinfo, node);
+}
+#endif
+
+static void PT_WillResendGamestate(void)
+{
+#ifndef NONET
+ char tmpsave[256];
+
+ if (server || cl_redownloadinggamestate)
+ return;
+
+ // Send back a PT_CANRECEIVEGAMESTATE packet to the server
+ // so they know they can start sending the game state
+ netbuffer->packettype = PT_CANRECEIVEGAMESTATE;
+ if (!HSendPacket(servernode, true, 0, 0))
+ return;
+
+ CONS_Printf(M_GetText("Reloading game state...\n"));
+
+ sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
+
+ // Don't get a corrupt savegame error because tmpsave already exists
+ if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
+ I_Error("Can't delete %s\n", tmpsave);
+
+ CL_PrepareDownloadSaveGame(tmpsave);
+
+ cl_redownloadinggamestate = true;
+#endif
+}
+
+static void PT_CanReceiveGamestate(SINT8 node)
+{
+#ifndef NONET
+ if (client || sendingsavegame[node])
+ return;
+
+ CONS_Printf(M_GetText("Resending game state to %s...\n"), player_names[nodetoplayer[node]]);
+
+ SV_SendSaveGame(node, true); // Resend a complete game state
+ resendingsavegame[node] = true;
+#else
+ (void)node;
+#endif
+}
+
+/** Handles a packet received from a node that isn't in game
+ *
+ * \param node The packet sender
+ * \todo Choose a better name, as the packet can also come from the server apparently?
+ * \sa HandlePacketFromPlayer
+ * \sa GetPackets
+ *
+ */
+static void HandlePacketFromAwayNode(SINT8 node)
+{
+ if (node != servernode)
+ DEBFILE(va("Received packet from unknown host %d\n", node));
+
+// macro for packets that should only be sent by the server
+// if it is NOT from the server, bail out and close the connection!
+#define SERVERONLY \
+ if (node != servernode) \
+ { \
+ Net_CloseConnection(node); \
+ break; \
+ }
+ switch (netbuffer->packettype)
+ {
+ case PT_ASKINFOVIAMS:
+ Net_CloseConnection(node);
+ break;
+
+ case PT_TELLFILESNEEDED:
+ if (server && serverrunning)
+ {
+ UINT8 *p;
+ INT32 firstfile = netbuffer->u.filesneedednum;
+
+ netbuffer->packettype = PT_MOREFILESNEEDED;
+ netbuffer->u.filesneededcfg.first = firstfile;
+ netbuffer->u.filesneededcfg.more = 0;
+
+ p = PutFileNeeded(firstfile);
+
+ HSendPacket(node, false, 0, p - ((UINT8 *)&netbuffer->u));
+ }
+ else // Shouldn't get this if you aren't the server...?
+ Net_CloseConnection(node);
+ break;
+
+ case PT_MOREFILESNEEDED:
+ if (server && serverrunning)
+ { // But wait I thought I'm the server?
+ Net_CloseConnection(node);
+ break;
+ }
+ SERVERONLY
+ if (cl_mode == CL_ASKFULLFILELIST && netbuffer->u.filesneededcfg.first == fileneedednum)
+ {
+ D_ParseFileneeded(netbuffer->u.filesneededcfg.num, netbuffer->u.filesneededcfg.files, netbuffer->u.filesneededcfg.first);
+ if (!netbuffer->u.filesneededcfg.more)
+ cl_lastcheckedfilecount = UINT16_MAX; // Got the whole file list
+ }
+ break;
+
+ case PT_ASKINFO:
+ if (server && serverrunning)
+ {
+ SV_SendServerInfo(node, (tic_t)LONG(netbuffer->u.askinfo.time));
+ SV_SendPlayerInfo(node); // Send extra info
+ }
+ Net_CloseConnection(node);
+ break;
+
+ case PT_SERVERREFUSE: // Negative response of client join request
+ if (server && serverrunning)
+ { // But wait I thought I'm the server?
+ Net_CloseConnection(node);
+ break;
+ }
+ SERVERONLY
+ if (cl_mode == CL_WAITJOINRESPONSE)
+ {
+ // Save the reason so it can be displayed after quitting the netgame
+ char *reason = strdup(netbuffer->u.serverrefuse.reason);
+ if (!reason)
+ I_Error("Out of memory!\n");
+
+ if (strstr(reason, "Maximum players reached"))
+ {
+ serverisfull = true;
+ //Special timeout for when refusing due to player cap. The client will wait 3 seconds between join requests when waiting for a slot, so we need this to be much longer
+ //We set it back to the value of cv_nettimeout.value in CL_Reset
+ connectiontimeout = NEWTICRATE*7;
+ cl_mode = CL_ASKJOIN;
+ free(reason);
+ break;
+ }
+
+ M_StartMessage(va(M_GetText("Server refuses connection\n\nReason:\n%s"),
+ reason), NULL, MM_NOTHING);
+
+ D_QuitNetGame();
+ CL_Reset();
+ D_StartTitle();
+
+ free(reason);
+
+ // Will be reset by caller. Signals refusal.
+ cl_mode = CL_ABORTED;
+ }
+ break;
+
+ case PT_SERVERCFG: // Positive response of client join request
+ {
+ if (server && serverrunning && node != servernode)
+ { // but wait I thought I'm the server?
+ Net_CloseConnection(node);
+ break;
+ }
+ SERVERONLY
+ /// \note how would this happen? and is it doing the right thing if it does?
+ if (cl_mode != CL_WAITJOINRESPONSE)
+ break;
+
+ if (client)
+ {
+ maketic = gametic = neededtic = (tic_t)LONG(netbuffer->u.servercfg.gametic);
+ G_SetGametype(netbuffer->u.servercfg.gametype);
+ modifiedgame = netbuffer->u.servercfg.modifiedgame;
+ memcpy(server_context, netbuffer->u.servercfg.server_context, 8);
+ }
+
+ nodeingame[(UINT8)servernode] = true;
+ serverplayer = netbuffer->u.servercfg.serverplayer;
+ doomcom->numslots = SHORT(netbuffer->u.servercfg.totalslotnum);
+ mynode = netbuffer->u.servercfg.clientnode;
+ if (serverplayer >= 0)
+ playernode[(UINT8)serverplayer] = servernode;
+
+ if (netgame)
+#ifndef NONET
+ CONS_Printf(M_GetText("Join accepted, waiting for complete game state...\n"));
+#else
+ CONS_Printf(M_GetText("Join accepted, waiting for next level change...\n"));
+#endif
+ DEBFILE(va("Server accept join gametic=%u mynode=%d\n", gametic, mynode));
+
+#ifndef NONET
+ /// \note Wait. What if a Lua script uses some global custom variables synched with the NetVars hook?
+ /// Shouldn't them be downloaded even at intermission time?
+ /// Also, according to HandleConnect, the server will send the savegame even during intermission...
+ if (netbuffer->u.servercfg.gamestate == GS_LEVEL/* ||
+ netbuffer->u.servercfg.gamestate == GS_INTERMISSION*/)
+ cl_mode = CL_DOWNLOADSAVEGAME;
+ else
+#endif
+ cl_mode = CL_CONNECTED;
+ break;
+ }
+
+ // Handled in d_netfil.c
+ case PT_FILEFRAGMENT:
+ if (server)
+ { // But wait I thought I'm the server?
+ Net_CloseConnection(node);
+ break;
+ }
+ SERVERONLY
+ PT_FileFragment();
+ break;
+
+ case PT_FILEACK:
+ if (server)
+ PT_FileAck();
+ break;
+
+ case PT_FILERECEIVED:
+ if (server)
+ PT_FileReceived();
+ break;
+
+ case PT_REQUESTFILE:
+ if (server)
+ {
+ if (!cv_downloading.value || !PT_RequestFile(node))
+ Net_CloseConnection(node); // close connection if one of the requested files could not be sent, or you disabled downloading anyway
+ }
+ else
+ Net_CloseConnection(node); // nope
+ break;
+
+ case PT_NODETIMEOUT:
+ case PT_CLIENTQUIT:
+ if (server)
+ Net_CloseConnection(node);
+ break;
+
+ case PT_CLIENTCMD:
+ break; // This is not an "unknown packet"
+
+ case PT_SERVERTICS:
+ // Do not remove my own server (we have just get a out of order packet)
+ if (node == servernode)
+ break;
+ /* FALLTHRU */
+
+ default:
+ DEBFILE(va("unknown packet received (%d) from unknown host\n",netbuffer->packettype));
+ Net_CloseConnection(node);
+ break; // Ignore it
+
+ }
+#undef SERVERONLY
+}
+
+/** Handles a packet received from a node that is in game
+ *
+ * \param node The packet sender
+ * \todo Choose a better name
+ * \sa HandlePacketFromAwayNode
+ * \sa GetPackets
+ *
+ */
+static void HandlePacketFromPlayer(SINT8 node)
+{
+ INT32 netconsole;
+ tic_t realend, realstart;
+ UINT8 *pak, *txtpak, numtxtpak;
+#ifndef NOMD5
+ UINT8 finalmd5[16];/* Well, it's the cool thing to do? */
+#endif
+
+ txtpak = NULL;
+
+ if (dedicated && node == 0)
+ netconsole = 0;
+ else
+ netconsole = nodetoplayer[node];
+#ifdef PARANOIA
+ if (netconsole >= MAXPLAYERS)
+ I_Error("bad table nodetoplayer: node %d player %d", doomcom->remotenode, netconsole);
+#endif
+
+ switch (netbuffer->packettype)
+ {
+// -------------------------------------------- SERVER RECEIVE ----------
+ case PT_CLIENTCMD:
+ case PT_CLIENT2CMD:
+ case PT_CLIENTMIS:
+ case PT_CLIENT2MIS:
+ case PT_NODEKEEPALIVE:
+ case PT_NODEKEEPALIVEMIS:
+ if (client)
+ break;
+
+ // To save bytes, only the low byte of tic numbers are sent
+ // Use ExpandTics to figure out what the rest of the bytes are
+ realstart = ExpandTics(netbuffer->u.clientpak.client_tic, node);
+ realend = ExpandTics(netbuffer->u.clientpak.resendfrom, node);
+
+ if (netbuffer->packettype == PT_CLIENTMIS || netbuffer->packettype == PT_CLIENT2MIS
+ || netbuffer->packettype == PT_NODEKEEPALIVEMIS
+ || supposedtics[node] < realend)
+ {
+ supposedtics[node] = realend;
+ }
+ // Discard out of order packet
+ if (nettics[node] > realend)
+ {
+ DEBFILE(va("out of order ticcmd discarded nettics = %u\n", nettics[node]));
+ break;
+ }
+
+ // Update the nettics
+ nettics[node] = realend;
+
+ // Don't do anything for packets of type NODEKEEPALIVE?
+ if (netconsole == -1 || netbuffer->packettype == PT_NODEKEEPALIVE
+ || netbuffer->packettype == PT_NODEKEEPALIVEMIS)
+ break;
+
+ // As long as clients send valid ticcmds, the server can keep running, so reset the timeout
+ /// \todo Use a separate cvar for that kind of timeout?
+ freezetimeout[node] = I_GetTime() + connectiontimeout;
+
+ // Copy ticcmd
+ G_MoveTiccmd(&netcmds[maketic%BACKUPTICS][netconsole], &netbuffer->u.clientpak.cmd, 1);
+
+ // Check ticcmd for "speed hacks"
+ if (netcmds[maketic%BACKUPTICS][netconsole].forwardmove > MAXPLMOVE || netcmds[maketic%BACKUPTICS][netconsole].forwardmove < -MAXPLMOVE
+ || netcmds[maketic%BACKUPTICS][netconsole].sidemove > MAXPLMOVE || netcmds[maketic%BACKUPTICS][netconsole].sidemove < -MAXPLMOVE)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("Illegal movement value received from node %d\n"), netconsole);
+ //D_Clearticcmd(k);
+
+ SendKick(netconsole, KICK_MSG_CON_FAIL);
+ break;
+ }
+
+ // Splitscreen cmd
+ if ((netbuffer->packettype == PT_CLIENT2CMD || netbuffer->packettype == PT_CLIENT2MIS)
+ && nodetoplayer2[node] >= 0)
+ G_MoveTiccmd(&netcmds[maketic%BACKUPTICS][(UINT8)nodetoplayer2[node]],
+ &netbuffer->u.client2pak.cmd2, 1);
+
+ // Check player consistancy during the level
+ if (realstart <= gametic && realstart + BACKUPTICS - 1 > gametic && gamestate == GS_LEVEL
+ && consistancy[realstart%BACKUPTICS] != SHORT(netbuffer->u.clientpak.consistancy)
+#ifndef NONET
+ && !SV_ResendingSavegameToAnyone()
+#endif
+ && !resendingsavegame[node] && savegameresendcooldown[node] <= I_GetTime())
+ {
+ if (cv_resynchattempts.value)
+ {
+ // Tell the client we are about to resend them the gamestate
+ netbuffer->packettype = PT_WILLRESENDGAMESTATE;
+ HSendPacket(node, true, 0, 0);
+
+ resendingsavegame[node] = true;
+
+ if (cv_blamecfail.value)
+ CONS_Printf(M_GetText("Synch failure for player %d (%s); expected %hd, got %hd\n"),
+ netconsole+1, player_names[netconsole],
+ consistancy[realstart%BACKUPTICS],
+ SHORT(netbuffer->u.clientpak.consistancy));
+ DEBFILE(va("Restoring player %d (synch failure) [%update] %d!=%d\n",
+ netconsole, realstart, consistancy[realstart%BACKUPTICS],
+ SHORT(netbuffer->u.clientpak.consistancy)));
+ break;
+ }
+ else
+ {
+ SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ DEBFILE(va("player %d kicked (synch failure) [%u] %d!=%d\n",
+ netconsole, realstart, consistancy[realstart%BACKUPTICS],
+ SHORT(netbuffer->u.clientpak.consistancy)));
+ break;
+ }
+ }
+ break;
+ case PT_TEXTCMD2: // splitscreen special
+ netconsole = nodetoplayer2[node];
+ /* FALLTHRU */
+ case PT_TEXTCMD:
+ if (client)
+ break;
+
+ if (netconsole < 0 || netconsole >= MAXPLAYERS)
+ Net_UnAcknowledgePacket(node);
+ else
+ {
+ size_t j;
+ tic_t tic = maketic;
+ UINT8 *textcmd;
+
+ // ignore if the textcmd has a reported size of zero
+ // this shouldn't be sent at all
+ if (!netbuffer->u.textcmd[0])
+ {
+ DEBFILE(va("GetPacket: Textcmd with size 0 detected! (node %u, player %d)\n",
+ node, netconsole));
+ Net_UnAcknowledgePacket(node);
+ break;
+ }
+
+ // ignore if the textcmd size var is actually larger than it should be
+ // BASEPACKETSIZE + 1 (for size) + textcmd[0] should == datalength
+ if (netbuffer->u.textcmd[0] > (size_t)doomcom->datalength-BASEPACKETSIZE-1)
+ {
+ DEBFILE(va("GetPacket: Bad Textcmd packet size! (expected %d, actual %s, node %u, player %d)\n",
+ netbuffer->u.textcmd[0], sizeu1((size_t)doomcom->datalength-BASEPACKETSIZE-1),
+ node, netconsole));
+ Net_UnAcknowledgePacket(node);
+ break;
+ }
+
+ // check if tic that we are making isn't too large else we cannot send it :(
+ // doomcom->numslots+1 "+1" since doomcom->numslots can change within this time and sent time
+ j = software_MAXPACKETLENGTH
+ - (netbuffer->u.textcmd[0]+2+BASESERVERTICSSIZE
+ + (doomcom->numslots+1)*sizeof(ticcmd_t));
+
+ // search a tic that have enougth space in the ticcmd
+ while ((textcmd = D_GetExistingTextcmd(tic, netconsole)),
+ (TotalTextCmdPerTic(tic) > j || netbuffer->u.textcmd[0] + (textcmd ? textcmd[0] : 0) > MAXTEXTCMD)
+ && tic < firstticstosend + BACKUPTICS)
+ tic++;
+
+ if (tic >= firstticstosend + BACKUPTICS)
+ {
+ DEBFILE(va("GetPacket: Textcmd too long (max %s, used %s, mak %d, "
+ "tosend %u, node %u, player %d)\n", sizeu1(j), sizeu2(TotalTextCmdPerTic(maketic)),
+ maketic, firstticstosend, node, netconsole));
+ Net_UnAcknowledgePacket(node);
+ break;
+ }
+
+ // Make sure we have a buffer
+ if (!textcmd) textcmd = D_GetTextcmd(tic, netconsole);
+
+ DEBFILE(va("textcmd put in tic %u at position %d (player %d) ftts %u mk %u\n",
+ tic, textcmd[0]+1, netconsole, firstticstosend, maketic));
+
+ M_Memcpy(&textcmd[textcmd[0]+1], netbuffer->u.textcmd+1, netbuffer->u.textcmd[0]);
+ textcmd[0] += (UINT8)netbuffer->u.textcmd[0];
+ }
+ break;
+ case PT_LOGIN:
+ if (client)
+ break;
+
+#ifndef NOMD5
+ if (doomcom->datalength < 16)/* ignore partial sends */
+ break;
+
+ if (!adminpasswordset)
+ {
+ CONS_Printf(M_GetText("Password from %s failed (no password set).\n"), player_names[netconsole]);
+ break;
+ }
+
+ // Do the final pass to compare with the sent md5
+ D_MD5PasswordPass(adminpassmd5, 16, va("PNUM%02d", netconsole), &finalmd5);
+
+ if (!memcmp(netbuffer->u.md5sum, finalmd5, 16))
+ {
+ CONS_Printf(M_GetText("%s passed authentication.\n"), player_names[netconsole]);
+ COM_BufInsertText(va("promote %d\n", netconsole)); // do this immediately
+ }
+ else
+ CONS_Printf(M_GetText("Password from %s failed.\n"), player_names[netconsole]);
+#endif
+ break;
+ case PT_NODETIMEOUT:
+ case PT_CLIENTQUIT:
+ if (client)
+ break;
+
+ // nodeingame will be put false in the execution of kick command
+ // this allow to send some packets to the quitting client to have their ack back
+ nodewaiting[node] = 0;
+ if (netconsole != -1 && playeringame[netconsole])
+ {
+ UINT8 kickmsg;
+
+ if (netbuffer->packettype == PT_NODETIMEOUT)
+ kickmsg = KICK_MSG_TIMEOUT;
+ else
+ kickmsg = KICK_MSG_PLAYER_QUIT;
+ kickmsg |= KICK_MSG_KEEP_BODY;
+
+ SendKick(netconsole, kickmsg);
+ nodetoplayer[node] = -1;
+
+ if (nodetoplayer2[node] != -1 && nodetoplayer2[node] >= 0
+ && playeringame[(UINT8)nodetoplayer2[node]])
+ {
+ SendKick(nodetoplayer2[node], kickmsg);
+ nodetoplayer2[node] = -1;
+ }
+ }
+ Net_CloseConnection(node);
+ nodeingame[node] = false;
+ break;
+ case PT_CANRECEIVEGAMESTATE:
+ PT_CanReceiveGamestate(node);
+ break;
+ case PT_ASKLUAFILE:
+ if (server && luafiletransfers && luafiletransfers->nodestatus[node] == LFTNS_ASKED)
+ AddLuaFileToSendQueue(node, luafiletransfers->realfilename);
+ break;
+ case PT_HASLUAFILE:
+ if (server && luafiletransfers && luafiletransfers->nodestatus[node] == LFTNS_SENDING)
+ SV_HandleLuaFileSent(node);
+ break;
+ case PT_RECEIVEDGAMESTATE:
+ sendingsavegame[node] = false;
+ resendingsavegame[node] = false;
+ savegameresendcooldown[node] = I_GetTime() + 5 * TICRATE;
+ break;
+// -------------------------------------------- CLIENT RECEIVE ----------
+ case PT_SERVERTICS:
+ // Only accept PT_SERVERTICS from the server.
+ if (node != servernode)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_SERVERTICS", node);
+ if (server)
+ SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ break;
+ }
+
+ realstart = netbuffer->u.serverpak.starttic;
+ realend = realstart + netbuffer->u.serverpak.numtics;
+
+ if (!txtpak)
+ txtpak = (UINT8 *)&netbuffer->u.serverpak.cmds[netbuffer->u.serverpak.numslots
+ * netbuffer->u.serverpak.numtics];
+
+ if (realend > gametic + CLIENTBACKUPTICS)
+ realend = gametic + CLIENTBACKUPTICS;
+ cl_packetmissed = realstart > neededtic;
+
+ if (realstart <= neededtic && realend > neededtic)
+ {
+ tic_t i, j;
+ pak = (UINT8 *)&netbuffer->u.serverpak.cmds;
+
+ for (i = realstart; i < realend; i++)
+ {
+ // clear first
+ D_Clearticcmd(i);
+
+ // copy the tics
+ pak = G_ScpyTiccmd(netcmds[i%BACKUPTICS], pak,
+ netbuffer->u.serverpak.numslots*sizeof (ticcmd_t));
+
+ // copy the textcmds
+ numtxtpak = *txtpak++;
+ for (j = 0; j < numtxtpak; j++)
+ {
+ INT32 k = *txtpak++; // playernum
+ const size_t txtsize = txtpak[0]+1;
+
+ if (i >= gametic) // Don't copy old net commands
+ M_Memcpy(D_GetTextcmd(i, k), txtpak, txtsize);
+ txtpak += txtsize;
+ }
+ }
+
+ neededtic = realend;
+ }
+ else
+ {
+ DEBFILE(va("frame not in bound: %u\n", neededtic));
+ /*if (realend < neededtic - 2 * TICRATE || neededtic + 2 * TICRATE < realstart)
+ I_Error("Received an out of order PT_SERVERTICS packet!\n"
+ "Got tics %d-%d, needed tic %d\n\n"
+ "Please report this crash on the Master Board,\n"
+ "IRC or Discord so it can be fixed.\n", (INT32)realstart, (INT32)realend, (INT32)neededtic);*/
+ }
+ break;
+ case PT_PING:
+ // Only accept PT_PING from the server.
+ if (node != servernode)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_PING", node);
+ if (server)
+ SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ break;
+ }
+
+ //Update client ping table from the server.
+ if (client)
+ {
+ UINT8 i;
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i])
+ playerpingtable[i] = (tic_t)netbuffer->u.pingtable[i];
+
+ servermaxping = (tic_t)netbuffer->u.pingtable[MAXPLAYERS];
+ }
+
+ break;
+ case PT_SERVERCFG:
+ break;
+ case PT_FILEFRAGMENT:
+ // Only accept PT_FILEFRAGMENT from the server.
+ if (node != servernode)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_FILEFRAGMENT", node);
+ if (server)
+ SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
+ break;
+ }
+ if (client)
+ PT_FileFragment();
+ break;
+ case PT_FILEACK:
+ if (server)
+ PT_FileAck();
+ break;
+ case PT_FILERECEIVED:
+ if (server)
+ PT_FileReceived();
+ break;
+ case PT_WILLRESENDGAMESTATE:
+ PT_WillResendGamestate();
+ break;
+ case PT_SENDINGLUAFILE:
+ if (client)
+ CL_PrepareDownloadLuaFile();
+ break;
+ default:
+ DEBFILE(va("UNKNOWN PACKET TYPE RECEIVED %d from host %d\n",
+ netbuffer->packettype, node));
+ } // end switch
+}
+
+/** Handles all received packets, if any
+ *
+ * \todo Add details to this description (lol)
+ *
+ */
+static void GetPackets(void)
+{
+ SINT8 node; // The packet sender
+
+ player_joining = false;
+
+ while (HGetPacket())
+ {
+ node = (SINT8)doomcom->remotenode;
+
+ if (netbuffer->packettype == PT_CLIENTJOIN && server)
+ {
+ HandleConnect(node);
+ continue;
+ }
+ if (node == servernode && client && cl_mode != CL_SEARCHING)
+ {
+ if (netbuffer->packettype == PT_SERVERSHUTDOWN)
+ {
+ HandleShutdown(node);
+ continue;
+ }
+ if (netbuffer->packettype == PT_NODETIMEOUT)
+ {
+ HandleTimeout(node);
+ continue;
+ }
+ }
+
+#ifndef NONET
+ if (netbuffer->packettype == PT_SERVERINFO)
+ {
+ HandleServerInfo(node);
+ continue;
+ }
+#endif
+
+ if (netbuffer->packettype == PT_PLAYERINFO)
+ continue; // We do nothing with PLAYERINFO, that's for the MS browser.
+
+ // Packet received from someone already playing
+ if (nodeingame[node])
+ HandlePacketFromPlayer(node);
+ // Packet received from someone not playing
+ else
+ HandlePacketFromAwayNode(node);
+ }
+}
+
+//
+// NetUpdate
+// Builds ticcmds for console player,
+// sends out a packet
+//
+// no more use random generator, because at very first tic isn't yet synchronized
+// Note: It is called consistAncy on purpose.
+//
+static INT16 Consistancy(void)
+{
+ INT32 i;
+ UINT32 ret = 0;
+#ifdef MOBJCONSISTANCY
+ thinker_t *th;
+ mobj_t *mo;
+#endif
+
+ DEBFILE(va("TIC %u ", gametic));
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ ret ^= 0xCCCC;
+ else if (!players[i].mo);
+ else
+ {
+ ret += players[i].mo->x;
+ ret -= players[i].mo->y;
+ ret += players[i].powers[pw_shield];
+ ret *= i+1;
+ }
+ }
+ // I give up
+ // Coop desynching enemies is painful
+ if (!G_PlatformGametype())
+ ret += P_GetRandSeed();
+
+#ifdef MOBJCONSISTANCY
+ if (gamestate == GS_LEVEL)
+ {
+ for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
+ {
+ if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ continue;
+
+ mo = (mobj_t *)th;
+
+ if (mo->flags & (MF_SPECIAL | MF_SOLID | MF_PUSHABLE | MF_BOSS | MF_MISSILE | MF_SPRING | MF_MONITOR | MF_FIRE | MF_ENEMY | MF_PAIN | MF_STICKY))
+ {
+ ret -= mo->type;
+ ret += mo->x;
+ ret -= mo->y;
+ ret += mo->z;
+ ret -= mo->momx;
+ ret += mo->momy;
+ ret -= mo->momz;
+ ret += mo->angle;
+ ret -= mo->flags;
+ ret += mo->flags2;
+ ret -= mo->eflags;
+ if (mo->target)
+ {
+ ret += mo->target->type;
+ ret -= mo->target->x;
+ ret += mo->target->y;
+ ret -= mo->target->z;
+ ret += mo->target->momx;
+ ret -= mo->target->momy;
+ ret += mo->target->momz;
+ ret -= mo->target->angle;
+ ret += mo->target->flags;
+ ret -= mo->target->flags2;
+ ret += mo->target->eflags;
+ ret -= mo->target->state - states;
+ ret += mo->target->tics;
+ ret -= mo->target->sprite;
+ ret += mo->target->frame;
+ }
+ else
+ ret ^= 0x3333;
+ if (mo->tracer && mo->tracer->type != MT_OVERLAY)
+ {
+ ret += mo->tracer->type;
+ ret -= mo->tracer->x;
+ ret += mo->tracer->y;
+ ret -= mo->tracer->z;
+ ret += mo->tracer->momx;
+ ret -= mo->tracer->momy;
+ ret += mo->tracer->momz;
+ ret -= mo->tracer->angle;
+ ret += mo->tracer->flags;
+ ret -= mo->tracer->flags2;
+ ret += mo->tracer->eflags;
+ ret -= mo->tracer->state - states;
+ ret += mo->tracer->tics;
+ ret -= mo->tracer->sprite;
+ ret += mo->tracer->frame;
+ }
+ else
+ ret ^= 0xAAAA;
+ ret -= mo->state - states;
+ ret += mo->tics;
+ ret -= mo->sprite;
+ ret += mo->frame;
+ }
+ }
+ }
+#endif
+
+ DEBFILE(va("Consistancy = %u\n", (ret & 0xFFFF)));
+
+ return (INT16)(ret & 0xFFFF);
+}
+
+// send the client packet to the server
+static void CL_SendClientCmd(void)
+{
+ size_t packetsize = 0;
+
+ netbuffer->packettype = PT_CLIENTCMD;
+
+ if (cl_packetmissed)
+ netbuffer->packettype++;
+ netbuffer->u.clientpak.resendfrom = (UINT8)(neededtic & UINT8_MAX);
+ netbuffer->u.clientpak.client_tic = (UINT8)(gametic & UINT8_MAX);
+
+ if (gamestate == GS_WAITINGPLAYERS)
+ {
+ // Send PT_NODEKEEPALIVE packet
+ netbuffer->packettype += 4;
+ packetsize = sizeof (clientcmd_pak) - sizeof (ticcmd_t) - sizeof (INT16);
+ HSendPacket(servernode, false, 0, packetsize);
+ }
+ else if (gamestate != GS_NULL && (addedtogame || dedicated))
+ {
+ G_MoveTiccmd(&netbuffer->u.clientpak.cmd, &localcmds, 1);
+ netbuffer->u.clientpak.consistancy = SHORT(consistancy[gametic%BACKUPTICS]);
+
+ // Send a special packet with 2 cmd for splitscreen
+ if (splitscreen || botingame)
+ {
+ netbuffer->packettype += 2;
+ G_MoveTiccmd(&netbuffer->u.client2pak.cmd2, &localcmds2, 1);
+ packetsize = sizeof (client2cmd_pak);
+ }
+ else
+ packetsize = sizeof (clientcmd_pak);
+
+ HSendPacket(servernode, false, 0, packetsize);
+ }
+
+ if (cl_mode == CL_CONNECTED || dedicated)
+ {
+ // Send extra data if needed
+ if (localtextcmd[0])
+ {
+ netbuffer->packettype = PT_TEXTCMD;
+ M_Memcpy(netbuffer->u.textcmd,localtextcmd, localtextcmd[0]+1);
+ // All extra data have been sent
+ if (HSendPacket(servernode, true, 0, localtextcmd[0]+1)) // Send can fail...
+ localtextcmd[0] = 0;
+ }
+
+ // Send extra data if needed for player 2 (splitscreen)
+ if (localtextcmd2[0])
+ {
+ netbuffer->packettype = PT_TEXTCMD2;
+ M_Memcpy(netbuffer->u.textcmd, localtextcmd2, localtextcmd2[0]+1);
+ // All extra data have been sent
+ if (HSendPacket(servernode, true, 0, localtextcmd2[0]+1)) // Send can fail...
+ localtextcmd2[0] = 0;
+ }
+ }
+}
+
+// send the server packet
+// send tic from firstticstosend to maketic-1
+static void SV_SendTics(void)
+{
+ tic_t realfirsttic, lasttictosend, i;
+ UINT32 n;
+ INT32 j;
+ size_t packsize;
+ UINT8 *bufpos;
+ UINT8 *ntextcmd;
+
+ // send to all client but not to me
+ // for each node create a packet with x tics and send it
+ // x is computed using supposedtics[n], max packet size and maketic
+ for (n = 1; n < MAXNETNODES; n++)
+ if (nodeingame[n])
+ {
+ // assert supposedtics[n]>=nettics[n]
+ realfirsttic = supposedtics[n];
+ lasttictosend = min(maketic, nettics[n] + CLIENTBACKUPTICS);
+
+ if (realfirsttic >= lasttictosend)
+ {
+ // well we have sent all tics we will so use extrabandwidth
+ // to resent packet that are supposed lost (this is necessary since lost
+ // packet detection work when we have received packet with firsttic > neededtic
+ // (getpacket servertics case)
+ DEBFILE(va("Nothing to send node %u mak=%u sup=%u net=%u \n",
+ n, maketic, supposedtics[n], nettics[n]));
+ realfirsttic = nettics[n];
+ if (realfirsttic >= lasttictosend || (I_GetTime() + n)&3)
+ // all tic are ok
+ continue;
+ DEBFILE(va("Sent %d anyway\n", realfirsttic));
+ }
+ if (realfirsttic < firstticstosend)
+ realfirsttic = firstticstosend;
+
+ // compute the length of the packet and cut it if too large
+ packsize = BASESERVERTICSSIZE;
+ for (i = realfirsttic; i < lasttictosend; i++)
+ {
+ packsize += sizeof (ticcmd_t) * doomcom->numslots;
+ packsize += TotalTextCmdPerTic(i);
+
+ if (packsize > software_MAXPACKETLENGTH)
+ {
+ DEBFILE(va("packet too large (%s) at tic %d (should be from %d to %d)\n",
+ sizeu1(packsize), i, realfirsttic, lasttictosend));
+ lasttictosend = i;
+
+ // too bad: too much player have send extradata and there is too
+ // much data in one tic.
+ // To avoid it put the data on the next tic. (see getpacket
+ // textcmd case) but when numplayer changes the computation can be different
+ if (lasttictosend == realfirsttic)
+ {
+ if (packsize > MAXPACKETLENGTH)
+ I_Error("Too many players: can't send %s data for %d players to node %d\n"
+ "Well sorry nobody is perfect....\n",
+ sizeu1(packsize), doomcom->numslots, n);
+ else
+ {
+ lasttictosend++; // send it anyway!
+ DEBFILE("sending it anyway\n");
+ }
+ }
+ break;
+ }
+ }
+
+ // Send the tics
+ netbuffer->packettype = PT_SERVERTICS;
+ netbuffer->u.serverpak.starttic = realfirsttic;
+ netbuffer->u.serverpak.numtics = (UINT8)(lasttictosend - realfirsttic);
+ netbuffer->u.serverpak.numslots = (UINT8)SHORT(doomcom->numslots);
+ bufpos = (UINT8 *)&netbuffer->u.serverpak.cmds;
+
+ for (i = realfirsttic; i < lasttictosend; i++)
+ {
+ bufpos = G_DcpyTiccmd(bufpos, netcmds[i%BACKUPTICS], doomcom->numslots * sizeof (ticcmd_t));
+ }
+
+ // add textcmds
+ for (i = realfirsttic; i < lasttictosend; i++)
+ {
+ ntextcmd = bufpos++;
+ *ntextcmd = 0;
+ for (j = 0; j < MAXPLAYERS; j++)
+ {
+ UINT8 *textcmd = D_GetExistingTextcmd(i, j);
+ INT32 size = textcmd ? textcmd[0] : 0;
+
+ if ((!j || playeringame[j]) && size)
+ {
+ (*ntextcmd)++;
+ WRITEUINT8(bufpos, j);
+ M_Memcpy(bufpos, textcmd, size + 1);
+ bufpos += size + 1;
+ }
+ }
+ }
+ packsize = bufpos - (UINT8 *)&(netbuffer->u);
+
+ HSendPacket(n, false, 0, packsize);
+ // when tic are too large, only one tic is sent so don't go backward!
+ if (lasttictosend-doomcom->extratics > realfirsttic)
+ supposedtics[n] = lasttictosend-doomcom->extratics;
+ else
+ supposedtics[n] = lasttictosend;
+ if (supposedtics[n] < nettics[n]) supposedtics[n] = nettics[n];
+ }
+ // node 0 is me!
+ supposedtics[0] = maketic;
+}
+
+//
+// TryRunTics
+//
+static void Local_Maketic(INT32 realtics)
+{
+ I_OsPolling(); // I_Getevent
+ D_ProcessEvents(); // menu responder, cons responder,
+ // game responder calls HU_Responder, AM_Responder,
+ // and G_MapEventsToControls
+ if (!dedicated) rendergametic = gametic;
+ // translate inputs (keyboard/mouse/gamepad) into game controls
+ G_BuildTiccmd(&localcmds, realtics, 1);
+ if (splitscreen || botingame)
+ G_BuildTiccmd(&localcmds2, realtics, 2);
+
+ localcmds.angleturn |= TICCMD_RECEIVED;
+ localcmds2.angleturn |= TICCMD_RECEIVED;
+}
+
+// create missed tic
+static void SV_Maketic(void)
+{
+ INT32 i;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ continue;
+
+ // We didn't receive this tic
+ if ((netcmds[maketic % BACKUPTICS][i].angleturn & TICCMD_RECEIVED) == 0)
+ {
+ ticcmd_t * ticcmd = &netcmds[(maketic ) % BACKUPTICS][i];
+ ticcmd_t *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i];
+
+ if (players[i].quittime)
+ {
+ // Copy the angle/aiming from the previous tic
+ // and empty the other inputs
+ memset(ticcmd, 0, sizeof(netcmds[0][0]));
+ ticcmd->angleturn = prevticcmd->angleturn | TICCMD_RECEIVED;
+ ticcmd->aiming = prevticcmd->aiming;
+ }
+ else
+ {
+ DEBFILE(va("MISS tic%4d for player %d\n", maketic, i));
+ // Copy the input from the previous tic
+ *ticcmd = *prevticcmd;
+ ticcmd->angleturn &= ~TICCMD_RECEIVED;
+ }
+ }
+ }
+
+ // all tic are now proceed make the next
+ maketic++;
+}
+
+boolean TryRunTics(tic_t realtics)
+{
+ boolean ticking;
+
+ // the machine has lagged but it is not so bad
+ if (realtics > TICRATE/7) // FIXME: consistency failure!!
+ {
+ if (server)
+ realtics = 1;
+ else
+ realtics = TICRATE/7;
+ }
+
+ if (singletics)
+ realtics = 1;
+
+ if (realtics >= 1)
+ {
+ COM_BufTicker();
+ if (mapchangepending)
+ D_MapChange(-1, 0, ultimatemode, false, 2, false, fromlevelselect); // finish the map change
+ }
+
+ NetUpdate();
+
+ if (demoplayback)
+ {
+ neededtic = gametic + realtics;
+ // start a game after a demo
+ maketic += realtics;
+ firstticstosend = maketic;
+ tictoclear = firstticstosend;
+ }
+
+ GetPackets();
+
+#ifdef DEBUGFILE
+ if (debugfile && (realtics || neededtic > gametic))
+ {
+ //SoM: 3/30/2000: Need long INT32 in the format string for args 4 & 5.
+ //Shut up stupid warning!
+ fprintf(debugfile, "------------ Tryruntic: REAL:%d NEED:%d GAME:%d LOAD: %d\n",
+ realtics, neededtic, gametic, debugload);
+ debugload = 100000;
+ }
+#endif
+
+ ticking = neededtic > gametic;
+
+ if (ticking)
+ {
+ if (realtics)
+ hu_stopped = false;
+ }
+
+ if (player_joining)
+ {
+ if (realtics)
+ hu_stopped = true;
+ return false;
+ }
+
+ if (ticking)
+ {
+ if (advancedemo)
+ {
+ if (timedemo_quit)
+ COM_ImmedExecute("quit");
+ else
+ D_StartTitle();
+ }
+ else
+ // run the count * tics
+ while (neededtic > gametic)
+ {
+ boolean update_stats = !(paused || P_AutoPause());
+
+ DEBFILE(va("============ Running tic %d (local %d)\n", gametic, localgametic));
+
+ if (update_stats)
+ PS_START_TIMING(ps_tictime);
+
+ G_Ticker((gametic % NEWTICRATERATIO) == 0);
+ ExtraDataTicker();
+ gametic++;
+ consistancy[gametic%BACKUPTICS] = Consistancy();
+
+ if (update_stats)
+ {
+ PS_STOP_TIMING(ps_tictime);
+ PS_UpdateTickStats();
+ }
+
+ // Leave a certain amount of tics present in the net buffer as long as we've ran at least one tic this frame.
+ if (client && gamestate == GS_LEVEL && leveltime > 3 && neededtic <= gametic + cv_netticbuffer.value)
+ break;
+ }
+ }
+ else
+ {
+ if (realtics)
+ hu_stopped = true;
+ }
+
+ return ticking;
+}
+
+/*
+Ping Update except better:
+We call this once per second and check for people's pings. If their ping happens to be too high, we increment some timer and kick them out.
+If they're not lagging, decrement the timer by 1. Of course, reset all of this if they leave.
+*/
+
+static INT32 pingtimeout[MAXPLAYERS];
+
+static inline void PingUpdate(void)
+{
+ INT32 i;
+ boolean laggers[MAXPLAYERS];
+ UINT8 numlaggers = 0;
+ memset(laggers, 0, sizeof(boolean) * MAXPLAYERS);
+
+ netbuffer->packettype = PT_PING;
+
+ //check for ping limit breakage.
+ if (cv_maxping.value)
+ {
+ for (i = 1; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i] && !players[i].quittime
+ && (realpingtable[i] / pingmeasurecount > (unsigned)cv_maxping.value))
+ {
+ if (players[i].jointime > 30 * TICRATE)
+ laggers[i] = true;
+ numlaggers++;
+ }
+ else
+ pingtimeout[i] = 0;
+ }
+
+ //kick lagging players... unless everyone but the server's ping sucks.
+ //in that case, it is probably the server's fault.
+ if (numlaggers < D_NumPlayers() - 1)
+ {
+ for (i = 1; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i] && laggers[i])
+ {
+ pingtimeout[i]++;
+ // ok your net has been bad for too long, you deserve to die.
+ if (pingtimeout[i] > cv_pingtimeout.value)
+ {
+ pingtimeout[i] = 0;
+ SendKick(i, KICK_MSG_PING_HIGH | KICK_MSG_KEEP_BODY);
+ }
+ }
+ /*
+ you aren't lagging,
+ but you aren't free yet.
+ In case you'll keep spiking,
+ we just make the timer go back down. (Very unstable net must still get kicked).
+ */
+ else
+ pingtimeout[i] = (pingtimeout[i] == 0 ? 0 : pingtimeout[i]-1);
+ }
+ }
+ }
+
+ //make the ping packet and clear server data for next one
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ netbuffer->u.pingtable[i] = realpingtable[i] / pingmeasurecount;
+ //server takes a snapshot of the real ping for display.
+ //otherwise, pings fluctuate a lot and would be odd to look at.
+ playerpingtable[i] = realpingtable[i] / pingmeasurecount;
+ realpingtable[i] = 0; //Reset each as we go.
+ }
+
+ // send the server's maxping as last element of our ping table. This is useful to let us know when we're about to get kicked.
+ netbuffer->u.pingtable[MAXPLAYERS] = cv_maxping.value;
+
+ //send out our ping packets
+ for (i = 0; i < MAXNETNODES; i++)
+ if (nodeingame[i])
+ HSendPacket(i, true, 0, sizeof(INT32) * (MAXPLAYERS+1));
+
+ pingmeasurecount = 1; //Reset count
+}
+
+void NetUpdate(void)
+{
+ static tic_t gametime = 0;
+ static tic_t resptime = 0;
+ tic_t nowtime;
+ INT32 i;
+ INT32 realtics;
+
+ nowtime = I_GetTime();
+ realtics = nowtime - gametime;
+
+ if (realtics <= 0) // nothing new to update
+ return;
+ if (realtics > 5)
+ {
+ if (server)
+ realtics = 1;
+ else
+ realtics = 5;
+ }
+
+ gametime = nowtime;
+
+ if (server)
+ {
+ if (netgame && !(gametime % 35)) // update once per second.
+ PingUpdate();
+ // update node latency values so we can take an average later.
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && playernode[i] != UINT8_MAX)
+ realpingtable[i] += G_TicsToMilliseconds(GetLag(playernode[i]));
+ pingmeasurecount++;
+ }
+
+ if (client)
+ maketic = neededtic;
+
+ Local_Maketic(realtics); // make local tic, and call menu?
+
+ if (server)
+ CL_SendClientCmd(); // send it
+
+ GetPackets(); // get packet from client or from server
+
+ // client send the command after a receive of the server
+ // the server send before because in single player is beter
+
+#ifdef MASTERSERVER
+ MasterClient_Ticker(); // Acking the Master Server
+#endif
+
+ if (client)
+ {
+#ifndef NONET
+ // If the client just finished redownloading the game state, load it
+ if (cl_redownloadinggamestate && fileneeded[0].status == FS_FOUND)
+ CL_ReloadReceivedSavegame();
+#endif
+
+ CL_SendClientCmd(); // Send tic cmd
+ hu_redownloadinggamestate = cl_redownloadinggamestate;
+ }
+ else
+ {
+ if (!demoplayback)
+ {
+ INT32 counts;
+
+ hu_redownloadinggamestate = false;
+
+ firstticstosend = gametic;
+ for (i = 0; i < MAXNETNODES; i++)
+ if (nodeingame[i] && nettics[i] < firstticstosend)
+ {
+ firstticstosend = nettics[i];
+
+ if (maketic + 1 >= nettics[i] + BACKUPTICS)
+ Net_ConnectionTimeout(i);
+ }
+
+ // Don't erase tics not acknowledged
+ counts = realtics;
+
+ if (maketic + counts >= firstticstosend + BACKUPTICS)
+ counts = firstticstosend+BACKUPTICS-maketic-1;
+
+ for (i = 0; i < counts; i++)
+ SV_Maketic(); // Create missed tics and increment maketic
+
+ for (; tictoclear < firstticstosend; tictoclear++) // Clear only when acknowledged
+ D_Clearticcmd(tictoclear); // Clear the maketic the new tic
+
+ SV_SendTics();
+
+ neededtic = maketic; // The server is a client too
+ }
+ }
+
+ Net_AckTicker();
+
+ // Handle timeouts to prevent definitive freezes from happenning
+ if (server)
+ {
+ for (i = 1; i < MAXNETNODES; i++)
+ if (nodeingame[i] && freezetimeout[i] < I_GetTime())
+ Net_ConnectionTimeout(i);
+
+ // In case the cvar value was lowered
+ if (joindelay)
+ joindelay = min(joindelay - 1, 3 * (tic_t)cv_joindelay.value * TICRATE);
+ }
+
+ nowtime /= NEWTICRATERATIO;
+ if (nowtime > resptime)
+ {
+ resptime = nowtime;
+#ifdef HAVE_THREADS
+ I_lock_mutex(&m_menu_mutex);
+#endif
+ M_Ticker();
+#ifdef HAVE_THREADS
+ I_unlock_mutex(m_menu_mutex);
+#endif
+ CON_Ticker();
+ }
+
+ FileSendTicker();
+}
+
+/** Returns the number of players playing.
+ * \return Number of players. Can be zero if we're running a ::dedicated
+ * server.
+ * \author Graue <graue@oceanbase.org>
+ */
+INT32 D_NumPlayers(void)
+{
+ INT32 num = 0, ix;
+ for (ix = 0; ix < MAXPLAYERS; ix++)
+ if (playeringame[ix])
+ num++;
+ return num;
+}
+
+tic_t GetLag(INT32 node)
+{
+ return gametic - nettics[node];
+}
+
+void D_MD5PasswordPass(const UINT8 *buffer, size_t len, const char *salt, void *dest)
+{
+#ifdef NOMD5
+ (void)buffer;
+ (void)len;
+ (void)salt;
+ memset(dest, 0, 16);
+#else
+ char tmpbuf[256];
+ const size_t sl = strlen(salt);
+
+ if (len > 256-sl)
+ len = 256-sl;
+
+ memcpy(tmpbuf, buffer, len);
+ memmove(&tmpbuf[len], salt, sl);
+ //strcpy(&tmpbuf[len], salt);
+ len += strlen(salt);
+ if (len < 256)
+ memset(&tmpbuf[len],0,256-len);
+
+ // Yes, we intentionally md5 the ENTIRE buffer regardless of size...
+ md5_buffer(tmpbuf, 256, dest);
+#endif
+}
diff --git a/src/netcode/protocol.h b/src/d_clisrv.h
similarity index 60%
rename from src/netcode/protocol.h
rename to src/d_clisrv.h
index 9866e4c5a5ee508b5b68a5573f90925e6b3b7f18..e07864122455bf0960e2299ba5ef7c3d9b2ac39f 100644
--- a/src/netcode/protocol.h
+++ b/src/d_clisrv.h
@@ -7,15 +7,19 @@
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
-/// \file protocol.h
-/// \brief Data exchanged through the network
+/// \file d_clisrv.h
+/// \brief high level networking stuff
-#ifndef __PROTOCOL__
-#define __PROTOCOL__
+#ifndef __D_CLISRV__
+#define __D_CLISRV__
+#include "d_ticcmd.h"
#include "d_net.h"
-#include "../d_ticcmd.h"
-#include "../doomdef.h"
+#include "d_netcmd.h"
+#include "d_net.h"
+#include "tables.h"
+#include "d_player.h"
+#include "mserv.h"
/*
The 'packet version' is used to distinguish packet
@@ -34,9 +38,10 @@ therein, increment this number.
// one that defines the actual packets to
// be transmitted.
+// Networking and tick handling related.
#define BACKUPTICS 1024
+#define CLIENTBACKUPTICS 32
#define MAXTEXTCMD 256
-
//
// Packet structure
//
@@ -85,6 +90,7 @@ typedef enum
PT_TEXTCMD, // Extra text commands from the client.
PT_TEXTCMD2, // Splitscreen text commands.
PT_CLIENTJOIN, // Client wants to join; used in start game.
+ PT_NODETIMEOUT, // Packet sent to self if the connection times out.
PT_LOGIN, // Login attempt from the client.
@@ -95,6 +101,14 @@ typedef enum
NUMPACKETTYPE
} packettype_t;
+#ifdef PACKETDROP
+void Command_Drop(void);
+void Command_Droprate(void);
+#endif
+#ifdef _DEBUG
+void Command_Numnodes(void);
+#endif
+
#if defined(_MSC_VER)
#pragma pack(1)
#endif
@@ -123,12 +137,13 @@ typedef struct
#endif
// Server to client packet
+// this packet is too large
typedef struct
{
tic_t starttic;
UINT8 numtics;
UINT8 numslots; // "Slots filled": Highest player number in use plus one.
- ticcmd_t cmds[45];
+ ticcmd_t cmds[45]; // Normally [BACKUPTIC][MAXPLAYERS] but too large
} ATTRPACK servertics_pak;
typedef struct
@@ -197,7 +212,6 @@ enum {
#define MAXSERVERNAME 32
#define MAXFILENEEDED 915
-
// This packet is too large
typedef struct
{
@@ -258,7 +272,7 @@ typedef struct
UINT8 data; // Color is first four bits, hasflag, isit and issuper have one bit each, the last is unused.
UINT32 score;
UINT16 timeinserver; // In seconds.
-} ATTRPACK plrinfo_pak;
+} ATTRPACK plrinfo;
// Shortest player information for join during intermission.
typedef struct
@@ -269,7 +283,7 @@ typedef struct
UINT32 pflags;
UINT32 score;
UINT8 ctfteam;
-} ATTRPACK plrconfig_pak;
+} ATTRPACK plrconfig;
typedef struct
{
@@ -292,25 +306,25 @@ typedef struct
UINT8 reserved; // Padding
union
{
- clientcmd_pak clientpak;
- client2cmd_pak client2pak;
- servertics_pak serverpak;
- serverconfig_pak servercfg;
- UINT8 textcmd[MAXTEXTCMD+1];
- filetx_pak filetxpak;
+ clientcmd_pak clientpak; // 144 bytes
+ client2cmd_pak client2pak; // 200 bytes
+ servertics_pak serverpak; // 132495 bytes (more around 360, no?)
+ serverconfig_pak servercfg; // 773 bytes
+ UINT8 textcmd[MAXTEXTCMD+1]; // 66049 bytes (wut??? 64k??? More like 257 bytes...)
+ filetx_pak filetxpak; // 139 bytes
fileack_pak fileack;
UINT8 filereceived;
- clientconfig_pak clientcfg;
+ clientconfig_pak clientcfg; // 136 bytes
UINT8 md5sum[16];
- serverinfo_pak serverinfo;
- serverrefuse_pak serverrefuse;
- askinfo_pak askinfo;
- msaskinfo_pak msaskinfo;
- plrinfo_pak playerinfo[MAXPLAYERS];
- plrconfig_pak playerconfig[MAXPLAYERS];
- INT32 filesneedednum;
- filesneededconfig_pak filesneededcfg;
- UINT32 pingtable[MAXPLAYERS+1];
+ serverinfo_pak serverinfo; // 1024 bytes
+ serverrefuse_pak serverrefuse; // 65025 bytes (somehow I feel like those values are garbage...)
+ askinfo_pak askinfo; // 61 bytes
+ msaskinfo_pak msaskinfo; // 22 bytes
+ plrinfo playerinfo[MAXPLAYERS]; // 576 bytes(?)
+ plrconfig playerconfig[MAXPLAYERS]; // (up to) 528 bytes(?)
+ INT32 filesneedednum; // 4 bytes
+ filesneededconfig_pak filesneededcfg; // ??? bytes
+ UINT32 pingtable[MAXPLAYERS+1]; // 68 bytes
} u; // This is needed to pack diff packet types data together
} ATTRPACK doomdata_t;
@@ -318,7 +332,26 @@ typedef struct
#pragma pack()
#endif
+#define MAXSERVERLIST (MAXNETNODES-1)
+typedef struct
+{
+ SINT8 node;
+ serverinfo_pak info;
+} serverelem_t;
+
+extern serverelem_t serverlist[MAXSERVERLIST];
+extern UINT32 serverlistcount;
+extern INT32 mapchangepending;
+
+// Points inside doomcom
+extern doomdata_t *netbuffer;
+
+extern consvar_t cv_showjoinaddress;
+extern consvar_t cv_playbackspeed;
+
+#define BASEPACKETSIZE offsetof(doomdata_t, u)
#define FILETXHEADER offsetof(filetx_pak, data)
+#define BASESERVERTICSSIZE offsetof(doomdata_t, u.serverpak.cmds[0])
#define KICK_MSG_GO_AWAY 1
#define KICK_MSG_CON_FAIL 2
@@ -330,4 +363,102 @@ typedef struct
#define KICK_MSG_CUSTOM_BAN 8
#define KICK_MSG_KEEP_BODY 0x80
+typedef enum
+{
+ KR_KICK = 1, //Kicked by server
+ KR_PINGLIMIT = 2, //Broke Ping Limit
+ KR_SYNCH = 3, //Synch Failure
+ KR_TIMEOUT = 4, //Connection Timeout
+ KR_BAN = 5, //Banned by server
+ KR_LEAVE = 6, //Quit the game
+
+} kickreason_t;
+
+/* the max number of name changes in some time period */
+#define MAXNAMECHANGES (5)
+#define NAMECHANGERATE (60*TICRATE)
+
+extern boolean server;
+extern boolean serverrunning;
+#define client (!server)
+extern boolean dedicated; // For dedicated server
+extern UINT16 software_MAXPACKETLENGTH;
+extern boolean acceptnewnode;
+extern SINT8 servernode;
+
+void Command_Ping_f(void);
+extern tic_t connectiontimeout;
+extern tic_t jointimeout;
+extern UINT16 pingmeasurecount;
+extern UINT32 realpingtable[MAXPLAYERS];
+extern UINT32 playerpingtable[MAXPLAYERS];
+extern tic_t servermaxping;
+
+extern consvar_t cv_netticbuffer, cv_allownewplayer, cv_joinnextround, cv_maxplayers, cv_joindelay, cv_rejointimeout;
+extern consvar_t cv_resynchattempts, cv_blamecfail;
+extern consvar_t cv_maxsend, cv_noticedownload, cv_downloadspeed;
+
+// Used in d_net, the only dependence
+tic_t ExpandTics(INT32 low, INT32 node);
+void D_ClientServerInit(void);
+
+// Initialise the other field
+void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum));
+void SendNetXCmd(netxcmd_t id, const void *param, size_t nparam);
+void SendNetXCmd2(netxcmd_t id, const void *param, size_t nparam); // splitsreen player
+void SendKick(UINT8 playernum, UINT8 msg);
+
+// Create any new ticcmds and broadcast to other players.
+void NetUpdate(void);
+
+void SV_StartSinglePlayerServer(void);
+boolean SV_SpawnServer(void);
+void SV_StopServer(void);
+void SV_ResetServer(void);
+void CL_AddSplitscreenPlayer(void);
+void CL_RemoveSplitscreenPlayer(void);
+void CL_Reset(void);
+void CL_ClearPlayer(INT32 playernum);
+void CL_QueryServerList(msg_server_t *list);
+void CL_UpdateServerList(boolean internetsearch, INT32 room);
+void CL_RemovePlayer(INT32 playernum, kickreason_t reason);
+// Is there a game running
+boolean Playing(void);
+
+// Broadcasts special packets to other players
+// to notify of game exit
+void D_QuitNetGame(void);
+
+//? How many ticks to run?
+boolean TryRunTics(tic_t realtic);
+
+// extra data for lmps
+// these functions scare me. they contain magic.
+/*boolean AddLmpExtradata(UINT8 **demo_p, INT32 playernum);
+void ReadLmpExtraData(UINT8 **demo_pointer, INT32 playernum);*/
+
+#ifndef NONET
+// translate a playername in a player number return -1 if not found and
+// print a error message in the console
+SINT8 nametonum(const char *name);
+#endif
+
+extern char motd[254], server_context[8];
+extern UINT8 playernode[MAXPLAYERS];
+
+INT32 D_NumPlayers(void);
+void D_ResetTiccmds(void);
+
+tic_t GetLag(INT32 node);
+UINT8 GetFreeXCmdSize(void);
+
+void D_MD5PasswordPass(const UINT8 *buffer, size_t len, const char *salt, void *dest);
+
+extern UINT8 hu_redownloadinggamestate;
+
+extern UINT8 adminpassmd5[16];
+extern boolean adminpasswordset;
+
+extern boolean hu_stopped;
+
#endif
diff --git a/src/d_main.c b/src/d_main.c
index 8b13dba89bbf3a307dda463fd8250c5954dd0193..1af8d090c1952a2c56385aec3de742542f1dcda1 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -34,7 +34,7 @@
#include "doomdef.h"
#include "am_map.h"
#include "console.h"
-#include "netcode/d_net.h"
+#include "d_net.h"
#include "f_finale.h"
#include "g_game.h"
#include "hu_stuff.h"
@@ -57,11 +57,11 @@
#include "w_wad.h"
#include "z_zone.h"
#include "d_main.h"
-#include "netcode/d_netfil.h"
+#include "d_netfil.h"
#include "m_cheat.h"
#include "y_inter.h"
#include "p_local.h" // chasecam
-#include "netcode/mserv.h" // ms_RoomId
+#include "mserv.h" // ms_RoomId
#include "m_misc.h" // screenshot functionality
#include "deh_tables.h" // Dehacked list test
#include "m_cond.h" // condition initialization
diff --git a/src/netcode/d_net.c b/src/d_net.c
similarity index 93%
rename from src/netcode/d_net.c
rename to src/d_net.c
index a4b0778e367877373b800ddccbc31ee246242f75..a7e1eb16d6d4fc53f118da9e45d8f8baf4f94590 100644
--- a/src/netcode/d_net.c
+++ b/src/d_net.c
@@ -16,21 +16,19 @@
/// This protocol uses a mix of "goback n" and "selective repeat" implementation
/// The NOTHING packet is sent when connection is idle to acknowledge packets
-#include "../doomdef.h"
-#include "../g_game.h"
-#include "../i_time.h"
+#include "doomdef.h"
+#include "g_game.h"
+#include "i_time.h"
#include "i_net.h"
-#include "../i_system.h"
-#include "../m_argv.h"
+#include "i_system.h"
+#include "m_argv.h"
#include "d_net.h"
-#include "../w_wad.h"
+#include "w_wad.h"
#include "d_netfil.h"
#include "d_clisrv.h"
-#include "tic_command.h"
-#include "net_command.h"
-#include "../z_zone.h"
+#include "z_zone.h"
#include "i_tcp.h"
-#include "../d_main.h" // srb2home
+#include "d_main.h" // srb2home
//
// NETWORKING
@@ -140,6 +138,7 @@ boolean Net_GetNetStat(void)
#define URGENTFREESLOTNUM 10
#define ACKTOSENDTIMEOUT (TICRATE/11)
+#ifndef NONET
typedef struct
{
UINT8 acknum;
@@ -153,6 +152,7 @@ typedef struct
doomdata_t data;
} pak;
} ackpak_t;
+#endif
typedef enum
{
@@ -160,8 +160,10 @@ typedef enum
NF_TIMEOUT = 2, // Flag is set when the node got a timeout
} node_flags_t;
+#ifndef NONET
// Table of packets that were not acknowleged can be resent (the sender window)
static ackpak_t ackpak[MAXACKPACKETS];
+#endif
typedef struct
{
@@ -189,6 +191,7 @@ typedef struct
static node_t nodes[MAXNETNODES];
#define NODETIMEOUT 14
+#ifndef NONET
// return <0 if a < b (mod 256)
// 0 if a = n (mod 256)
// >0 if a > b (mod 256)
@@ -211,7 +214,7 @@ FUNCMATH static INT32 cmpack(UINT8 a, UINT8 b)
static boolean GetFreeAcknum(UINT8 *freeack, boolean lowtimer)
{
node_t *node = &nodes[doomcom->remotenode];
- INT32 numfreeslot = 0;
+ INT32 i, numfreeslot = 0;
if (cmpack((UINT8)((node->remotefirstack + MAXACKTOSEND) % 256), node->nextacknum) < 0)
{
@@ -219,7 +222,7 @@ static boolean GetFreeAcknum(UINT8 *freeack, boolean lowtimer)
return false;
}
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
if (!ackpak[i].acknum)
{
// For low priority packets, make sure to let freeslots so urgent packets can be sent
@@ -276,10 +279,10 @@ static boolean GetFreeAcknum(UINT8 *freeack, boolean lowtimer)
*/
INT32 Net_GetFreeAcks(boolean urgent)
{
- INT32 numfreeslot = 0;
+ INT32 i, numfreeslot = 0;
INT32 n = 0; // Number of free acks found
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
if (!ackpak[i].acknum)
{
// For low priority packets, make sure to let freeslots so urgent packets can be sent
@@ -315,6 +318,7 @@ static void RemoveAck(INT32 i)
// We have got a packet, proceed the ack request and ack return
static boolean Processackpak(void)
{
+ INT32 i;
boolean goodpacket = true;
node_t *node = &nodes[doomcom->remotenode];
@@ -323,7 +327,7 @@ static boolean Processackpak(void)
{
node->remotefirstack = netbuffer->ackreturn;
// Search the ackbuffer and free it
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
if (ackpak[i].acknum && ackpak[i].destinationnode == node - nodes
&& cmpack(ackpak[i].acknum, netbuffer->ackreturn) <= 0)
{
@@ -345,7 +349,7 @@ static boolean Processackpak(void)
else
{
// Check if it is not already in the queue
- for (INT32 i = node->acktosend_tail; i != node->acktosend_head; i = (i+1) % MAXACKTOSEND)
+ for (i = node->acktosend_tail; i != node->acktosend_head; i = (i+1) % MAXACKTOSEND)
if (node->acktosend[i] == ack)
{
DEBFILE(va("Discard(2) ack %d (duplicated)\n", ack));
@@ -373,7 +377,7 @@ static boolean Processackpak(void)
while (change)
{
change = false;
- for (INT32 i = node->acktosend_tail; i != node->acktosend_head;
+ for (i = node->acktosend_tail; i != node->acktosend_head;
i = (i+1) % MAXACKTOSEND)
{
if (cmpack(node->acktosend[i], nextfirstack) <= 0)
@@ -422,20 +426,28 @@ static boolean Processackpak(void)
}
return goodpacket;
}
+#endif
// send special packet with only ack on it
void Net_SendAcks(INT32 node)
{
+#ifdef NONET
+ (void)node;
+#else
netbuffer->packettype = PT_NOTHING;
M_Memcpy(netbuffer->u.textcmd, nodes[node].acktosend, MAXACKTOSEND);
HSendPacket(node, false, 0, MAXACKTOSEND);
+#endif
}
+#ifndef NONET
static void GotAcks(void)
{
- for (INT32 j = 0; j < MAXACKTOSEND; j++)
+ INT32 i, j;
+
+ for (j = 0; j < MAXACKTOSEND; j++)
if (netbuffer->u.textcmd[j])
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
if (ackpak[i].acknum && ackpak[i].destinationnode == doomcom->remotenode)
{
if (ackpak[i].acknum == netbuffer->u.textcmd[j])
@@ -451,6 +463,7 @@ static void GotAcks(void)
}
}
}
+#endif
void Net_ConnectionTimeout(INT32 node)
{
@@ -459,10 +472,14 @@ void Net_ConnectionTimeout(INT32 node)
return;
nodes[node].flags |= NF_TIMEOUT;
- if (server)
- SendKicksForNode(node, KICK_MSG_TIMEOUT | KICK_MSG_KEEP_BODY);
- else
- CL_HandleTimeout();
+ // Send a very special packet to self (hack the reboundstore queue)
+ // Main code will handle it
+ reboundstore[rebound_head].packettype = PT_NODETIMEOUT;
+ reboundstore[rebound_head].ack = 0;
+ reboundstore[rebound_head].ackreturn = 0;
+ reboundstore[rebound_head].u.textcmd[0] = (UINT8)node;
+ reboundsize[rebound_head] = (INT16)(BASEPACKETSIZE + 1);
+ rebound_head = (rebound_head+1) % MAXREBOUND;
// Do not redo it quickly (if we do not close connection it is
// for a good reason!)
@@ -472,8 +489,10 @@ void Net_ConnectionTimeout(INT32 node)
// Resend the data if needed
void Net_AckTicker(void)
{
+#ifndef NONET
+ INT32 i;
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
{
const INT32 nodei = ackpak[i].destinationnode;
node_t *node = &nodes[nodei];
@@ -500,7 +519,7 @@ void Net_AckTicker(void)
}
}
- for (INT32 i = 1; i < MAXNETNODES; i++)
+ for (i = 1; i < MAXNETNODES; i++)
{
// This is something like node open flag
if (nodes[i].firstacktosend)
@@ -517,12 +536,16 @@ void Net_AckTicker(void)
}
}
}
+#endif
}
// Remove last packet received ack before resending the ackreturn
// (the higher layer doesn't have room, or something else ....)
void Net_UnAcknowledgePacket(INT32 node)
{
+#ifdef NONET
+ (void)node;
+#else
INT32 hm1 = (nodes[node].acktosend_head-1+MAXACKTOSEND) % MAXACKTOSEND;
DEBFILE(va("UnAcknowledge node %d\n", node));
if (!node)
@@ -554,8 +577,10 @@ void Net_UnAcknowledgePacket(INT32 node)
if (!nodes[node].firstacktosend)
nodes[node].firstacktosend = 1;
}
+#endif
}
+#ifndef NONET
/** Checks if all acks have been received
*
* \return True if all acks have been received
@@ -563,12 +588,15 @@ void Net_UnAcknowledgePacket(INT32 node)
*/
static boolean Net_AllAcksReceived(void)
{
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ INT32 i;
+
+ for (i = 0; i < MAXACKPACKETS; i++)
if (ackpak[i].acknum)
return false;
return true;
}
+#endif
/** Waits for all ackreturns
*
@@ -577,6 +605,9 @@ static boolean Net_AllAcksReceived(void)
*/
void Net_WaitAllAckReceived(UINT32 timeout)
{
+#ifdef NONET
+ (void)timeout;
+#else
tic_t tictac = I_GetTime();
timeout = tictac + timeout*NEWTICRATE;
@@ -592,6 +623,7 @@ void Net_WaitAllAckReceived(UINT32 timeout)
HGetPacket();
Net_AckTicker();
}
+#endif
}
static void InitNode(node_t *node)
@@ -605,10 +637,14 @@ static void InitNode(node_t *node)
static void InitAck(void)
{
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ INT32 i;
+
+#ifndef NONET
+ for (i = 0; i < MAXACKPACKETS; i++)
ackpak[i].acknum = 0;
+#endif
- for (INT32 i = 0; i < MAXNETNODES; i++)
+ for (i = 0; i < MAXNETNODES; i++)
InitNode(&nodes[i]);
}
@@ -619,12 +655,17 @@ static void InitAck(void)
*/
void Net_AbortPacketType(UINT8 packettype)
{
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+#ifdef NONET
+ (void)packettype;
+#else
+ INT32 i;
+ for (i = 0; i < MAXACKPACKETS; i++)
if (ackpak[i].acknum && (ackpak[i].pak.data.packettype == packettype
|| packettype == UINT8_MAX))
{
ackpak[i].acknum = 0;
}
+#endif
}
// -----------------------------------------------------------------
@@ -634,6 +675,10 @@ void Net_AbortPacketType(UINT8 packettype)
// remove a node, clear all ack from this node and reset askret
void Net_CloseConnection(INT32 node)
{
+#ifdef NONET
+ (void)node;
+#else
+ INT32 i;
boolean forceclose = (node & FORCECLOSE) != 0;
if (node == -1)
@@ -663,7 +708,7 @@ void Net_CloseConnection(INT32 node)
}
// check if we are waiting for an ack from this node
- for (INT32 i = 0; i < MAXACKPACKETS; i++)
+ for (i = 0; i < MAXACKPACKETS; i++)
if (ackpak[i].acknum && ackpak[i].destinationnode == node)
{
if (!forceclose)
@@ -677,8 +722,10 @@ void Net_CloseConnection(INT32 node)
if (server)
SV_AbortLuaFileTransfer(node);
I_NetFreeNodenum(node);
+#endif
}
+#ifndef NONET
//
// Checksum
//
@@ -687,20 +734,23 @@ static UINT32 NetbufferChecksum(void)
UINT32 c = 0x1234567;
const INT32 l = doomcom->datalength - 4;
const UINT8 *buf = (UINT8 *)netbuffer + 4;
+ INT32 i;
- for (INT32 i = 0; i < l; i++, buf++)
+ for (i = 0; i < l; i++, buf++)
c += (*buf) * (i+1);
return LONG(c);
}
+#endif
#ifdef DEBUGFILE
static void fprintfstring(char *s, size_t len)
{
INT32 mode = 0;
+ size_t i;
- for (size_t i = 0; i < len; i++)
+ for (i = 0; i < len; i++)
if (s[i] < 32)
{
if (!mode)
@@ -767,6 +817,7 @@ static const char *packettypename[NUMPACKETTYPE] =
"TEXTCMD",
"TEXTCMD2",
"CLIENTJOIN",
+ "NODETIMEOUT",
"LOGIN",
"TELLFILESNEEDED",
"MOREFILESNEEDED",
@@ -867,6 +918,7 @@ void Command_Drop(void)
{
INT32 packetquantity;
const char *packetname;
+ size_t i;
if (COM_Argc() < 2)
{
@@ -896,11 +948,11 @@ void Command_Drop(void)
packetname = COM_Argv(1);
if (!(stricmp(packetname, "all") && stricmp(packetname, "any")))
- for (size_t i = 0; i < NUMPACKETTYPE; i++)
+ for (i = 0; i < NUMPACKETTYPE; i++)
packetdropquantity[i] = packetquantity;
else
{
- for (size_t i = 0; i < NUMPACKETTYPE; i++)
+ for (i = 0; i < NUMPACKETTYPE; i++)
if (!stricmp(packetname, packettypename[i]))
{
packetdropquantity[i] = packetquantity;
@@ -931,12 +983,14 @@ void Command_Droprate(void)
packetdroprate = droprate;
}
+#ifndef NONET
static boolean ShouldDropPacket(void)
{
return (packetdropquantity[netbuffer->packettype])
|| (packetdroprate != 0 && rand() < (RAND_MAX * (packetdroprate / 100.f))) || packetdroprate == 100;
}
#endif
+#endif
//
// HSendPacket
@@ -971,6 +1025,11 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum, size_t packetlen
if (!netgame)
I_Error("Tried to transmit to another node");
+#ifdef NONET
+ (void)node;
+ (void)reliable;
+ (void)acknum;
+#else
// do this before GetFreeAcknum because this function backups
// the current packet
doomcom->remotenode = (INT16)node;
@@ -1031,6 +1090,8 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum, size_t packetlen
}
#endif
+#endif // ndef NONET
+
return true;
}
@@ -1048,7 +1109,10 @@ boolean HGetPacket(void)
{
M_Memcpy(netbuffer, &reboundstore[rebound_tail], reboundsize[rebound_tail]);
doomcom->datalength = reboundsize[rebound_tail];
- doomcom->remotenode = 0;
+ if (netbuffer->packettype == PT_NODETIMEOUT)
+ doomcom->remotenode = netbuffer->u.textcmd[0];
+ else
+ doomcom->remotenode = 0;
rebound_tail = (rebound_tail+1) % MAXREBOUND;
#ifdef DEBUGFILE
@@ -1061,6 +1125,8 @@ boolean HGetPacket(void)
if (!netgame)
return false;
+#ifndef NONET
+
while(true)
{
//nodejustjoined = I_NetGet();
@@ -1120,6 +1186,7 @@ boolean HGetPacket(void)
}
break;
}
+#endif // ndef NONET
return true;
}
@@ -1323,12 +1390,13 @@ void Command_Ping_f(void)
int name_width = 0;
int ms_width = 0;
+ int n;
+ INT32 i;
+
pingc = 0;
- for (INT32 i = 1; i < MAXPLAYERS; ++i)
+ for (i = 1; i < MAXPLAYERS; ++i)
if (playeringame[i])
{
- int n;
-
n = strlen(player_names[i]);
if (n > name_width)
name_width = n;
@@ -1348,7 +1416,7 @@ void Command_Ping_f(void)
qsort(pingv, pingc, sizeof (struct pingcell), &pingcellcmp);
- for (INT32 i = 0; i < pingc; ++i)
+ for (i = 0; i < pingc; ++i)
{
CONS_Printf("%02d : %-*s %*d ms\n",
pingv[i].num,
@@ -1364,13 +1432,15 @@ void Command_Ping_f(void)
void D_CloseConnection(void)
{
+ INT32 i;
+
if (netgame)
{
// wait the ackreturn with timout of 5 Sec
Net_WaitAllAckReceived(5);
// close all connection
- for (INT32 i = 0; i < MAXNETNODES; i++)
+ for (i = 0; i < MAXNETNODES; i++)
Net_CloseConnection(i|FORCECLOSE);
InitAck();
diff --git a/src/netcode/d_net.h b/src/d_net.h
similarity index 74%
rename from src/netcode/d_net.h
rename to src/d_net.h
index 039f5b3b486b582e9d462a64c68eea31e299160a..5baa593a0573d53ebbe66aac193ce217fc5089f9 100644
--- a/src/netcode/d_net.h
+++ b/src/d_net.h
@@ -18,8 +18,6 @@
#ifndef __D_NET__
#define __D_NET__
-#include "../doomtype.h"
-
// Max computers in a game
// 127 is probably as high as this can go, because
// SINT8 is used for nodes sometimes >:(
@@ -39,24 +37,10 @@ boolean Net_GetNetStat(void);
extern INT32 getbytes;
extern INT64 sendbytes; // Realtime updated
-typedef struct netnode_s
-{
- boolean ingame; // set false as nodes leave game
- tic_t freezetimeout; // Until when can this node freeze the server before getting a timeout?
-
- SINT8 player;
- SINT8 player2; // say the numplayer for this node if any (splitscreen)
- UINT8 numplayers; // used specialy for scplitscreen
-
- tic_t tic; // what tic the client have received
- tic_t supposedtic; // nettics prevision for smaller packet
-
- boolean sendingsavegame; // Are we sending the savegame?
- boolean resendingsavegame; // Are we resending the savegame?
- tic_t savegameresendcooldown; // How long before we can resend again?
-} netnode_t;
-
-extern netnode_t netnodes[MAXNETNODES];
+extern SINT8 nodetoplayer[MAXNETNODES];
+extern SINT8 nodetoplayer2[MAXNETNODES]; // Say the numplayer for this node if any (splitscreen)
+extern UINT8 playerpernode[MAXNETNODES]; // Used specially for splitscreen
+extern boolean nodeingame[MAXNETNODES]; // Set false as nodes leave game
extern boolean serverrunning;
@@ -68,6 +52,9 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum,
size_t packetlength);
boolean HGetPacket(void);
void D_SetDoomcom(void);
+#ifndef NONET
+void D_SaveBan(void);
+#endif
boolean D_CheckNetGame(void);
void D_CloseConnection(void);
void Net_UnAcknowledgePacket(INT32 node);
diff --git a/src/netcode/d_netcmd.c b/src/d_netcmd.c
similarity index 99%
rename from src/netcode/d_netcmd.c
rename to src/d_netcmd.c
index dd9f811e39c7d960760d10361105190ad521f151..f721aa75ae4c2510ffb50fa558193e3562aec9de 100644
--- a/src/netcode/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -12,47 +12,45 @@
/// commands are executed through the command buffer
/// like console commands, other miscellaneous commands (at the end)
-#include "../doomdef.h"
-
-#include "../console.h"
-#include "../command.h"
-#include "../i_time.h"
-#include "../i_system.h"
-#include "../g_game.h"
-#include "../hu_stuff.h"
-#include "../g_input.h"
-#include "../i_gamepad.h"
-#include "../m_menu.h"
-#include "../r_local.h"
-#include "../r_skins.h"
-#include "../p_local.h"
-#include "../p_setup.h"
-#include "../s_sound.h"
-#include "../i_sound.h"
-#include "../m_misc.h"
-#include "../am_map.h"
-#include "../byteptr.h"
+#include "doomdef.h"
+
+#include "console.h"
+#include "command.h"
+#include "i_time.h"
+#include "i_system.h"
+#include "g_game.h"
+#include "hu_stuff.h"
+#include "g_input.h"
+#include "i_gamepad.h"
+#include "m_menu.h"
+#include "r_local.h"
+#include "r_skins.h"
+#include "p_local.h"
+#include "p_setup.h"
+#include "s_sound.h"
+#include "i_sound.h"
+#include "m_misc.h"
+#include "am_map.h"
+#include "byteptr.h"
#include "d_netfil.h"
-#include "../p_spec.h"
-#include "../m_cheat.h"
+#include "p_spec.h"
+#include "m_cheat.h"
#include "d_clisrv.h"
-#include "server_connection.h"
-#include "net_command.h"
#include "d_net.h"
-#include "../v_video.h"
-#include "../d_main.h"
-#include "../m_random.h"
-#include "../f_finale.h"
-#include "../filesrch.h"
+#include "v_video.h"
+#include "d_main.h"
+#include "m_random.h"
+#include "f_finale.h"
+#include "filesrch.h"
#include "mserv.h"
-#include "../z_zone.h"
-#include "../lua_script.h"
-#include "../lua_hook.h"
-#include "../m_cond.h"
-#include "../m_anigif.h"
-#include "../md5.h"
-#include "../m_perfstats.h"
-#include "../hardware/u_list.h" // TODO: this should be a standard utility class
+#include "z_zone.h"
+#include "lua_script.h"
+#include "lua_hook.h"
+#include "m_cond.h"
+#include "m_anigif.h"
+#include "md5.h"
+#include "m_perfstats.h"
+#include "hardware/u_list.h" // TODO: this should be a standard utility class
#ifdef NETGAME_DEVMODE
#define CV_RESTRICT CV_NETVAR
@@ -631,9 +629,12 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_maxsend);
CV_RegisterVar(&cv_noticedownload);
CV_RegisterVar(&cv_downloadspeed);
+#ifndef NONET
CV_RegisterVar(&cv_allownewplayer);
+ CV_RegisterVar(&cv_joinnextround);
CV_RegisterVar(&cv_showjoinaddress);
CV_RegisterVar(&cv_blamecfail);
+#endif
COM_AddCommand("ping", Command_Ping_f);
CV_RegisterVar(&cv_nettimeout);
@@ -1841,7 +1842,8 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pultmode, boolean rese
// reset players if there is a new one
if (!IsPlayerAdmin(consoleplayer))
{
- SV_SpawnServer();
+ if (SV_SpawnServer())
+ buf[0] &= ~(1<<1);
if (!Playing()) // you failed to start a server somehow, so cancel the map change
return;
}
diff --git a/src/netcode/d_netcmd.h b/src/d_netcmd.h
similarity index 99%
rename from src/netcode/d_netcmd.h
rename to src/d_netcmd.h
index 797a686a785b007d083875603c51dab60ef0875d..47f68a17e9d8f3f73a7196062ba533791689a3cd 100644
--- a/src/netcode/d_netcmd.h
+++ b/src/d_netcmd.h
@@ -15,7 +15,7 @@
#ifndef __D_NETCMD__
#define __D_NETCMD__
-#include "../command.h"
+#include "command.h"
// console vars
extern consvar_t cv_playername;
diff --git a/src/netcode/d_netfil.c b/src/d_netfil.c
similarity index 93%
rename from src/netcode/d_netfil.c
rename to src/d_netfil.c
index 10b7359adcb4ec78f67f527b23d1834e6345b43b..edbef30bbf92ba6156da44f3d30fb32d8ab0cccb 100644
--- a/src/netcode/d_netfil.c
+++ b/src/d_netfil.c
@@ -31,25 +31,24 @@
#include <sys/utime.h>
#endif
-#include "../doomdef.h"
-#include "../doomstat.h"
-#include "../d_main.h"
-#include "../g_game.h"
-#include "../i_time.h"
+#include "doomdef.h"
+#include "doomstat.h"
+#include "d_main.h"
+#include "g_game.h"
+#include "i_time.h"
#include "i_net.h"
-#include "../i_system.h"
-#include "../m_argv.h"
+#include "i_system.h"
+#include "m_argv.h"
#include "d_net.h"
-#include "../w_wad.h"
+#include "w_wad.h"
#include "d_netfil.h"
-#include "net_command.h"
-#include "../z_zone.h"
-#include "../byteptr.h"
-#include "../p_setup.h"
-#include "../m_misc.h"
-#include "../m_menu.h"
-#include "../md5.h"
-#include "../filesrch.h"
+#include "z_zone.h"
+#include "byteptr.h"
+#include "p_setup.h"
+#include "m_misc.h"
+#include "m_menu.h"
+#include "md5.h"
+#include "filesrch.h"
#include <errno.h>
@@ -104,31 +103,26 @@ typedef struct
} pauseddownload_t;
static pauseddownload_t *pauseddownload = NULL;
+#ifndef NONET
// for cl loading screen
INT32 lastfilenum = -1;
INT32 downloadcompletednum = 0;
UINT32 downloadcompletedsize = 0;
INT32 totalfilesrequestednum = 0;
UINT32 totalfilesrequestedsize = 0;
+#endif
luafiletransfer_t *luafiletransfers = NULL;
boolean waitingforluafiletransfer = false;
boolean waitingforluafilecommand = false;
char luafiledir[256 + 16] = "luafiles";
-// max file size to send to a player (in kilobytes)
-static CV_PossibleValue_t maxsend_cons_t[] = {{0, "MIN"}, {204800, "MAX"}, {0, NULL}};
-consvar_t cv_maxsend = CVAR_INIT ("maxsend", "4096", CV_SAVE|CV_NETVAR, maxsend_cons_t, NULL);
-
-consvar_t cv_noticedownload = CVAR_INIT ("noticedownload", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
-
-// Speed of file downloading (in packets per tic)
-static CV_PossibleValue_t downloadspeed_cons_t[] = {{1, "MIN"}, {300, "MAX"}, {0, NULL}};
-consvar_t cv_downloadspeed = CVAR_INIT ("downloadspeed", "16", CV_SAVE|CV_NETVAR, downloadspeed_cons_t, NULL);
static UINT16 GetWadNumFromFileNeededId(UINT8 id)
{
- for (UINT16 wadnum = mainwads; wadnum < numwadfiles; wadnum++)
+ UINT16 wadnum;
+
+ for (wadnum = mainwads; wadnum < numwadfiles; wadnum++)
{
if (!wadfiles[wadnum]->important)
continue;
@@ -148,13 +142,14 @@ static UINT16 GetWadNumFromFileNeededId(UINT8 id)
*/
UINT8 *PutFileNeeded(UINT16 firstfile)
{
+ size_t i;
UINT8 count = 0;
UINT8 *p_start = netbuffer->packettype == PT_MOREFILESNEEDED ? netbuffer->u.filesneededcfg.files : netbuffer->u.serverinfo.fileneeded;
UINT8 *p = p_start;
char wadfilename[MAX_WADPATH] = "";
UINT8 filestatus, folder;
- for (size_t i = mainwads; i < numwadfiles; i++) //mainwads, otherwise we start on the first mainwad
+ for (i = mainwads; i < numwadfiles; i++) //mainwads, otherwise we start on the first mainwad
{
// If it has only music/sound lumps, don't put it in the list
if (!wadfiles[i]->important)
@@ -229,6 +224,7 @@ void FreeFileNeeded(void)
*/
void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 firstfile)
{
+ INT32 i;
UINT8 *p;
UINT8 filestatus;
@@ -237,7 +233,7 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
AllocFileNeeded(fileneedednum);
- for (INT32 i = firstfile; i < fileneedednum; i++)
+ for (i = firstfile; i < fileneedednum; i++)
{
fileneeded[i].type = FILENEEDED_WAD;
fileneeded[i].status = FS_NOTCHECKED; // We haven't even started looking for the file yet
@@ -254,7 +250,9 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
void CL_PrepareDownloadSaveGame(const char *tmpsave)
{
+#ifndef NONET
lastfilenum = -1;
+#endif
FreeFileNeeded();
AllocFileNeeded(1);
@@ -277,9 +275,9 @@ void CL_PrepareDownloadSaveGame(const char *tmpsave)
*/
boolean CL_CheckDownloadable(void)
{
- UINT8 dlstatus = 0;
+ UINT8 i,dlstatus = 0;
- for (UINT8 i = 0; i < fileneedednum; i++)
+ for (i = 0; i < fileneedednum; i++)
if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
{
if (fileneeded[i].willsend == 1)
@@ -300,7 +298,7 @@ boolean CL_CheckDownloadable(void)
// not downloadable, put reason in console
CONS_Alert(CONS_NOTICE, M_GetText("You need additional files to connect to this server:\n"));
- for (UINT8 i = 0; i < fileneedednum; i++)
+ for (i = 0; i < fileneedednum; i++)
if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
{
CONS_Printf(" * \"%s\" (%dK)", fileneeded[i].filename, fileneeded[i].totalsize >> 10);
@@ -370,13 +368,14 @@ void CL_AbortDownloadResume(void)
boolean CL_SendFileRequest(void)
{
char *p;
+ INT32 i;
INT64 totalfreespaceneeded = 0, availablefreespace;
#ifdef PARANOIA
if (M_CheckParm("-nodownload"))
I_Error("Attempted to download files in -nodownload mode");
- for (INT32 i = 0; i < fileneedednum; i++)
+ for (i = 0; i < fileneedednum; i++)
if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN
&& (fileneeded[i].willsend == 0 || fileneeded[i].willsend == 2))
{
@@ -386,7 +385,7 @@ boolean CL_SendFileRequest(void)
netbuffer->packettype = PT_REQUESTFILE;
p = (char *)netbuffer->u.textcmd;
- for (INT32 i = 0; i < fileneedednum; i++)
+ for (i = 0; i < fileneedednum; i++)
if ((fileneeded[i].status == FS_NOTFOUND || fileneeded[i].status == FS_MD5SUMBAD))
{
totalfreespaceneeded += fileneeded[i].totalsize;
@@ -414,31 +413,26 @@ boolean CL_SendFileRequest(void)
}
// get request filepak and put it on the send queue
-void PT_RequestFile(SINT8 node)
+// returns false if a requested file was not found or cannot be sent
+boolean PT_RequestFile(INT32 node)
{
UINT8 *p = netbuffer->u.textcmd;
-
- if (client || !cv_downloading.value)
- {
- Net_CloseConnection(node); // close connection if you are not the server or disabled downloading
- return;
- }
+ UINT8 id;
while (p < netbuffer->u.textcmd + MAXTEXTCMD-1) // Don't allow hacked client to overflow
{
- UINT8 id = READUINT8(p);
+ id = READUINT8(p);
if (id == 0xFF)
break;
if (!AddFileToSendQueue(node, id))
{
SV_AbortSendFiles(node);
- Net_CloseConnection(node); // close connection if one of the requested files could not be sent
- return; // don't read the rest of the files
+ return false; // don't read the rest of the files
}
}
- return; // no problems with any files
+ return true; // no problems with any files
}
/** Checks if the files needed aren't already loaded or on the disk
@@ -537,7 +531,9 @@ INT32 CL_CheckFiles(void)
// Load it now
boolean CL_LoadServerFiles(void)
{
- for (INT32 i = 0; i < fileneedednum; i++)
+ INT32 i;
+
+ for (i = 0; i < fileneedednum; i++)
{
if (fileneeded[i].status == FS_OPEN)
continue; // Already loaded
@@ -633,10 +629,11 @@ void AddLuaFileTransfer(const char *filename, const char *mode)
static void SV_PrepareSendLuaFileToNextNode(void)
{
+ INT32 i;
UINT8 success = 1;
// Find a client to send the file to
- for (INT32 i = 1; i < MAXNETNODES; i++)
+ for (i = 1; i < MAXNETNODES; i++)
if (luafiletransfers->nodestatus[i] == LFTNS_WAITING) // Node waiting
{
// Tell the client we're about to send them the file
@@ -658,12 +655,13 @@ static void SV_PrepareSendLuaFileToNextNode(void)
void SV_PrepareSendLuaFile(void)
{
char *binfilename;
+ INT32 i;
luafiletransfers->ongoing = true;
// Set status to "waiting" for everyone
- for (INT32 i = 0; i < MAXNETNODES; i++)
- luafiletransfers->nodestatus[i] = (netnodes[i].ingame ? LFTNS_WAITING : LFTNS_NONE);
+ for (i = 0; i < MAXNETNODES; i++)
+ luafiletransfers->nodestatus[i] = (nodeingame[i] ? LFTNS_WAITING : LFTNS_NONE);
if (FIL_ReadFileOK(luafiletransfers->realfilename))
{
@@ -1139,13 +1137,12 @@ void FileSendTicker(void)
}
}
-void PT_FileAck(SINT8 node)
+void PT_FileAck(void)
{
fileack_pak *packet = &netbuffer->u.fileack;
+ INT32 node = doomcom->remotenode;
filetran_t *trans = &transfer[node];
-
- if (client)
- return;
+ INT32 i, j;
// Wrong file id? Ignore it, it's probably a late packet
if (!(trans->txlist && packet->fileid == trans->txlist->fileid))
@@ -1164,11 +1161,11 @@ void PT_FileAck(SINT8 node)
trans->dontsenduntil = 0;
}
- for (INT32 i = 0; i < packet->numsegments; i++)
+ for (i = 0; i < packet->numsegments; i++)
{
fileacksegment_t *segment = &packet->segments[i];
- for (INT32 j = 0; j < 32; j++)
+ for (j = 0; j < 32; j++)
if (LONG(segment->acks) & (1 << j))
{
if (LONG(segment->start) * FILEFRAGMENTSIZE >= trans->txlist->size)
@@ -1193,23 +1190,24 @@ void PT_FileAck(SINT8 node)
}
}
-void PT_FileReceived(SINT8 node)
+void PT_FileReceived(void)
{
- filetx_t *trans = transfer[node].txlist;
+ filetx_t *trans = transfer[doomcom->remotenode].txlist;
- if (server && trans && netbuffer->u.filereceived == trans->fileid)
- SV_EndFileSend(node);
+ if (trans && netbuffer->u.filereceived == trans->fileid)
+ SV_EndFileSend(doomcom->remotenode);
}
static void SendAckPacket(fileack_pak *packet, UINT8 fileid)
{
size_t packetsize;
+ INT32 i;
packetsize = sizeof(*packet) + packet->numsegments * sizeof(*packet->segments);
// Finalise the packet
packet->fileid = fileid;
- for (INT32 i = 0; i < packet->numsegments; i++)
+ for (i = 0; i < packet->numsegments; i++)
{
packet->segments[i].start = LONG(packet->segments[i].start);
packet->segments[i].acks = LONG(packet->segments[i].acks);
@@ -1249,7 +1247,9 @@ static void AddFragmentToAckPacket(fileack_pak *packet, UINT8 iteration, UINT32
void FileReceiveTicker(void)
{
- for (INT32 i = 0; i < fileneedednum; i++)
+ INT32 i;
+
+ for (i = 0; i < fileneedednum; i++)
{
fileneeded_t *file = &fileneeded[i];
@@ -1263,7 +1263,8 @@ void FileReceiveTicker(void)
if (file->ackresendposition != UINT32_MAX && file->status == FS_DOWNLOADING)
{
// Acknowledge ~70 MB/s, whichs means the client sends ~18 KB/s
- for (INT32 j = 0; j < 2048; j++)
+ INT32 j;
+ for (j = 0; j < 2048; j++)
{
if (file->receivedfragments[file->ackresendposition])
AddFragmentToAckPacket(file->ackpacket, file->iteration, file->ackresendposition, i);
@@ -1280,27 +1281,8 @@ void FileReceiveTicker(void)
}
}
-void PT_FileFragment(SINT8 node, INT32 netconsole)
+void PT_FileFragment(void)
{
- if (netnodes[node].ingame)
- {
- // Only accept PT_FILEFRAGMENT from the server.
- if (node != servernode)
- {
- CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_FILEFRAGMENT", node);
- if (server)
- SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
- return;
- }
- if (server)
- return;
- }
- else if (server || node != servernode)
- {
- Net_CloseConnection(node);
- return;
- }
-
INT32 filenum = netbuffer->u.filetxpak.fileid;
fileneeded_t *file = &fileneeded[filenum];
UINT32 fragmentpos = LONG(netbuffer->u.filetxpak.position);
@@ -1457,7 +1439,9 @@ void PT_FileFragment(SINT8 node, INT32 netconsole)
I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);
}
+#ifndef NONET
lastfilenum = filenum;
+#endif
}
/** \brief Checks if a node is downloading a file
@@ -1485,14 +1469,15 @@ void SV_AbortSendFiles(INT32 node)
void CloseNetFile(void)
{
+ INT32 i;
// Is sending?
- for (INT32 i = 0; i < MAXNETNODES; i++)
+ for (i = 0; i < MAXNETNODES; i++)
SV_AbortSendFiles(i);
// Receiving a file?
if (fileneeded)
{
- for (INT32 i = 0; i < fileneedednum; i++)
+ for (i = 0; i < fileneedednum; i++)
if (fileneeded[i].status == FS_DOWNLOADING && fileneeded[i].file)
{
fclose(fileneeded[i].file);
@@ -1525,7 +1510,9 @@ void CloseNetFile(void)
void Command_Downloads_f(void)
{
- for (INT32 node = 0; node < MAXNETNODES; node++)
+ INT32 node;
+
+ for (node = 0; node < MAXNETNODES; node++)
if (transfer[node].txlist
&& transfer[node].txlist->ram == SF_FILE) // Node is downloading a file?
{
@@ -1559,11 +1546,14 @@ void Command_Downloads_f(void)
void nameonly(char *s)
{
- for (size_t j = strlen(s); j != (size_t)-1; j--)
+ size_t j, len;
+ void *ns;
+
+ for (j = strlen(s); j != (size_t)-1; j--)
if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
{
- void *ns = &(s[j+1]);
- size_t len = strlen(ns);
+ ns = &(s[j+1]);
+ len = strlen(ns);
#if 0
M_Memcpy(s, ns, len+1);
#else
@@ -1576,9 +1566,9 @@ void nameonly(char *s)
// Returns the length in characters of the last element of a path.
size_t nameonlylength(const char *s)
{
- size_t len = strlen(s);
+ size_t j, len = strlen(s);
- for (size_t j = len; j != (size_t)-1; j--)
+ for (j = len; j != (size_t)-1; j--)
if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
return len - j - 1;
diff --git a/src/netcode/d_netfil.h b/src/d_netfil.h
similarity index 94%
rename from src/netcode/d_netfil.h
rename to src/d_netfil.h
index 850e24d49060ed7ebd753f60ae649c26438b4555..f778a518ff2eee3076170885ac9bdded15cd9f8f 100644
--- a/src/netcode/d_netfil.h
+++ b/src/d_netfil.h
@@ -15,7 +15,7 @@
#include "d_net.h"
#include "d_clisrv.h"
-#include "../w_wad.h"
+#include "w_wad.h"
typedef enum
{
@@ -70,13 +70,13 @@ extern INT32 fileneedednum;
extern fileneeded_t *fileneeded;
extern char downloaddir[512];
+#ifndef NONET
extern INT32 lastfilenum;
extern INT32 downloadcompletednum;
extern UINT32 downloadcompletedsize;
extern INT32 totalfilesrequestednum;
extern UINT32 totalfilesrequestedsize;
-
-extern consvar_t cv_maxsend, cv_noticedownload, cv_downloadspeed;
+#endif
void AllocFileNeeded(INT32 size);
void FreeFileNeeded(void);
@@ -90,16 +90,16 @@ void AddRamToSendQueue(INT32 node, void *data, size_t size, freemethod_t freemet
UINT8 fileid);
void FileSendTicker(void);
-void PT_FileAck(SINT8 node);
-void PT_FileReceived(SINT8 node);
+void PT_FileAck(void);
+void PT_FileReceived(void);
boolean SendingFile(INT32 node);
void FileReceiveTicker(void);
-void PT_FileFragment(SINT8 node, INT32 netconsole);
+void PT_FileFragment(void);
boolean CL_CheckDownloadable(void);
boolean CL_SendFileRequest(void);
-void PT_RequestFile(SINT8 node);
+boolean PT_RequestFile(INT32 node);
typedef enum
{
diff --git a/src/deh_soc.c b/src/deh_soc.c
index 81b36479cfb4a513170a2f1459165da5a3d435ab..cbc7940f76d50c426cc340f46cc8c53af325b26f 100644
--- a/src/deh_soc.c
+++ b/src/deh_soc.c
@@ -34,7 +34,7 @@
#include "r_sky.h"
#include "fastcmp.h"
#include "lua_script.h" // Reluctantly included for LUA_EvalMath
-#include "netcode/d_clisrv.h"
+#include "d_clisrv.h"
#ifdef HWRENDER
#include "hardware/hw_light.h"
diff --git a/src/deh_soc.h b/src/deh_soc.h
index cd55b665bd78ede8883714caaa67402b24bb7713..f972ec26ecbb7732098e131d427ebd34b5f621ef 100644
--- a/src/deh_soc.h
+++ b/src/deh_soc.h
@@ -35,7 +35,7 @@
#include "r_sky.h"
#include "fastcmp.h"
#include "lua_script.h" // Reluctantly included for LUA_EvalMath
-#include "netcode/d_clisrv.h"
+#include "d_clisrv.h"
#ifdef HWRENDER
#include "hardware/hw_light.h"
diff --git a/src/deh_tables.c b/src/deh_tables.c
index a119f792f98c545a430a5e549cc6057816663d8e..90c3047a8dc388dd85d9ccd0adb7be262e969f90 100644
--- a/src/deh_tables.c
+++ b/src/deh_tables.c
@@ -4831,7 +4831,7 @@ const char *const MENUTYPES_LIST[] = {
"MP_SERVER",
"MP_CONNECT",
"MP_ROOM",
- "MP_PLAYERSETUP",
+ "MP_PLAYERSETUP", // MP_PlayerSetupDef shared with SPLITSCREEN if #defined NONET
"MP_SERVER_OPTIONS",
// Options
diff --git a/src/doomdef.h b/src/doomdef.h
index b70f0a47ebc49c9c70db66f8fe64cddc7d86bce1..24b4fa9807e3e6fffaaec1609b3f7cd5d5693035 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -56,6 +56,7 @@
#endif
#ifdef _WINDOWS
+#define NONET
#if !defined (HWRENDER) && !defined (NOHW)
#define HWRENDER
#endif
@@ -656,7 +657,7 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
/// Maintain compatibility with older 2.2 demos
#define OLD22DEMOCOMPAT
-#ifdef HAVE_CURL
+#if defined (HAVE_CURL) && ! defined (NONET)
#define MASTERSERVER
#else
#undef UPDATE_ALERT
diff --git a/src/doomstat.h b/src/doomstat.h
index 344a3daa47c77573e16102678edfa3f72e2c428c..bce43416b840e7704a870857708ae1e019062868 100644
--- a/src/doomstat.h
+++ b/src/doomstat.h
@@ -683,7 +683,7 @@ extern boolean singletics;
// Netgame stuff
// =============
-#include "netcode/d_clisrv.h"
+#include "d_clisrv.h"
extern consvar_t cv_timetic; // display high resolution timer
extern consvar_t cv_powerupdisplay; // display powerups
diff --git a/src/dummy/i_net.c b/src/dummy/i_net.c
index 4c30dc767a04615b75e6badf68d3603bc475a575..f6e642022e4a54360d68004f69d61eaa5e3acb19 100644
--- a/src/dummy/i_net.c
+++ b/src/dummy/i_net.c
@@ -1,4 +1,4 @@
-#include "../netcode/i_net.h"
+#include "../i_net.h"
boolean I_InitNetwork(void)
{
diff --git a/src/f_finale.c b/src/f_finale.c
index 2122cf34d91bb11e2c4ae94e24d028d4b34d3136..307e00aaa2d26118672b1d173be0b6ffa7011256 100644
--- a/src/f_finale.c
+++ b/src/f_finale.c
@@ -14,7 +14,7 @@
#include "doomdef.h"
#include "doomstat.h"
#include "d_main.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "f_finale.h"
#include "g_game.h"
#include "hu_stuff.h"
diff --git a/src/filesrch.c b/src/filesrch.c
index d68a7d5ed427eaa7d8b09ee305d9354c7eeb9352..23b8e7f409b5c450f0d507b2075bebb611efa508 100644
--- a/src/filesrch.c
+++ b/src/filesrch.c
@@ -26,7 +26,7 @@
#include <string.h>
#include "filesrch.h"
-#include "netcode/d_netfil.h"
+#include "d_netfil.h"
#include "m_misc.h"
#include "z_zone.h"
#include "m_menu.h" // Addons_option_Onchange
diff --git a/src/filesrch.h b/src/filesrch.h
index a934c48d61bc9cfa4e31f550c2001bd582908e31..59ef5269b194f0918a14927a6fc1eaf003e1a40b 100644
--- a/src/filesrch.h
+++ b/src/filesrch.h
@@ -5,7 +5,7 @@
#define __FILESRCH_H__
#include "doomdef.h"
-#include "netcode/d_netfil.h"
+#include "d_netfil.h"
#include "m_menu.h" // MAXSTRINGLENGTH
#include "w_wad.h"
diff --git a/src/g_demo.c b/src/g_demo.c
index 6167b3a09f325222dcfa5f9a6ad74175850f3726..9099adc712635170d14f0ea61bc77aa9808a635c 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -15,7 +15,7 @@
#include "console.h"
#include "d_main.h"
#include "d_player.h"
-#include "netcode/d_clisrv.h"
+#include "d_clisrv.h"
#include "p_setup.h"
#include "i_time.h"
#include "i_system.h"
diff --git a/src/g_game.c b/src/g_game.c
index 2aa2d78624524a2ff6ced563b79eeafbadd5eb65..dc12c2bab727752feb4ddf3a211062610c02f02d 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -15,8 +15,7 @@
#include "console.h"
#include "d_main.h"
#include "d_player.h"
-#include "netcode/d_clisrv.h"
-#include "netcode/net_command.h"
+#include "d_clisrv.h"
#include "f_finale.h"
#include "p_setup.h"
#include "p_saveg.h"
diff --git a/src/g_input.c b/src/g_input.c
index d425c6ba857e4c135248c96445405a46a0480c20..87f4d5173be20a9d97d302374e3fcfbf8609366b 100644
--- a/src/g_input.c
+++ b/src/g_input.c
@@ -18,7 +18,7 @@
#include "i_gamepad.h"
#include "keys.h"
#include "hu_stuff.h" // need HUFONT start & end
-#include "netcode/d_net.h"
+#include "d_net.h"
#include "console.h"
#define MAXMOUSESENSITIVITY 100 // sensitivity steps
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index 24a39e2fb5075dffbfa999b167a8cca2295c8d18..3a6baab71c3b9a0225ce4471adff28077136d62a 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -29,7 +29,7 @@
#include "../r_patch.h"
#include "../r_picformats.h"
#include "../r_bsp.h"
-#include "../netcode/d_clisrv.h"
+#include "../d_clisrv.h"
#include "../w_wad.h"
#include "../z_zone.h"
#include "../r_splats.h"
@@ -5234,7 +5234,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
{
interpmobjstate_t casterinterp = { 0 };
fixed_t groundz;
- fixed_t floordiff;
+ fixed_t floordiff;
if (R_UsingFrameInterpolation() && !paused)
{
@@ -5244,7 +5244,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
{
R_InterpolateMobjState(caster, FRACUNIT, &casterinterp);
}
-
+
groundz = R_GetShadowZ(thing, NULL);
floordiff = abs(((thing->eflags & MFE_VERTICALFLIP) ? caster->height : 0) + casterinterp.z - groundz);
diff --git a/src/netcode/http-mserv.c b/src/http-mserv.c
similarity index 98%
rename from src/netcode/http-mserv.c
rename to src/http-mserv.c
index 1ef18093514fb88a4d7dd292a668f06f6cbfaec6..7b418c99ad127461099a68c0452980dff18c78b2 100644
--- a/src/netcode/http-mserv.c
+++ b/src/http-mserv.c
@@ -18,15 +18,14 @@ Documentation available here.
#include <curl/curl.h>
#endif
-#include "../doomdef.h"
+#include "doomdef.h"
#include "d_clisrv.h"
-#include "client_connection.h"
-#include "../command.h"
-#include "../m_argv.h"
-#include "../m_menu.h"
+#include "command.h"
+#include "m_argv.h"
+#include "m_menu.h"
#include "mserv.h"
#include "i_tcp.h"/* for current_port */
-#include "../i_threads.h"
+#include "i_threads.h"
/* reasonable default I guess?? */
#define DEFAULT_BUFFER_SIZE (4096)
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index 7ec33bd79fc35dede0dd00146922e8f0b468566d..805aa694f8238f2a69f3854feb8521d9c190d3ee 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -19,9 +19,7 @@
#include "m_cond.h" // emblems
#include "m_misc.h" // word jumping
-#include "netcode/d_clisrv.h"
-#include "netcode/net_command.h"
-#include "netcode/gamestate.h"
+#include "d_clisrv.h"
#include "g_game.h"
#include "g_input.h"
@@ -177,12 +175,14 @@ static huddrawlist_h luahuddrawlist_scores;
static tic_t resynch_ticker = 0;
+#ifndef NONET
// just after
static void Command_Say_f(void);
static void Command_Sayto_f(void);
static void Command_Sayteam_f(void);
static void Command_CSay_f(void);
static void Got_Saycmd(UINT8 **p, INT32 playernum);
+#endif
void HU_LoadGraphics(void)
{
@@ -327,11 +327,13 @@ void HU_LoadGraphics(void)
//
void HU_Init(void)
{
+#ifndef NONET
COM_AddCommand("say", Command_Say_f);
COM_AddCommand("sayto", Command_Sayto_f);
COM_AddCommand("sayteam", Command_Sayteam_f);
COM_AddCommand("csay", Command_CSay_f);
RegisterNetXCmd(XD_SAY, Got_Saycmd);
+#endif
// set shift translation table
shiftxform = english_shiftxform;
@@ -361,6 +363,8 @@ void HU_Start(void)
// EXECUTION
//======================================================================
+#ifndef NONET
+
// EVERY CHANGE IN THIS SCRIPT IS LOL XD! BY VINCYTM
static UINT32 chat_nummsg_log = 0;
@@ -408,9 +412,11 @@ static void HU_removeChatText_Log(void)
}
chat_nummsg_log--; // lost 1 msg.
}
+#endif
void HU_AddChatText(const char *text, boolean playsound)
{
+#ifndef NONET
if (playsound && cv_consolechat.value != 2) // Don't play the sound if we're using hidden chat.
S_StartSound(NULL, sfx_radio);
// reguardless of our preferences, put all of this in the chat buffer in case we decide to change from oldchat mid-game.
@@ -432,8 +438,14 @@ void HU_AddChatText(const char *text, boolean playsound)
CONS_Printf("%s\n", text);
else // if we aren't, still save the message to log.txt
CON_LogMessage(va("%s\n", text));
+#else
+ (void)playsound;
+ CONS_Printf("%s\n", text);
+#endif
}
+#ifndef NONET
+
/** Runs a say command, sending an ::XD_SAY message.
* A say command consists of a signed 8-bit integer for the target, an
* unsigned 8-bit flag variable, and then the message itself.
@@ -853,6 +865,8 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
#endif
}
+#endif
+
//
//
void HU_Ticker(void)
@@ -868,6 +882,7 @@ void HU_Ticker(void)
else
hu_showscores = false;
+#ifndef NONET
if (chat_on)
{
// count down the scroll timer.
@@ -895,6 +910,7 @@ void HU_Ticker(void)
HU_removeChatText_Mini();
}
}
+#endif
if (cechotimer > 0) --cechotimer;
@@ -902,6 +918,8 @@ void HU_Ticker(void)
resynch_ticker++;
}
+#ifndef NONET
+
static boolean teamtalk = false;
static boolean justscrolleddown;
static boolean justscrolledup;
@@ -1009,6 +1027,8 @@ static void HU_sendChatMessage(void)
}
}
+#endif
+
void HU_clearChatChars(void)
{
memset(w_chat, '\0', sizeof(w_chat));
@@ -1023,13 +1043,16 @@ void HU_clearChatChars(void)
//
boolean HU_Responder(event_t *ev)
{
+#ifndef NONET
INT32 c=0;
+#endif
if (ev->type != ev_keydown)
return false;
// only KeyDown events now...
+#ifndef NONET
c = (INT32)ev->key;
if (!chat_on)
@@ -1179,6 +1202,7 @@ boolean HU_Responder(event_t *ev)
return true;
}
+#endif
return false;
}
@@ -1188,6 +1212,8 @@ boolean HU_Responder(event_t *ev)
// HEADS UP DRAWING
//======================================================================
+#ifndef NONET
+
// Precompile a wordwrapped string to any given width.
// This is a muuuch better method than V_WORDWRAP.
// again stolen and modified a bit from video.c, don't mind me, will need to rearrange this one day.
@@ -1767,6 +1793,7 @@ static void HU_DrawChat_Old(void)
if (hu_tick < 4)
V_DrawCharacter(HU_INPUTX + c, y, '_' | cv_constextsize.value |V_NOSCALESTART|t, true);
}
+#endif
// Draw crosshairs at the exact center of the view.
// In splitscreen, crosshairs are stretched vertically to compensate for V_PERPLAYER squishing them.
@@ -1906,6 +1933,7 @@ static void HU_DrawDemoInfo(void)
//
void HU_Drawer(void)
{
+#ifndef NONET
// draw chat string plus cursor
if (chat_on)
{
@@ -1922,6 +1950,7 @@ void HU_Drawer(void)
if (!OLDCHAT && cv_consolechat.value < 2 && netgame) // Don't display minimized chat if you set the mode to Window (Hidden)
HU_drawMiniChat(); // draw messages in a cool fashion.
}
+#endif
if (cechotimer)
HU_DrawCEcho();
diff --git a/src/netcode/i_addrinfo.c b/src/i_addrinfo.c
similarity index 100%
rename from src/netcode/i_addrinfo.c
rename to src/i_addrinfo.c
diff --git a/src/netcode/i_addrinfo.h b/src/i_addrinfo.h
similarity index 100%
rename from src/netcode/i_addrinfo.h
rename to src/i_addrinfo.h
diff --git a/src/netcode/i_net.h b/src/i_net.h
similarity index 98%
rename from src/netcode/i_net.h
rename to src/i_net.h
index 66126d050348ae23034ecfe9efa15c0a035c3214..62b7528d59f0bcf6877f55ab467687fc7a55dad5 100644
--- a/src/netcode/i_net.h
+++ b/src/i_net.h
@@ -18,8 +18,8 @@
#pragma interface
#endif
-#include "../doomdef.h"
-#include "../command.h"
+#include "doomdef.h"
+#include "command.h"
/// \brief program net id
#define DOOMCOM_ID (INT32)0x12345678l
diff --git a/src/netcode/i_tcp.c b/src/i_tcp.c
similarity index 88%
rename from src/netcode/i_tcp.c
rename to src/i_tcp.c
index bd950c355992f554ed8bc2c52dd7db50a907fb5c..8838ba7257efb99adef6379935f36ca57cfd3876 100644
--- a/src/netcode/i_tcp.c
+++ b/src/i_tcp.c
@@ -36,100 +36,109 @@
#include <ws2tcpip.h>
#endif
-#include "../doomdef.h"
+#include "doomdef.h"
-#ifdef USE_WINSOCK1
- #include <winsock.h>
-#else
- #ifndef USE_WINSOCK
- #include <arpa/inet.h>
- #ifdef __APPLE_CC__
- #ifndef _BSD_SOCKLEN_T_
- #define _BSD_SOCKLEN_T_
- #endif //_BSD_SOCKLEN_T_
- #endif //__APPLE_CC__
- #include <sys/socket.h>
- #include <netinet/in.h>
- #include <netdb.h>
- #include <sys/ioctl.h>
- #endif //normal BSD API
-
- #include <errno.h>
- #include <time.h>
-
- #if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
- #include <sys/time.h>
- #endif // UNIXCOMMON
+#if defined (NOMD5) && !defined (NONET)
+ //#define NONET
#endif
-#ifdef USE_WINSOCK
- // some undefined under win32
- #undef errno
- //#define errno WSAGetLastError() //Alam_GBC: this is the correct way, right?
- #define errno h_errno // some very strange things happen when not using h_error?!?
- #ifdef EWOULDBLOCK
- #undef EWOULDBLOCK
- #endif
- #define EWOULDBLOCK WSAEWOULDBLOCK
- #ifdef EMSGSIZE
- #undef EMSGSIZE
- #endif
- #define EMSGSIZE WSAEMSGSIZE
- #ifdef ECONNREFUSED
- #undef ECONNREFUSED
- #endif
- #define ECONNREFUSED WSAECONNREFUSED
- #ifdef ETIMEDOUT
- #undef ETIMEDOUT
- #endif
- #define ETIMEDOUT WSAETIMEDOUT
- #ifndef IOC_VENDOR
- #define IOC_VENDOR 0x18000000
- #endif
- #ifndef _WSAIOW
- #define _WSAIOW(x,y) (IOC_IN|(x)|(y))
- #endif
- #ifndef SIO_UDP_CONNRESET
- #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
- #endif
- #ifndef AI_ADDRCONFIG
- #define AI_ADDRCONFIG 0x00000400
+#ifdef NONET
+ #undef HAVE_MINIUPNPC
+#else
+ #ifdef USE_WINSOCK1
+ #include <winsock.h>
+ #else
+ #ifndef USE_WINSOCK
+ #include <arpa/inet.h>
+ #ifdef __APPLE_CC__
+ #ifndef _BSD_SOCKLEN_T_
+ #define _BSD_SOCKLEN_T_
+ #endif //_BSD_SOCKLEN_T_
+ #endif //__APPLE_CC__
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <netdb.h>
+ #include <sys/ioctl.h>
+ #endif //normal BSD API
+
+ #include <errno.h>
+ #include <time.h>
+
+ #if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
+ #include <sys/time.h>
+ #endif // UNIXCOMMON
#endif
- #ifndef STATUS_INVALID_PARAMETER
- #define STATUS_INVALID_PARAMETER 0xC000000D
+
+ #ifdef USE_WINSOCK
+ // some undefined under win32
+ #undef errno
+ //#define errno WSAGetLastError() //Alam_GBC: this is the correct way, right?
+ #define errno h_errno // some very strange things happen when not using h_error?!?
+ #ifdef EWOULDBLOCK
+ #undef EWOULDBLOCK
+ #endif
+ #define EWOULDBLOCK WSAEWOULDBLOCK
+ #ifdef EMSGSIZE
+ #undef EMSGSIZE
+ #endif
+ #define EMSGSIZE WSAEMSGSIZE
+ #ifdef ECONNREFUSED
+ #undef ECONNREFUSED
+ #endif
+ #define ECONNREFUSED WSAECONNREFUSED
+ #ifdef ETIMEDOUT
+ #undef ETIMEDOUT
+ #endif
+ #define ETIMEDOUT WSAETIMEDOUT
+ #ifndef IOC_VENDOR
+ #define IOC_VENDOR 0x18000000
+ #endif
+ #ifndef _WSAIOW
+ #define _WSAIOW(x,y) (IOC_IN|(x)|(y))
+ #endif
+ #ifndef SIO_UDP_CONNRESET
+ #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
+ #endif
+ #ifndef AI_ADDRCONFIG
+ #define AI_ADDRCONFIG 0x00000400
+ #endif
+ #ifndef STATUS_INVALID_PARAMETER
+ #define STATUS_INVALID_PARAMETER 0xC000000D
+ #endif
+ #endif // USE_WINSOCK
+
+ typedef union
+ {
+ struct sockaddr any;
+ struct sockaddr_in ip4;
+ #ifdef HAVE_IPV6
+ struct sockaddr_in6 ip6;
#endif
-#endif // USE_WINSOCK
+ } mysockaddr_t;
-typedef union
-{
- struct sockaddr any;
- struct sockaddr_in ip4;
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ip6;
-#endif
-} mysockaddr_t;
+ #ifdef HAVE_MINIUPNPC
+ #ifdef STATIC_MINIUPNPC
+ #define STATICLIB
+ #endif
+ #include "miniupnpc/miniwget.h"
+ #include "miniupnpc/miniupnpc.h"
+ #include "miniupnpc/upnpcommands.h"
+ #undef STATICLIB
+ static UINT8 UPNP_support = TRUE;
+ #endif // HAVE_MINIUPNC
-#ifdef HAVE_MINIUPNPC
- #ifdef STATIC_MINIUPNPC
- #define STATICLIB
- #endif
- #include "miniupnpc/miniwget.h"
- #include "miniupnpc/miniupnpc.h"
- #include "miniupnpc/upnpcommands.h"
- #undef STATICLIB
- static UINT8 UPNP_support = TRUE;
-#endif // HAVE_MINIUPNC
+#endif // !NONET
#define MAXBANS 100
-#include "../i_system.h"
+#include "i_system.h"
#include "i_net.h"
#include "d_net.h"
#include "d_netfil.h"
#include "i_tcp.h"
-#include "../m_argv.h"
+#include "m_argv.h"
-#include "../doomstat.h"
+#include "doomstat.h"
// win32
#ifdef USE_WINSOCK
@@ -142,7 +151,7 @@ typedef union
#define SELECTTEST
#define DEFAULTPORT "5029"
-#ifdef USE_WINSOCK
+#if defined (USE_WINSOCK) && !defined (NONET)
typedef SOCKET SOCKET_TYPE;
#define ERRSOCKET (SOCKET_ERROR)
#else
@@ -154,20 +163,22 @@ typedef union
#define ERRSOCKET (-1)
#endif
-// define socklen_t in DOS/Windows if it is not already defined
-#ifdef USE_WINSOCK1
- typedef int socklen_t;
+#ifndef NONET
+ // define socklen_t in DOS/Windows if it is not already defined
+ #ifdef USE_WINSOCK1
+ typedef int socklen_t;
+ #endif
+ static SOCKET_TYPE mysockets[MAXNETNODES+1] = {ERRSOCKET};
+ static size_t mysocketses = 0;
+ static int myfamily[MAXNETNODES+1] = {0};
+ static SOCKET_TYPE nodesocket[MAXNETNODES+1] = {ERRSOCKET};
+ static mysockaddr_t clientaddress[MAXNETNODES+1];
+ static mysockaddr_t broadcastaddress[MAXNETNODES+1];
+ static size_t broadcastaddresses = 0;
+ static boolean nodeconnected[MAXNETNODES+1];
+ static mysockaddr_t banned[MAXBANS];
+ static UINT8 bannedmask[MAXBANS];
#endif
-static SOCKET_TYPE mysockets[MAXNETNODES+1] = {ERRSOCKET};
-static size_t mysocketses = 0;
-static int myfamily[MAXNETNODES+1] = {0};
-static SOCKET_TYPE nodesocket[MAXNETNODES+1] = {ERRSOCKET};
-static mysockaddr_t clientaddress[MAXNETNODES+1];
-static mysockaddr_t broadcastaddress[MAXNETNODES+1];
-static size_t broadcastaddresses = 0;
-static boolean nodeconnected[MAXNETNODES+1];
-static mysockaddr_t banned[MAXBANS];
-static UINT8 bannedmask[MAXBANS];
static size_t numbans = 0;
static boolean SOCK_bannednode[MAXNETNODES+1]; /// \note do we really need the +1?
@@ -176,6 +187,7 @@ static boolean init_tcp_driver = false;
static const char *serverport_name = DEFAULTPORT;
static const char *clientport_name;/* any port */
+#ifndef NONET
#ifdef USE_WINSOCK
// stupid microsoft makes things complicated
static char *get_WSAErrorStr(int e)
@@ -362,33 +374,47 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
#endif
return s;
}
+#endif
static const char *SOCK_GetNodeAddress(INT32 node)
{
if (node == 0)
return "self";
+#ifdef NONET
+ return NULL;
+#else
if (!nodeconnected[node])
return NULL;
return SOCK_AddrToStr(&clientaddress[node]);
+#endif
}
static const char *SOCK_GetBanAddress(size_t ban)
{
if (ban >= numbans)
return NULL;
+#ifdef NONET
+ return NULL;
+#else
return SOCK_AddrToStr(&banned[ban]);
+#endif
}
static const char *SOCK_GetBanMask(size_t ban)
{
+#ifdef NONET
+ (void)ban;
+#else
static char s[16]; //255.255.255.255 netmask? no, just CDIR for only
if (ban >= numbans)
return NULL;
if (sprintf(s,"%d",bannedmask[ban]) > 0)
return s;
+#endif
return NULL;
}
+#ifndef NONET
static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
{
UINT32 bitmask = INADDR_NONE;
@@ -416,20 +442,24 @@ static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
*/
static void cleanupnodes(void)
{
+ SINT8 j;
+
if (!Playing())
return;
// Why can't I start at zero?
- for (SINT8 j = 1; j < MAXNETNODES; j++)
- if (!(netnodes[j].ingame || SendingFile(j)))
+ for (j = 1; j < MAXNETNODES; j++)
+ if (!(nodeingame[j] || SendingFile(j)))
nodeconnected[j] = false;
}
static SINT8 getfreenode(void)
{
+ SINT8 j;
+
cleanupnodes();
- for (SINT8 j = 0; j < MAXNETNODES; j++)
+ for (j = 0; j < MAXNETNODES; j++)
if (!nodeconnected[j])
{
nodeconnected[j] = true;
@@ -442,8 +472,8 @@ static SINT8 getfreenode(void)
* downloading a needed wad, but it's better than not letting anyone join...
*/
/*I_Error("No more free nodes!!1!11!11!!1111\n");
- for (SINT8 j = 1; j < MAXNETNODES; j++)
- if (!netnodes[j].ingame)
+ for (j = 1; j < MAXNETNODES; j++)
+ if (!nodeingame[j])
return j;*/
return -1;
@@ -454,27 +484,28 @@ void Command_Numnodes(void)
{
INT32 connected = 0;
INT32 ingame = 0;
+ INT32 i;
- for (INT32 i = 1; i < MAXNETNODES; i++)
+ for (i = 1; i < MAXNETNODES; i++)
{
- if (!(nodeconnected[i] || netnodes[i].ingame))
+ if (!(nodeconnected[i] || nodeingame[i]))
continue;
if (nodeconnected[i])
connected++;
- if (netnodes[i].ingame)
+ if (nodeingame[i])
ingame++;
CONS_Printf("%2d - ", i);
- if (netnodes[i].player != -1)
- CONS_Printf("player %.2d", netnodes[i].player);
+ if (nodetoplayer[i] != -1)
+ CONS_Printf("player %.2d", nodetoplayer[i]);
else
CONS_Printf(" ");
if (nodeconnected[i])
CONS_Printf(" - connected");
else
CONS_Printf(" - ");
- if (netnodes[i].ingame)
+ if (nodeingame[i])
CONS_Printf(" - ingame");
else
CONS_Printf(" - ");
@@ -487,17 +518,19 @@ void Command_Numnodes(void)
connected, ingame);
}
#endif
+#endif
+#ifndef NONET
// Returns true if a packet was received from a new node, false in all other cases
static boolean SOCK_Get(void)
{
- size_t i;
+ size_t i, n;
int j;
ssize_t c;
mysockaddr_t fromaddress;
socklen_t fromlen;
- for (size_t n = 0; n < mysocketses; n++)
+ for (n = 0; n < mysocketses; n++)
{
fromlen = (socklen_t)sizeof(fromaddress);
c = recvfrom(mysockets[n], (char *)&doomcom->data, MAXPACKETLENGTH, 0,
@@ -550,17 +583,20 @@ static boolean SOCK_Get(void)
doomcom->remotenode = -1; // no packet
return false;
}
+#endif
// check if we can send (do not go over the buffer)
+#ifndef NONET
static fd_set masterset;
#ifdef SELECTTEST
static boolean FD_CPY(fd_set *src, fd_set *dst, SOCKET_TYPE *fd, size_t len)
{
+ size_t i;
boolean testset = false;
FD_ZERO(dst);
- for (size_t i = 0; i < len;i++)
+ for (i = 0; i < len;i++)
{
if(fd[i] != (SOCKET_TYPE)ERRSOCKET &&
FD_ISSET(fd[i], src) && !FD_ISSET(fd[i], dst)) // no checking for dups
@@ -600,7 +636,9 @@ static boolean SOCK_CanGet(void)
return false;
}
#endif
+#endif
+#ifndef NONET
static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr)
{
socklen_t d4 = (socklen_t)sizeof(struct sockaddr_in);
@@ -624,15 +662,16 @@ static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr
static void SOCK_Send(void)
{
ssize_t c = ERRSOCKET;
+ size_t i, j;
if (!nodeconnected[doomcom->remotenode])
return;
if (doomcom->remotenode == BROADCASTADDR)
{
- for (size_t i = 0; i < mysocketses; i++)
+ for (i = 0; i < mysocketses; i++)
{
- for (size_t j = 0; j < broadcastaddresses; j++)
+ for (j = 0; j < broadcastaddresses; j++)
{
if (myfamily[i] == broadcastaddress[j].any.sa_family)
SOCK_SendToAddr(mysockets[i], &broadcastaddress[j]);
@@ -642,7 +681,7 @@ static void SOCK_Send(void)
}
else if (nodesocket[doomcom->remotenode] == (SOCKET_TYPE)ERRSOCKET)
{
- for (size_t i = 0; i < mysocketses; i++)
+ for (i = 0; i < mysocketses; i++)
{
if (myfamily[i] == clientaddress[doomcom->remotenode].any.sa_family)
SOCK_SendToAddr(mysockets[i], &clientaddress[doomcom->remotenode]);
@@ -662,7 +701,9 @@ static void SOCK_Send(void)
SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
}
}
+#endif
+#ifndef NONET
static void SOCK_FreeNodenum(INT32 numnode)
{
// can't disconnect from self :)
@@ -677,10 +718,12 @@ static void SOCK_FreeNodenum(INT32 numnode)
// put invalid address
memset(&clientaddress[numnode], 0, sizeof (clientaddress[numnode]));
}
+#endif
//
// UDPsocket
//
+#ifndef NONET
// allocate a socket
static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen)
@@ -1001,10 +1044,12 @@ static boolean UDP_Socket(void)
return true;
}
+#endif
boolean I_InitTcpDriver(void)
{
boolean tcp_was_up = init_tcp_driver;
+#ifndef NONET
if (!init_tcp_driver)
{
#ifdef USE_WINSOCK
@@ -1059,7 +1104,7 @@ boolean I_InitTcpDriver(void)
#endif
init_tcp_driver = true;
}
-
+#endif
if (!tcp_was_up && init_tcp_driver)
{
I_AddExitFunc(I_ShutdownTcpDriver);
@@ -1073,9 +1118,11 @@ boolean I_InitTcpDriver(void)
return init_tcp_driver;
}
+#ifndef NONET
static void SOCK_CloseSocket(void)
{
- for (size_t i=0; i < MAXNETNODES+1; i++)
+ size_t i;
+ for (i=0; i < MAXNETNODES+1; i++)
{
if (mysockets[i] != (SOCKET_TYPE)ERRSOCKET
&& FD_ISSET(mysockets[i], &masterset))
@@ -1086,9 +1133,11 @@ static void SOCK_CloseSocket(void)
mysockets[i] = ERRSOCKET;
}
}
+#endif
void I_ShutdownTcpDriver(void)
{
+#ifndef NONET
SOCK_CloseSocket();
CONS_Printf("I_ShutdownTcpDriver: ");
@@ -1098,8 +1147,10 @@ void I_ShutdownTcpDriver(void)
#endif
CONS_Printf("shut down\n");
init_tcp_driver = false;
+#endif
}
+#ifndef NONET
static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
{
SINT8 newnode = -1;
@@ -1143,13 +1194,17 @@ static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
I_freeaddrinfo(ai);
return newnode;
}
+#endif
static boolean SOCK_OpenSocket(void)
{
+#ifndef NONET
+ size_t i;
+
memset(clientaddress, 0, sizeof (clientaddress));
nodeconnected[0] = true; // always connected to self
- for (size_t i = 1; i < MAXNETNODES; i++)
+ for (i = 1; i < MAXNETNODES; i++)
nodeconnected[i] = false;
nodeconnected[BROADCASTADDR] = true;
I_NetSend = SOCK_Send;
@@ -1167,12 +1222,18 @@ static boolean SOCK_OpenSocket(void)
// build the socket but close it first
SOCK_CloseSocket();
return UDP_Socket();
+#else
+ return false;
+#endif
}
static boolean SOCK_Ban(INT32 node)
{
if (node > MAXNETNODES)
return false;
+#ifdef NONET
+ return false;
+#else
if (numbans == MAXBANS)
return false;
@@ -1191,10 +1252,16 @@ static boolean SOCK_Ban(INT32 node)
#endif
numbans++;
return true;
+#endif
}
static boolean SOCK_SetBanAddress(const char *address, const char *mask)
{
+#ifdef NONET
+ (void)address;
+ (void)mask;
+ return false;
+#else
struct my_addrinfo *ai, *runp, hints;
int gaie;
@@ -1239,6 +1306,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
I_freeaddrinfo(ai);
return true;
+#endif
}
static void SOCK_ClearBans(void)
diff --git a/src/netcode/i_tcp.h b/src/i_tcp.h
similarity index 100%
rename from src/netcode/i_tcp.h
rename to src/i_tcp.h
diff --git a/src/i_time.c b/src/i_time.c
index 9303d7be7abd504a60048fa38f52c1f36539e925..c1cc9dfd44d1c20828c598b44826fdbb48fed919 100644
--- a/src/i_time.c
+++ b/src/i_time.c
@@ -17,7 +17,7 @@
#include "command.h"
#include "doomtype.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "m_fixed.h"
#include "i_system.h"
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index ea519be55f4d19f368ef9f40f0e1f4924a41f53a..c94e9e91ef245ff84236536e69736235addf0584 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -27,11 +27,11 @@
#include "y_inter.h"
#include "hu_stuff.h" // HU_AddChatText
#include "console.h"
-#include "netcode/d_netcmd.h" // IsPlayerAdmin
+#include "d_netcmd.h" // IsPlayerAdmin
#include "m_menu.h" // Player Setup menu color stuff
#include "m_misc.h" // M_MapNumber
#include "b_bot.h" // B_UpdateBotleader
-#include "netcode/d_clisrv.h" // CL_RemovePlayer
+#include "d_clisrv.h" // CL_RemovePlayer
#include "i_system.h" // I_GetPreciseTime, I_GetPrecisePrecision
#include "lua_script.h"
diff --git a/src/lua_consolelib.c b/src/lua_consolelib.c
index a1bdf380d231c1a6cbb1659628ed3034ec630cec..81605119906ae3ad70fe887e7393965c81c288e7 100644
--- a/src/lua_consolelib.c
+++ b/src/lua_consolelib.c
@@ -16,7 +16,6 @@
#include "g_game.h"
#include "byteptr.h"
#include "z_zone.h"
-#include "netcode/net_command.h"
#include "lua_script.h"
#include "lua_libs.h"
diff --git a/src/lua_hooklib.c b/src/lua_hooklib.c
index 2b1fef238fdb0fc5407e0b6aa674e674b50fc6b0..ef8426d7ac2c4a38d71cb4c0d08e8eda00401b85 100644
--- a/src/lua_hooklib.c
+++ b/src/lua_hooklib.c
@@ -25,7 +25,7 @@
#include "lua_hud.h" // hud_running errors
#include "m_perfstats.h"
-#include "netcode/d_netcmd.h" // for cv_perfstats
+#include "d_netcmd.h" // for cv_perfstats
#include "i_system.h" // I_GetPreciseTime
/* =========================================================================
diff --git a/src/lua_script.c b/src/lua_script.c
index f1c800df5cc7ca22bcb6546a87186e117da63bbd..8d8fb295cda8cdf0df4e0bd42b31e6ae344d88cc 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -28,7 +28,7 @@
#include "p_slopes.h" // for P_SlopeById and slopelist
#include "p_polyobj.h" // polyobj_t, PolyObjects
#ifdef LUA_ALLOW_BYTECODE
-#include "netcode/d_netfil.h" // for LUA_DumpFile
+#include "d_netfil.h" // for LUA_DumpFile
#endif
#include "lua_script.h"
diff --git a/src/m_cheat.c b/src/m_cheat.c
index 36b2d19073c28b123f6f0ec4ea7a520eae58670c..f943774504e336914c46c9436948bef125a79d2f 100644
--- a/src/m_cheat.c
+++ b/src/m_cheat.c
@@ -19,7 +19,7 @@
#include "r_local.h"
#include "p_local.h"
#include "p_setup.h"
-#include "netcode/d_net.h"
+#include "d_net.h"
#include "m_cheat.h"
#include "m_menu.h"
diff --git a/src/m_menu.c b/src/m_menu.c
index eecac55a779762d2acb53aac4c175ca69024b78c..1e7e1a7610c72a9fd40ef1b11f64ad6b53dd45a1 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -20,7 +20,7 @@
#include "doomdef.h"
#include "d_main.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "console.h"
#include "r_fps.h"
#include "r_local.h"
@@ -55,10 +55,8 @@
#include "hardware/hw_main.h"
#endif
-#include "netcode/d_net.h"
-#include "netcode/mserv.h"
-#include "netcode/server_connection.h"
-#include "netcode/client_connection.h"
+#include "d_net.h"
+#include "mserv.h"
#include "m_misc.h"
#include "m_anigif.h"
#include "byteptr.h"
@@ -149,7 +147,9 @@ static struct
INT32 index;
} gamepadInfo[MAX_CONNECTED_GAMEPADS + 1];
+#ifndef NONET
static UINT32 serverlistpage;
+#endif
static UINT8 numsaves = 0;
static saveinfo_t* savegameinfo = NULL; // Extra info about the save games.
@@ -189,8 +189,10 @@ static void M_GoBack(INT32 choice);
static void M_StopMessage(INT32 choice);
static boolean stopstopmessage = false;
+#ifndef NONET
static void M_HandleServerPage(INT32 choice);
static void M_RoomMenu(INT32 choice);
+#endif
// Prototyping is fun, innit?
// ==========================================================================
@@ -292,6 +294,7 @@ static void M_SetupMultiPlayer2(INT32 choice);
static void M_StartSplitServerMenu(INT32 choice);
static void M_StartServer(INT32 choice);
static void M_ServerOptions(INT32 choice);
+#ifndef NONET
static void M_StartServerMenu(INT32 choice);
static void M_ConnectMenu(INT32 choice);
static void M_ConnectMenuModChecks(INT32 choice);
@@ -299,6 +302,7 @@ static void M_Refresh(INT32 choice);
static void M_Connect(INT32 choice);
static void M_ChooseRoom(INT32 choice);
menu_t MP_MainDef;
+#endif
// Options
// Split into multiple parts due to size
@@ -377,9 +381,11 @@ static void M_DrawVideoMode(void);
static void M_DrawColorMenu(void);
static void M_DrawScreenshotMenu(void);
static void M_DrawMonitorToggles(void);
+#ifndef NONET
static void M_DrawConnectMenu(void);
static void M_DrawMPMainMenu(void);
static void M_DrawRoomMenu(void);
+#endif
static void M_DrawGamepadList(void);
static void M_DrawSetupMultiPlayerMenu(void);
@@ -393,8 +399,10 @@ static void M_HandleImageDef(INT32 choice);
static void M_HandleLoadSave(INT32 choice);
static void M_HandleLevelStats(INT32 choice);
static void M_HandlePlaystyleMenu(INT32 choice);
+#ifndef NONET
static boolean M_CancelConnect(void);
static void M_HandleConnectIP(INT32 choice);
+#endif
static void M_HandleSetupMultiPlayer(INT32 choice);
static void M_HandleVideoMode(INT32 choice);
@@ -493,7 +501,11 @@ consvar_t cv_dummyloadless = CVAR_INIT ("dummyloadless", "In-game", CV_HIDEN, lo
static menuitem_t MainMenu[] =
{
{IT_STRING|IT_CALL, NULL, "1 Player", M_SinglePlayerMenu, 76},
+#ifndef NONET
{IT_STRING|IT_SUBMENU, NULL, "Multiplayer", &MP_MainDef, 84},
+#else
+ {IT_STRING|IT_CALL, NULL, "Multiplayer", M_StartSplitServerMenu, 84},
+#endif
{IT_STRING|IT_CALL, NULL, "Extras", M_SecretsMenu, 92},
{IT_CALL |IT_STRING, NULL, "Addons", M_Addons, 100},
{IT_STRING|IT_CALL, NULL, "Options", M_Options, 108},
@@ -944,10 +956,16 @@ static menuitem_t SP_PlayerMenu[] =
static menuitem_t MP_SplitServerMenu[] =
{
{IT_STRING|IT_CALL, NULL, "Select Gametype/Level...", M_MapChange, 100},
+#ifdef NONET // In order to keep player setup accessible.
+ {IT_STRING|IT_CALL, NULL, "Player 1 setup...", M_SetupMultiPlayer, 110},
+ {IT_STRING|IT_CALL, NULL, "Player 2 setup...", M_SetupMultiPlayer2, 120},
+#endif
{IT_STRING|IT_CALL, NULL, "More Options...", M_ServerOptions, 130},
{IT_WHITESTRING|IT_CALL, NULL, "Start", M_StartServer, 140},
};
+#ifndef NONET
+
static menuitem_t MP_MainMenu[] =
{
{IT_HEADER, NULL, "Join a game", NULL, 0},
@@ -1034,6 +1052,8 @@ menuitem_t MP_RoomMenu[] =
{IT_DISABLED, NULL, "", M_ChooseRoom, 162},
};
+#endif
+
static menuitem_t MP_PlayerSetupMenu[] =
{
{IT_KEYHANDLER, NULL, "", M_HandleSetupMultiPlayer, 0}, // name
@@ -1601,12 +1621,14 @@ enum
static menuitem_t OP_ServerOptionsMenu[] =
{
{IT_HEADER, NULL, "General", NULL, 0},
+#ifndef NONET
{IT_STRING | IT_CVAR | IT_CV_STRING,
NULL, "Server name", &cv_servername, 7},
{IT_STRING | IT_CVAR, NULL, "Max Players", &cv_maxplayers, 21},
{IT_STRING | IT_CVAR, NULL, "Allow Add-on Downloading", &cv_downloading, 26},
{IT_STRING | IT_CVAR, NULL, "Allow players to join", &cv_allownewplayer, 31},
{IT_STRING | IT_CVAR, NULL, "Minutes for reconnecting", &cv_rejointimeout, 36},
+#endif
{IT_STRING | IT_CVAR, NULL, "Map progression", &cv_advancemap, 41},
{IT_STRING | IT_CVAR, NULL, "Intermission Timer", &cv_inttime, 46},
@@ -1645,6 +1667,7 @@ static menuitem_t OP_ServerOptionsMenu[] =
{IT_STRING | IT_CVAR, NULL, "Autobalance sizes", &cv_autobalance, 216},
{IT_STRING | IT_CVAR, NULL, "Scramble on Map Change", &cv_scrambleonchange, 221},
+#ifndef NONET
{IT_HEADER, NULL, "Advanced", NULL, 230},
{IT_STRING | IT_CVAR | IT_CV_STRING, NULL, "Master server", &cv_masterserver, 236},
@@ -1652,6 +1675,7 @@ static menuitem_t OP_ServerOptionsMenu[] =
{IT_STRING | IT_CVAR, NULL, "Attempts to resynchronise", &cv_resynchattempts, 256},
{IT_STRING | IT_CVAR, NULL, "Show IP Address of Joiners", &cv_showjoinaddress, 261},
+#endif
};
static menuitem_t OP_MonitorToggleMenu[] =
@@ -1961,7 +1985,11 @@ menu_t MP_SplitServerDef =
MTREE2(MN_MP_MAIN, MN_MP_SPLITSCREEN),
"M_MULTI",
sizeof (MP_SplitServerMenu)/sizeof (menuitem_t),
+#ifndef NONET
&MP_MainDef,
+#else
+ &MainDef,
+#endif
MP_SplitServerMenu,
M_DrawServerMenu,
27, 30 - 50,
@@ -1969,6 +1997,8 @@ menu_t MP_SplitServerDef =
NULL
};
+#ifndef NONET
+
menu_t MP_MainDef =
{
MN_MP_MAIN,
@@ -2020,10 +2050,15 @@ menu_t MP_RoomDef =
0,
NULL
};
+#endif
menu_t MP_PlayerSetupDef =
{
+#ifdef NONET
+ MTREE2(MN_MP_MAIN, MN_MP_PLAYERSETUP),
+#else
MTREE3(MN_MP_MAIN, MN_MP_SPLITSCREEN, MN_MP_PLAYERSETUP),
+#endif
"M_SPLAYR",
sizeof (MP_PlayerSetupMenu)/sizeof (menuitem_t),
&MainDef, // doesn't matter
@@ -3973,7 +4008,9 @@ void M_Init(void)
OP_GamepadSetMenu[i].itemaction = M_AssignGamepad;
}
+#ifndef NONET
CV_RegisterVar(&cv_serversort);
+#endif
}
void M_InitCharacterTables(void)
@@ -10986,6 +11023,7 @@ static void M_EndGame(INT32 choice)
#define S_LINEY(n) currentMenu->y + SERVERHEADERHEIGHT + (n * SERVERLINEHEIGHT)
+#ifndef NONET
static UINT32 localservercount;
static void M_HandleServerPage(INT32 choice)
@@ -11257,9 +11295,11 @@ static int ServerListEntryComparator_modified(const void *entry1, const void *en
// Default to strcmp.
return strcmp(sa->info.servername, sb->info.servername);
}
+#endif
void M_SortServerList(void)
{
+#ifndef NONET
switch(cv_serversort.value)
{
case 0: // Ping.
@@ -11281,8 +11321,10 @@ void M_SortServerList(void)
qsort(serverlist, serverlistcount, sizeof(serverelem_t), ServerListEntryComparator_gametypename);
break;
}
+#endif
}
+#ifndef NONET
#ifdef UPDATE_ALERT
static boolean M_CheckMODVersion(int id)
{
@@ -11481,6 +11523,7 @@ static void M_ChooseRoom(INT32 choice)
if (currentMenu == &MP_ConnectDef)
M_Refresh(0);
}
+#endif //NONET
//===========================================================================
// Start Server Menu
@@ -11528,6 +11571,7 @@ static void M_DrawServerMenu(void)
{
M_DrawGenericMenu();
+#ifndef NONET
// Room name
if (currentMenu == &MP_ServerDef)
{
@@ -11539,10 +11583,15 @@ static void M_DrawServerMenu(void)
V_DrawRightAlignedString(BASEVIDWIDTH - currentMenu->x, currentMenu->y + MP_ServerMenu[mp_server_room].alphaKey,
V_YELLOWMAP, room_list[menuRoomIndex].name);
}
+#endif
if (cv_nextmap.value)
{
+#ifndef NONET
#define imgheight MP_ServerMenu[mp_server_levelgt].alphaKey
+#else
+#define imgheight 100
+#endif
patch_t *PictureOfLevel;
lumpnum_t lumpnum;
char headerstr[40];
@@ -11594,6 +11643,7 @@ static void M_ServerOptions(INT32 choice)
{
(void)choice;
+#ifndef NONET
if ((splitscreen && !netgame) || currentMenu == &MP_SplitServerDef)
{
OP_ServerOptionsMenu[ 1].status = IT_GRAYEDOUT; // Server name
@@ -11614,6 +11664,7 @@ static void M_ServerOptions(INT32 choice)
OP_ServerOptionsMenu[37].status = IT_STRING | IT_CVAR;
OP_ServerOptionsMenu[38].status = IT_STRING | IT_CVAR;
}
+#endif
/* Disable fading because of different menu head. */
if (currentMenu == &OP_MainDef)/* from Options menu */
@@ -11625,6 +11676,7 @@ static void M_ServerOptions(INT32 choice)
M_SetupNextMenu(&OP_ServerOptionsDef);
}
+#ifndef NONET
static void M_StartServerMenu(INT32 choice)
{
(void)choice;
@@ -11881,6 +11933,7 @@ static void M_HandleConnectIP(INT32 choice)
M_ClearMenus(true);
}
}
+#endif //!NONET
// ========================
// MULTIPLAYER PLAYER SETUP
diff --git a/src/m_menu.h b/src/m_menu.h
index 809186a17c192961a980820ffc959326e2fdbd41..8d023811d2f41c565e98c063e6debff05039df8c 100644
--- a/src/m_menu.h
+++ b/src/m_menu.h
@@ -20,7 +20,7 @@
#include "command.h"
#include "f_finale.h" // for ttmode_enum
#include "i_threads.h"
-#include "netcode/mserv.h"
+#include "mserv.h"
#include "r_things.h" // for SKINNAMESIZE
// Compatibility with old-style named NiGHTS replay files.
@@ -74,7 +74,7 @@ typedef enum
MN_MP_SERVER,
MN_MP_CONNECT,
MN_MP_ROOM,
- MN_MP_PLAYERSETUP,
+ MN_MP_PLAYERSETUP, // MP_PlayerSetupDef shared with SPLITSCREEN if #defined NONET
MN_MP_SERVER_OPTIONS,
// Options
diff --git a/src/m_perfstats.c b/src/m_perfstats.c
index cca4c62caf062b197dbdee40d38ffd15d5e14ff7..9f65a7616abfe427eaa1abd69fe16c128d559fba 100644
--- a/src/m_perfstats.c
+++ b/src/m_perfstats.c
@@ -12,7 +12,7 @@
#include "m_perfstats.h"
#include "v_video.h"
#include "i_video.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "r_main.h"
#include "i_system.h"
#include "z_zone.h"
diff --git a/src/netcode/mserv.c b/src/mserv.c
similarity index 97%
rename from src/netcode/mserv.c
rename to src/mserv.c
index f603d78e5bf28ed937916559e8f4fe2493247be7..bff562c95fb02cdfe7dab811972aad42e83f0065 100644
--- a/src/netcode/mserv.c
+++ b/src/mserv.c
@@ -15,14 +15,13 @@
#include <time.h>
#endif
-#include "../doomstat.h"
-#include "../doomdef.h"
-#include "../command.h"
-#include "../i_threads.h"
+#include "doomstat.h"
+#include "doomdef.h"
+#include "command.h"
+#include "i_threads.h"
#include "mserv.h"
-#include "client_connection.h"
-#include "../m_menu.h"
-#include "../z_zone.h"
+#include "m_menu.h"
+#include "z_zone.h"
#ifdef MASTERSERVER
@@ -46,7 +45,9 @@ static I_cond MSCond;
# define Unlock_state()
#endif/*HAVE_THREADS*/
+#ifndef NONET
static void Command_Listserv_f(void);
+#endif
#endif/*MASTERSERVER*/
@@ -88,6 +89,7 @@ msg_rooms_t room_list[NUM_LIST_ROOMS+1]; // +1 for easy test
*/
void AddMServCommands(void)
{
+#ifndef NONET
CV_RegisterVar(&cv_masterserver);
CV_RegisterVar(&cv_masterserver_update_rate);
CV_RegisterVar(&cv_masterserver_timeout);
@@ -98,6 +100,7 @@ void AddMServCommands(void)
COM_AddCommand("listserv", Command_Listserv_f);
COM_AddCommand("masterserver_update", Update_parameters); // allows people to updates manually in case you were delisted by accident
#endif
+#endif
}
#ifdef MASTERSERVER
@@ -186,6 +189,7 @@ void GetMODVersion_Console(void)
}
#endif
+#ifndef NONET
/** Gets a list of game servers. Called from console.
*/
static void Command_Listserv_f(void)
@@ -196,6 +200,7 @@ static void Command_Listserv_f(void)
HMS_list_servers();
}
}
+#endif
static void
Finish_registration (void)
diff --git a/src/netcode/mserv.h b/src/mserv.h
similarity index 99%
rename from src/netcode/mserv.h
rename to src/mserv.h
index 7fdf3ed1b90dfe1805b217f43fec9aa1edaf6ed6..23b26fbc54670fff4d5e2673dcd742c8bf0e950c 100644
--- a/src/netcode/mserv.h
+++ b/src/mserv.h
@@ -14,7 +14,7 @@
#ifndef _MSERV_H_
#define _MSERV_H_
-#include "../i_threads.h"
+#include "i_threads.h"
// lowered from 32 due to menu changes
#define NUM_LIST_ROOMS 16
diff --git a/src/netcode/Sourcefile b/src/netcode/Sourcefile
deleted file mode 100644
index 7c0354714f9c3739c9b0920b0c7db6466dcef2c3..0000000000000000000000000000000000000000
--- a/src/netcode/Sourcefile
+++ /dev/null
@@ -1,13 +0,0 @@
-d_clisrv.c
-server_connection.c
-client_connection.c
-tic_command.c
-net_command.c
-gamestate.c
-commands.c
-d_net.c
-d_netcmd.c
-d_netfil.c
-http-mserv.c
-i_tcp.c
-mserv.c
diff --git a/src/netcode/client_connection.c b/src/netcode/client_connection.c
deleted file mode 100644
index d363d7d5adf16b7201ee315f8d41bce275cfba7a..0000000000000000000000000000000000000000
--- a/src/netcode/client_connection.c
+++ /dev/null
@@ -1,1161 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file client_connection.h
-/// \brief Client connection handling
-
-#include "client_connection.h"
-#include "gamestate.h"
-#include "d_clisrv.h"
-#include "d_netfil.h"
-#include "../d_main.h"
-#include "../f_finale.h"
-#include "../g_game.h"
-#include "../i_gamepad.h"
-#include "i_net.h"
-#include "../i_system.h"
-#include "../i_time.h"
-#include "../i_video.h"
-#include "../m_menu.h"
-#include "../m_misc.h"
-#include "../snake.h"
-#include "../s_sound.h"
-#include "../v_video.h"
-#include "../y_inter.h"
-#include "../z_zone.h"
-#include "../doomtype.h"
-#include "../doomstat.h"
-
-cl_mode_t cl_mode = CL_SEARCHING;
-static UINT16 cl_lastcheckedfilecount = 0; // used for full file list
-boolean serverisfull = false; // lets us be aware if the server was full after we check files, but before downloading, so we can ask if the user still wants to download or not
-tic_t firstconnectattempttime = 0;
-UINT8 mynode;
-static void *snake = NULL;
-
-static void CL_DrawConnectionStatusBox(void)
-{
- M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-16-8, 32, 1);
- if (cl_mode != CL_CONFIRMCONNECT)
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-16, V_YELLOWMAP, "Press ESC to abort");
-}
-
-//
-// CL_DrawConnectionStatus
-//
-// Keep the local client informed of our status.
-//
-static inline void CL_DrawConnectionStatus(void)
-{
- INT32 ccstime = I_GetTime();
-
- // Draw background fade
- V_DrawFadeScreen(0xFF00, 16); // force default
-
- if (cl_mode != CL_DOWNLOADFILES && cl_mode != CL_LOADFILES)
- {
- INT32 animtime = ((ccstime / 4) & 15) + 16;
- UINT8 palstart;
- const char *cltext;
-
- // Draw the bottom box.
- CL_DrawConnectionStatusBox();
-
- if (cl_mode == CL_SEARCHING)
- palstart = 32; // Red
- else if (cl_mode == CL_CONFIRMCONNECT)
- palstart = 48; // Orange
- else
- palstart = 96; // Green
-
- if (!(cl_mode == CL_DOWNLOADSAVEGAME && lastfilenum != -1))
- for (INT32 i = 0; i < 16; ++i) // 15 pal entries total.
- V_DrawFill((BASEVIDWIDTH/2-128) + (i * 16), BASEVIDHEIGHT-16, 16, 8, palstart + ((animtime - i) & 15));
-
- switch (cl_mode)
- {
- case CL_DOWNLOADSAVEGAME:
- if (fileneeded && lastfilenum != -1)
- {
- UINT32 currentsize = fileneeded[lastfilenum].currentsize;
- UINT32 totalsize = fileneeded[lastfilenum].totalsize;
- INT32 dldlength;
-
- cltext = M_GetText("Downloading game state...");
- Net_GetNetStat();
-
- dldlength = (INT32)((currentsize/(double)totalsize) * 256);
- if (dldlength > 256)
- dldlength = 256;
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, dldlength, 8, 96);
-
- V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
- va(" %4uK/%4uK",currentsize>>10,totalsize>>10));
-
- V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
- va("%3.1fK/s ", ((double)getbps)/1024));
- }
- else
- cltext = M_GetText("Waiting to download game state...");
- break;
- case CL_ASKFULLFILELIST:
- case CL_CHECKFILES:
- cltext = M_GetText("Checking server addon list...");
- break;
- case CL_CONFIRMCONNECT:
- cltext = "";
- break;
- case CL_LOADFILES:
- cltext = M_GetText("Loading server addons...");
- break;
- case CL_ASKJOIN:
- case CL_WAITJOINRESPONSE:
- if (serverisfull)
- cltext = M_GetText("Server full, waiting for a slot...");
- else
- cltext = M_GetText("Requesting to join...");
- break;
- default:
- cltext = M_GetText("Connecting to server...");
- break;
- }
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP, cltext);
- }
- else
- {
- if (cl_mode == CL_LOADFILES)
- {
- INT32 totalfileslength;
- INT32 loadcompletednum = 0;
-
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-16, V_YELLOWMAP, "Press ESC to abort");
-
- // ima just count files here
- if (fileneeded)
- {
- for (INT32 i = 0; i < fileneedednum; i++)
- if (fileneeded[i].status == FS_OPEN)
- loadcompletednum++;
- }
-
- // Loading progress
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP, "Loading server addons...");
- totalfileslength = (INT32)((loadcompletednum/(double)(fileneedednum)) * 256);
- M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-16-8, 32, 1);
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, totalfileslength, 8, 96);
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
- va(" %2u/%2u Files",loadcompletednum,fileneedednum));
- }
- else if (lastfilenum != -1)
- {
- INT32 dldlength;
- static char tempname[28];
- fileneeded_t *file;
- char *filename;
-
- if (snake)
- Snake_Draw(snake);
-
- // Draw the bottom box.
- CL_DrawConnectionStatusBox();
-
- if (fileneeded)
- {
- file = &fileneeded[lastfilenum];
- filename = file->filename;
- }
- else
- return;
-
- Net_GetNetStat();
- dldlength = (INT32)((file->currentsize/(double)file->totalsize) * 256);
- if (dldlength > 256)
- dldlength = 256;
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, 256, 8, 111);
- V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, dldlength, 8, 96);
-
- memset(tempname, 0, sizeof(tempname));
- // offset filename to just the name only part
- filename += strlen(filename) - nameonlylength(filename);
-
- if (strlen(filename) > sizeof(tempname)-1) // too long to display fully
- {
- size_t endhalfpos = strlen(filename)-10;
- // display as first 14 chars + ... + last 10 chars
- // which should add up to 27 if our math(s) is correct
- snprintf(tempname, sizeof(tempname), "%.14s...%.10s", filename, filename+endhalfpos);
- }
- else // we can copy the whole thing in safely
- {
- strncpy(tempname, filename, sizeof(tempname)-1);
- }
-
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP,
- va(M_GetText("Downloading \"%s\""), tempname));
- V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
- va(" %4uK/%4uK",fileneeded[lastfilenum].currentsize>>10,file->totalsize>>10));
- V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-16, V_20TRANS|V_MONOSPACE,
- va("%3.1fK/s ", ((double)getbps)/1024));
- }
- else
- {
- if (snake)
- Snake_Draw(snake);
-
- CL_DrawConnectionStatusBox();
- V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-16-24, V_YELLOWMAP,
- M_GetText("Waiting to download files..."));
- }
- }
-}
-
-static boolean CL_AskFileList(INT32 firstfile)
-{
- netbuffer->packettype = PT_TELLFILESNEEDED;
- netbuffer->u.filesneedednum = firstfile;
-
- return HSendPacket(servernode, false, 0, sizeof (INT32));
-}
-
-/** Sends a PT_CLIENTJOIN packet to the server
- *
- * \return True if the packet was successfully sent
- *
- */
-boolean CL_SendJoin(void)
-{
- UINT8 localplayers = 1;
- if (netgame)
- CONS_Printf(M_GetText("Sending join request...\n"));
- netbuffer->packettype = PT_CLIENTJOIN;
-
- netbuffer->u.clientcfg.modversion = MODVERSION;
- strncpy(netbuffer->u.clientcfg.application,
- SRB2APPLICATION,
- sizeof netbuffer->u.clientcfg.application);
-
- if (splitscreen || botingame)
- localplayers++;
- netbuffer->u.clientcfg.localplayers = localplayers;
-
- CleanupPlayerName(consoleplayer, cv_playername.zstring);
- if (splitscreen)
- CleanupPlayerName(1, cv_playername2.zstring); // 1 is a HACK? oh no
-
- strncpy(netbuffer->u.clientcfg.names[0], cv_playername.zstring, MAXPLAYERNAME);
- strncpy(netbuffer->u.clientcfg.names[1], cv_playername2.zstring, MAXPLAYERNAME);
-
- return HSendPacket(servernode, true, 0, sizeof (clientconfig_pak));
-}
-
-static void SendAskInfo(INT32 node)
-{
- const tic_t asktime = I_GetTime();
- netbuffer->packettype = PT_ASKINFO;
- netbuffer->u.askinfo.version = VERSION;
- netbuffer->u.askinfo.time = (tic_t)LONG(asktime);
-
- // Even if this never arrives due to the host being firewalled, we've
- // now allowed traffic from the host to us in, so once the MS relays
- // our address to the host, it'll be able to speak to us.
- HSendPacket(node, false, 0, sizeof (askinfo_pak));
-}
-
-serverelem_t serverlist[MAXSERVERLIST];
-UINT32 serverlistcount = 0;
-
-#define FORCECLOSE 0x8000
-
-static void SL_ClearServerList(INT32 connectedserver)
-{
- for (UINT32 i = 0; i < serverlistcount; i++)
- if (connectedserver != serverlist[i].node)
- {
- Net_CloseConnection(serverlist[i].node|FORCECLOSE);
- serverlist[i].node = 0;
- }
- serverlistcount = 0;
-}
-
-static UINT32 SL_SearchServer(INT32 node)
-{
- for (UINT32 i = 0; i < serverlistcount; i++)
- if (serverlist[i].node == node)
- return i;
-
- return UINT32_MAX;
-}
-
-static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
-{
- UINT32 i;
-
- // search if not already on it
- i = SL_SearchServer(node);
- if (i == UINT32_MAX)
- {
- // not found add it
- if (serverlistcount >= MAXSERVERLIST)
- return; // list full
-
- // check it later if connecting to this one
- if (node != servernode)
- {
- if (info->_255 != 255)
- return; // Old packet format
-
- if (info->packetversion != PACKETVERSION)
- return; // Old new packet format
-
- if (info->version != VERSION)
- return; // Not same version.
-
- if (info->subversion != SUBVERSION)
- return; // Close, but no cigar.
-
- if (strcmp(info->application, SRB2APPLICATION))
- return; // That's a different mod
- }
-
- i = serverlistcount++;
- }
-
- serverlist[i].info = *info;
- serverlist[i].node = node;
-
- // resort server list
- M_SortServerList();
-}
-
-#if defined (MASTERSERVER) && defined (HAVE_THREADS)
-struct Fetch_servers_ctx
-{
- int room;
- int id;
-};
-
-static void
-Fetch_servers_thread (struct Fetch_servers_ctx *ctx)
-{
- msg_server_t *server_list;
-
- server_list = GetShortServersList(ctx->room, ctx->id);
-
- if (server_list)
- {
- I_lock_mutex(&ms_QueryId_mutex);
- {
- if (ctx->id != ms_QueryId)
- {
- free(server_list);
- server_list = NULL;
- }
- }
- I_unlock_mutex(ms_QueryId_mutex);
-
- if (server_list)
- {
- I_lock_mutex(&m_menu_mutex);
- {
- if (m_waiting_mode == M_WAITING_SERVERS)
- m_waiting_mode = M_NOT_WAITING;
- }
- I_unlock_mutex(m_menu_mutex);
-
- I_lock_mutex(&ms_ServerList_mutex);
- {
- ms_ServerList = server_list;
- }
- I_unlock_mutex(ms_ServerList_mutex);
- }
- }
-
- free(ctx);
-}
-#endif // defined (MASTERSERVER) && defined (HAVE_THREADS)
-
-void CL_QueryServerList (msg_server_t *server_list)
-{
- for (INT32 i = 0; server_list[i].header.buffer[0]; i++)
- {
- // Make sure MS version matches our own, to
- // thwart nefarious servers who lie to the MS.
-
- // lol bruh, that version COMES from the servers
- //if (strcmp(version, server_list[i].version) == 0)
- {
- INT32 node = I_NetMakeNodewPort(server_list[i].ip, server_list[i].port);
- if (node == -1)
- break; // no more node free
- SendAskInfo(node);
- // Force close the connection so that servers can't eat
- // up nodes forever if we never get a reply back from them
- // (usually when they've not forwarded their ports).
- //
- // Don't worry, we'll get in contact with the working
- // servers again when they send SERVERINFO to us later!
- //
- // (Note: as a side effect this probably means every
- // server in the list will probably be using the same node (e.g. node 1),
- // not that it matters which nodes they use when
- // the connections are closed afterwards anyway)
- // -- Monster Iestyn 12/11/18
- Net_CloseConnection(node|FORCECLOSE);
- }
- }
-}
-
-void CL_UpdateServerList(boolean internetsearch, INT32 room)
-{
- (void)internetsearch;
- (void)room;
-
- SL_ClearServerList(0);
-
- if (!netgame && I_NetOpenSocket)
- {
- if (I_NetOpenSocket())
- {
- netgame = true;
- multiplayer = true;
- }
- }
-
- // search for local servers
- if (netgame)
- SendAskInfo(BROADCASTADDR);
-
-#ifdef MASTERSERVER
- if (internetsearch)
- {
-#ifdef HAVE_THREADS
- struct Fetch_servers_ctx *ctx;
-
- ctx = malloc(sizeof *ctx);
-
- // This called from M_Refresh so I don't use a mutex
- m_waiting_mode = M_WAITING_SERVERS;
-
- I_lock_mutex(&ms_QueryId_mutex);
- {
- ctx->id = ms_QueryId;
- }
- I_unlock_mutex(ms_QueryId_mutex);
-
- ctx->room = room;
-
- I_spawn_thread("fetch-servers", (I_thread_fn)Fetch_servers_thread, ctx);
-#else
- msg_server_t *server_list;
-
- server_list = GetShortServersList(room, 0);
-
- if (server_list)
- {
- CL_QueryServerList(server_list);
- free(server_list);
- }
-#endif
- }
-#endif // MASTERSERVER
-}
-
-static void M_ConfirmConnect(event_t *ev)
-{
- if (ev->type == ev_keydown || ev->type == ev_gamepad_down)
- {
- if ((ev->type == ev_keydown && (ev->key == ' ' || ev->key == 'y' || ev->key == KEY_ENTER)) || (ev->type == ev_gamepad_down && ev->which == 0 && ev->key == GAMEPAD_BUTTON_A))
- {
- if (totalfilesrequestednum > 0)
- {
- if (CL_SendFileRequest())
- {
- cl_mode = CL_DOWNLOADFILES;
- Snake_Allocate(&snake);
- }
- }
- else
- cl_mode = CL_LOADFILES;
-
- M_ClearMenus(true);
- }
- else if ((ev->type == ev_keydown && (ev->key == 'n' || ev->key == KEY_ESCAPE)) || (ev->type == ev_gamepad_down && ev->which == 0 && ev->key == GAMEPAD_BUTTON_B))
- {
- cl_mode = CL_ABORTED;
- M_ClearMenus(true);
- }
- }
-}
-
-static boolean CL_FinishedFileList(void)
-{
- INT32 i;
- char *downloadsize = NULL;
-
- //CONS_Printf(M_GetText("Checking files...\n"));
- i = CL_CheckFiles();
- if (i == 4) // still checking ...
- {
- return true;
- }
- else if (i == 3) // too many files
- {
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText(
- "You have too many WAD files loaded\n"
- "to add ones the server is using.\n"
- "Please restart SRB2 before connecting.\n\n"
- "Press ESC\n"
- ), NULL, MM_NOTHING);
- return false;
- }
- else if (i == 2) // cannot join for some reason
- {
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText(
- "You have the wrong addons loaded.\n\n"
- "To play on this server, restart\n"
- "the game and don't load any addons.\n"
- "SRB2 will automatically add\n"
- "everything you need when you join.\n\n"
- "Press ESC\n"
- ), NULL, MM_NOTHING);
- return false;
- }
- else if (i == 1)
- {
- if (serverisfull)
- {
- M_StartMessage(M_GetText(
- "This server is full!\n"
- "\n"
- "You may load server addons (if any), and wait for a slot.\n"
- "\n"
- "Press ENTER to continue\nor ESC to cancel.\n\n"
- ), M_ConfirmConnect, MM_EVENTHANDLER);
- cl_mode = CL_CONFIRMCONNECT;
- curfadevalue = 0;
- }
- else
- cl_mode = CL_LOADFILES;
- }
- else
- {
- // must download something
- // can we, though?
- if (!CL_CheckDownloadable()) // nope!
- {
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText(
- "An error occured when trying to\n"
- "download missing addons.\n"
- "(This is almost always a problem\n"
- "with the server, not your game.)\n\n"
- "See the console or log file\n"
- "for additional details.\n\n"
- "Press ESC\n"
- ), NULL, MM_NOTHING);
- return false;
- }
-
- downloadcompletednum = 0;
- downloadcompletedsize = 0;
- totalfilesrequestednum = 0;
- totalfilesrequestedsize = 0;
-
- if (fileneeded == NULL)
- I_Error("CL_FinishedFileList: fileneeded == NULL");
-
- for (i = 0; i < fileneedednum; i++)
- if (fileneeded[i].status == FS_NOTFOUND || fileneeded[i].status == FS_MD5SUMBAD)
- {
- totalfilesrequestednum++;
- totalfilesrequestedsize += fileneeded[i].totalsize;
- }
-
- if (totalfilesrequestedsize>>20 >= 100)
- downloadsize = Z_StrDup(va("%uM",totalfilesrequestedsize>>20));
- else
- downloadsize = Z_StrDup(va("%uK",totalfilesrequestedsize>>10));
-
- if (serverisfull)
- M_StartMessage(va(M_GetText(
- "This server is full!\n"
- "Download of %s additional content\nis required to join.\n"
- "\n"
- "You may download, load server addons,\nand wait for a slot.\n"
- "\n"
- "Press ENTER to continue\nor ESC to cancel.\n"
- ), downloadsize), M_ConfirmConnect, MM_EVENTHANDLER);
- else
- M_StartMessage(va(M_GetText(
- "Download of %s additional content\nis required to join.\n"
- "\n"
- "Press ENTER to continue\nor ESC to cancel.\n"
- ), downloadsize), M_ConfirmConnect, MM_EVENTHANDLER);
-
- Z_Free(downloadsize);
- cl_mode = CL_CONFIRMCONNECT;
- curfadevalue = 0;
- }
- return true;
-}
-
-static const char * InvalidServerReason (serverinfo_pak *info)
-{
-#define EOT "\nPress ESC\n"
-
- // Magic number for new packet format
- if (info->_255 != 255)
- {
- return
- "Outdated server (version unknown).\n" EOT;
- }
-
- if (strncmp(info->application, SRB2APPLICATION, sizeof
- info->application))
- {
- return va(
- "%s cannot connect\n"
- "to %s servers.\n" EOT,
- SRB2APPLICATION,
- info->application);
- }
-
- if (
- info->packetversion != PACKETVERSION ||
- info->version != VERSION ||
- info->subversion != SUBVERSION
- ){
- return va(
- "Incompatible %s versions.\n"
- "(server version %d.%d.%d)\n" EOT,
- SRB2APPLICATION,
- info->version / 100,
- info->version % 100,
- info->subversion);
- }
-
- switch (info->refusereason)
- {
- case REFUSE_BANNED:
- return
- "You have been banned\n"
- "from the server.\n" EOT;
- case REFUSE_JOINS_DISABLED:
- return
- "The server is not accepting\n"
- "joins for the moment.\n" EOT;
- case REFUSE_SLOTS_FULL:
- return va(
- "Maximum players reached: %d\n" EOT,
- info->maxplayer);
- default:
- if (info->refusereason)
- {
- return
- "You can't join.\n"
- "I don't know why,\n"
- "but you can't join.\n" EOT;
- }
- }
-
- return NULL;
-
-#undef EOT
-}
-
-/** Called by CL_ServerConnectionTicker
- *
- * \param asksent The last time we asked the server to join. We re-ask every second in case our request got lost in transmit.
- * \return False if the connection was aborted
- * \sa CL_ServerConnectionTicker
- * \sa CL_ConnectToServer
- *
- */
-static boolean CL_ServerConnectionSearchTicker(tic_t *asksent)
-{
- INT32 i;
-
- // serverlist is updated by GetPackets
- if (serverlistcount > 0)
- {
- // This can be a response to our broadcast request
- if (servernode == -1 || servernode >= MAXNETNODES)
- {
- i = 0;
- servernode = serverlist[i].node;
- CONS_Printf(M_GetText("Found, "));
- }
- else
- {
- i = SL_SearchServer(servernode);
- if (i < 0)
- return true;
- }
-
- if (client)
- {
- serverinfo_pak *info = &serverlist[i].info;
-
- if (info->refusereason == REFUSE_SLOTS_FULL)
- serverisfull = true;
- else
- {
- const char *reason = InvalidServerReason(info);
-
- // Quit here rather than downloading files
- // and being refused later.
- if (reason)
- {
- char *message = Z_StrDup(reason);
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(message, NULL, MM_NOTHING);
- Z_Free(message);
- return false;
- }
- }
-
- D_ParseFileneeded(info->fileneedednum, info->fileneeded, 0);
-
- if (info->flags & SV_LOTSOFADDONS)
- {
- cl_mode = CL_ASKFULLFILELIST;
- cl_lastcheckedfilecount = 0;
- return true;
- }
-
- cl_mode = CL_CHECKFILES;
- }
- else
- {
- cl_mode = CL_ASKJOIN; // files need not be checked for the server.
- *asksent = 0;
- }
-
- return true;
- }
-
- // Ask the info to the server (askinfo packet)
- if (*asksent + NEWTICRATE < I_GetTime())
- {
- SendAskInfo(servernode);
- *asksent = I_GetTime();
- }
-
- return true;
-}
-
-/** Called by CL_ConnectToServer
- *
- * \param tmpsave The name of the gamestate file???
- * \param oldtic Used for knowing when to poll events and redraw
- * \param asksent ???
- * \return False if the connection was aborted
- * \sa CL_ServerConnectionSearchTicker
- * \sa CL_ConnectToServer
- *
- */
-static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic_t *asksent)
-{
- boolean waitmore;
-
- switch (cl_mode)
- {
- case CL_SEARCHING:
- if (!CL_ServerConnectionSearchTicker(asksent))
- return false;
- break;
-
- case CL_ASKFULLFILELIST:
- if (cl_lastcheckedfilecount == UINT16_MAX) // All files retrieved
- cl_mode = CL_CHECKFILES;
- else if (fileneedednum != cl_lastcheckedfilecount || I_GetTime() >= *asksent)
- {
- if (CL_AskFileList(fileneedednum))
- {
- cl_lastcheckedfilecount = fileneedednum;
- *asksent = I_GetTime() + NEWTICRATE;
- }
- }
- break;
- case CL_CHECKFILES:
- if (!CL_FinishedFileList())
- return false;
- break;
- case CL_DOWNLOADFILES:
- waitmore = false;
- for (INT32 i = 0; i < fileneedednum; i++)
- if (fileneeded[i].status == FS_DOWNLOADING
- || fileneeded[i].status == FS_REQUESTED)
- {
- waitmore = true;
- break;
- }
- if (waitmore)
- break; // exit the case
-
- Snake_Free(&snake);
-
- cl_mode = CL_LOADFILES;
- break;
- case CL_LOADFILES:
- if (CL_LoadServerFiles())
- {
- FreeFileNeeded();
- *asksent = 0; // This ensures the first join request is right away
- firstconnectattempttime = I_GetTime();
- cl_mode = CL_ASKJOIN;
- }
- break;
- case CL_ASKJOIN:
- if (firstconnectattempttime + NEWTICRATE*300 < I_GetTime() && !server)
- {
- CONS_Printf(M_GetText("5 minute wait time exceeded.\n"));
- CONS_Printf(M_GetText("Network game synchronization aborted.\n"));
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText(
- "5 minute wait time exceeded.\n"
- "You may retry connection.\n"
- "\n"
- "Press ESC\n"
- ), NULL, MM_NOTHING);
- return false;
- }
-
- // Prepare structures to save the file
- CL_PrepareDownloadSaveGame(tmpsave);
-
- if (I_GetTime() >= *asksent && CL_SendJoin())
- {
- *asksent = I_GetTime() + NEWTICRATE*3;
- cl_mode = CL_WAITJOINRESPONSE;
- }
- break;
- case CL_WAITJOINRESPONSE:
- if (I_GetTime() >= *asksent)
- {
- cl_mode = CL_ASKJOIN;
- }
- break;
- case CL_DOWNLOADSAVEGAME:
- // At this state, the first (and only) needed file is the gamestate
- if (fileneeded[0].status == FS_FOUND)
- {
- // Gamestate is now handled within CL_LoadReceivedSavegame()
- CL_LoadReceivedSavegame(false);
- cl_mode = CL_CONNECTED;
- } // don't break case continue to CL_CONNECTED
- else
- break;
-
- case CL_CONNECTED:
- case CL_CONFIRMCONNECT: //logic is handled by M_ConfirmConnect
- default:
- break;
-
- // Connection closed by cancel, timeout or refusal.
- case CL_ABORTED:
- cl_mode = CL_SEARCHING;
- return false;
- }
-
- GetPackets();
- Net_AckTicker();
-
- // Call it only once by tic
- if (*oldtic != I_GetTime())
- {
- I_OsPolling();
-
- if (cl_mode == CL_CONFIRMCONNECT)
- D_ProcessEvents(); //needed for menu system to receive inputs
- else
- {
- // my hand has been forced and I am dearly sorry for this awful hack :vomit:
- for (; eventtail != eventhead; eventtail = (eventtail+1) & (MAXEVENTS-1))
- {
- G_MapEventsToControls(&events[eventtail]);
- }
- }
-
- if (gamekeydown[KEY_ESCAPE] || gamepads[0].buttons[GAMEPAD_BUTTON_B] || cl_mode == CL_ABORTED)
- {
- CONS_Printf(M_GetText("Network game synchronization aborted.\n"));
- M_StartMessage(M_GetText("Network game synchronization aborted.\n\nPress ESC\n"), NULL, MM_NOTHING);
-
- Snake_Free(&snake);
-
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- memset(gamekeydown, 0, NUMKEYS);
- return false;
- }
- else if (cl_mode == CL_DOWNLOADFILES && snake)
- Snake_Update(snake);
-
- if (client && (cl_mode == CL_DOWNLOADFILES || cl_mode == CL_DOWNLOADSAVEGAME))
- FileReceiveTicker();
-
- *oldtic = I_GetTime();
-
- if (client && cl_mode != CL_CONNECTED && cl_mode != CL_ABORTED)
- {
- if (!snake)
- {
- F_MenuPresTicker(true); // title sky
- F_TitleScreenTicker(true);
- F_TitleScreenDrawer();
- }
- CL_DrawConnectionStatus();
-#ifdef HAVE_THREADS
- I_lock_mutex(&m_menu_mutex);
-#endif
- M_Drawer(); //Needed for drawing messageboxes on the connection screen
-#ifdef HAVE_THREADS
- I_unlock_mutex(m_menu_mutex);
-#endif
- I_UpdateNoVsync(); // page flip or blit buffer
- if (moviemode)
- M_SaveFrame();
- S_UpdateSounds();
- S_UpdateClosedCaptions();
- }
- }
- else
- {
- I_Sleep(cv_sleep.value);
- I_UpdateTime(cv_timescale.value);
- }
-
- return true;
-}
-
-#define TMPSAVENAME "$$$.sav"
-
-void CL_ConnectToServer(void)
-{
- INT32 pnumnodes, nodewaited = doomcom->numnodes, i;
- tic_t oldtic;
- tic_t asksent;
- char tmpsave[256];
-
- sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
-
- lastfilenum = -1;
-
- cl_mode = CL_SEARCHING;
-
- // Don't get a corrupt savegame error because tmpsave already exists
- if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
- I_Error("Can't delete %s\n", tmpsave);
-
- if (netgame)
- {
- if (servernode < 0 || servernode >= MAXNETNODES)
- CONS_Printf(M_GetText("Searching for a server...\n"));
- else
- CONS_Printf(M_GetText("Contacting the server...\n"));
- }
-
- if (gamestate == GS_INTERMISSION)
- Y_EndIntermission(); // clean up intermission graphics etc
-
- DEBFILE(va("waiting %d nodes\n", doomcom->numnodes));
- G_SetGamestate(GS_WAITINGPLAYERS);
- wipegamestate = GS_WAITINGPLAYERS;
-
- ClearAdminPlayers();
- pnumnodes = 1;
- oldtic = I_GetTime() - 1;
-
- asksent = (tic_t) - TICRATE;
- firstconnectattempttime = I_GetTime();
-
- i = SL_SearchServer(servernode);
-
- if (i != -1)
- {
- char *gametypestr = serverlist[i].info.gametypename;
- CONS_Printf(M_GetText("Connecting to: %s\n"), serverlist[i].info.servername);
- gametypestr[sizeof serverlist[i].info.gametypename - 1] = '\0';
- CONS_Printf(M_GetText("Gametype: %s\n"), gametypestr);
- CONS_Printf(M_GetText("Version: %d.%d.%u\n"), serverlist[i].info.version/100,
- serverlist[i].info.version%100, serverlist[i].info.subversion);
- }
- SL_ClearServerList(servernode);
-
- do
- {
- // If the connection was aborted for some reason, leave
- if (!CL_ServerConnectionTicker(tmpsave, &oldtic, &asksent))
- return;
-
- if (server)
- {
- pnumnodes = 0;
- for (i = 0; i < MAXNETNODES; i++)
- if (netnodes[i].ingame)
- pnumnodes++;
- }
- }
- while (!(cl_mode == CL_CONNECTED && (client || (server && nodewaited <= pnumnodes))));
-
- DEBFILE(va("Synchronisation Finished\n"));
-
- displayplayer = consoleplayer;
-}
-
-/** Called when a PT_SERVERINFO packet is received
- *
- * \param node The packet sender
- * \note What happens if the packet comes from a client or something like that?
- *
- */
-void PT_ServerInfo(SINT8 node)
-{
- // compute ping in ms
- const tic_t ticnow = I_GetTime();
- const tic_t ticthen = (tic_t)LONG(netbuffer->u.serverinfo.time);
- const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
- netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
- netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
- netbuffer->u.serverinfo.application
- [sizeof netbuffer->u.serverinfo.application - 1] = '\0';
- netbuffer->u.serverinfo.gametypename
- [sizeof netbuffer->u.serverinfo.gametypename - 1] = '\0';
-
- SL_InsertServer(&netbuffer->u.serverinfo, node);
-}
-
-// Helper function for packets that should only be sent by the server
-// If it is NOT from the server, bail out and close the connection!
-static boolean ServerOnly(SINT8 node)
-{
- if (node == servernode)
- return false;
-
- Net_CloseConnection(node);
- return true;
-}
-
-void PT_MoreFilesNeeded(SINT8 node)
-{
- if (server && serverrunning)
- { // But wait I thought I'm the server?
- Net_CloseConnection(node);
- return;
- }
- if (ServerOnly(node))
- return;
- if (cl_mode == CL_ASKFULLFILELIST && netbuffer->u.filesneededcfg.first == fileneedednum)
- {
- D_ParseFileneeded(netbuffer->u.filesneededcfg.num, netbuffer->u.filesneededcfg.files, netbuffer->u.filesneededcfg.first);
- if (!netbuffer->u.filesneededcfg.more)
- cl_lastcheckedfilecount = UINT16_MAX; // Got the whole file list
- }
-}
-
-// Negative response of client join request
-void PT_ServerRefuse(SINT8 node)
-{
- if (server && serverrunning)
- { // But wait I thought I'm the server?
- Net_CloseConnection(node);
- return;
- }
- if (ServerOnly(node))
- return;
- if (cl_mode == CL_WAITJOINRESPONSE)
- {
- // Save the reason so it can be displayed after quitting the netgame
- char *reason = strdup(netbuffer->u.serverrefuse.reason);
- if (!reason)
- I_Error("Out of memory!\n");
-
- if (strstr(reason, "Maximum players reached"))
- {
- serverisfull = true;
- //Special timeout for when refusing due to player cap. The client will wait 3 seconds between join requests when waiting for a slot, so we need this to be much longer
- //We set it back to the value of cv_nettimeout.value in CL_Reset
- connectiontimeout = NEWTICRATE*7;
- cl_mode = CL_ASKJOIN;
- free(reason);
- return;
- }
-
- M_StartMessage(va(M_GetText("Server refuses connection\n\nReason:\n%s"),
- reason), NULL, MM_NOTHING);
-
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
-
- free(reason);
-
- // Will be reset by caller. Signals refusal.
- cl_mode = CL_ABORTED;
- }
-}
-
-// Positive response of client join request
-void PT_ServerCFG(SINT8 node)
-{
- if (server && serverrunning && node != servernode)
- { // but wait I thought I'm the server?
- Net_CloseConnection(node);
- return;
- }
- if (ServerOnly(node))
- return;
- /// \note how would this happen? and is it doing the right thing if it does?
- if (cl_mode != CL_WAITJOINRESPONSE)
- return;
-
- if (client)
- {
- maketic = gametic = neededtic = (tic_t)LONG(netbuffer->u.servercfg.gametic);
- G_SetGametype(netbuffer->u.servercfg.gametype);
- modifiedgame = netbuffer->u.servercfg.modifiedgame;
- memcpy(server_context, netbuffer->u.servercfg.server_context, 8);
- }
-
- netnodes[(UINT8)servernode].ingame = true;
- serverplayer = netbuffer->u.servercfg.serverplayer;
- doomcom->numslots = SHORT(netbuffer->u.servercfg.totalslotnum);
- mynode = netbuffer->u.servercfg.clientnode;
- if (serverplayer >= 0)
- playernode[(UINT8)serverplayer] = servernode;
-
- if (netgame)
- CONS_Printf(M_GetText("Join accepted, waiting for complete game state...\n"));
- DEBFILE(va("Server accept join gametic=%u mynode=%d\n", gametic, mynode));
-
- /// \note Wait. What if a Lua script uses some global custom variables synched with the NetVars hook?
- /// Shouldn't they be downloaded even at intermission time?
- /// Also, according to PT_ClientJoin, the server will send the savegame even during intermission...
- if (netbuffer->u.servercfg.gamestate == GS_LEVEL/* ||
- netbuffer->u.servercfg.gamestate == GS_INTERMISSION*/)
- cl_mode = CL_DOWNLOADSAVEGAME;
- else
- cl_mode = CL_CONNECTED;
-}
diff --git a/src/netcode/client_connection.h b/src/netcode/client_connection.h
deleted file mode 100644
index 74cff61fff518caf4d1a79776b4aa7ca94234cfd..0000000000000000000000000000000000000000
--- a/src/netcode/client_connection.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file client_connection.h
-/// \brief Client connection handling
-
-#ifndef __D_CLIENT_CONNECTION__
-#define __D_CLIENT_CONNECTION__
-
-#include "../doomtype.h"
-#include "d_clisrv.h"
-
-#define MAXSERVERLIST (MAXNETNODES-1)
-
-typedef struct
-{
- SINT8 node;
- serverinfo_pak info;
-} serverelem_t;
-
-typedef enum
-{
- CL_SEARCHING,
- CL_CHECKFILES,
- CL_DOWNLOADFILES,
- CL_ASKJOIN,
- CL_LOADFILES,
- CL_WAITJOINRESPONSE,
- CL_DOWNLOADSAVEGAME,
- CL_CONNECTED,
- CL_ABORTED,
- CL_ASKFULLFILELIST,
- CL_CONFIRMCONNECT
-} cl_mode_t;
-
-extern serverelem_t serverlist[MAXSERVERLIST];
-extern UINT32 serverlistcount;
-
-extern cl_mode_t cl_mode;
-extern boolean serverisfull; //lets us be aware if the server was full after we check files, but before downloading, so we can ask if the user still wants to download or not
-extern tic_t firstconnectattempttime;
-extern UINT8 mynode; // my address pointofview server
-
-void CL_QueryServerList(msg_server_t *list);
-void CL_UpdateServerList(boolean internetsearch, INT32 room);
-
-void CL_ConnectToServer(void);
-boolean CL_SendJoin(void);
-
-void PT_ServerInfo(SINT8 node);
-void PT_MoreFilesNeeded(SINT8 node);
-void PT_ServerRefuse(SINT8 node);
-void PT_ServerCFG(SINT8 node);
-
-#endif
diff --git a/src/netcode/commands.c b/src/netcode/commands.c
deleted file mode 100644
index 4d9a48b6bc488e27be3e2f2499d5f3c65fe5685b..0000000000000000000000000000000000000000
--- a/src/netcode/commands.c
+++ /dev/null
@@ -1,484 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file commands.c
-/// \brief Various netgame commands, such as kick and ban
-
-#include "commands.h"
-#include "d_clisrv.h"
-#include "client_connection.h"
-#include "net_command.h"
-#include "d_netcmd.h"
-#include "d_net.h"
-#include "i_net.h"
-#include "protocol.h"
-#include "../byteptr.h"
-#include "../d_main.h"
-#include "../g_game.h"
-#include "../w_wad.h"
-#include "../z_zone.h"
-#include "../doomstat.h"
-#include "../doomdef.h"
-#include "../r_local.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <string.h>
-
-typedef struct banreason_s
-{
- char *reason;
- struct banreason_s *prev; //-1
- struct banreason_s *next; //+1
-} banreason_t;
-
-static banreason_t *reasontail = NULL; //last entry, use prev
-static banreason_t *reasonhead = NULL; //1st entry, use next
-
-void Ban_Add(const char *reason)
-{
- banreason_t *reasonlist = malloc(sizeof(*reasonlist));
-
- if (!reasonlist)
- return;
- if (!reason)
- reason = "NA";
-
- reasonlist->next = NULL;
- reasonlist->reason = Z_StrDup(reason);
- if ((reasonlist->prev = reasontail) == NULL)
- reasonhead = reasonlist;
- else
- reasontail->next = reasonlist;
- reasontail = reasonlist;
-}
-
-static void Ban_Clear(void)
-{
- banreason_t *temp;
-
- I_ClearBans();
-
- reasontail = NULL;
-
- while (reasonhead)
- {
- temp = reasonhead->next;
- Z_Free(reasonhead->reason);
- free(reasonhead);
- reasonhead = temp;
- }
-}
-
-void Ban_Load_File(boolean warning)
-{
- FILE *f;
- const char *address, *mask;
- char buffer[MAX_WADPATH];
-
- if (!I_ClearBans)
- return;
-
- f = fopen(va("%s"PATHSEP"%s", srb2home, "ban.txt"), "r");
-
- if (!f)
- {
- if (warning)
- CONS_Alert(CONS_WARNING, M_GetText("Could not open ban.txt for ban list\n"));
- return;
- }
-
- Ban_Clear();
-
- for (size_t i=0; fgets(buffer, (int)sizeof(buffer), f); i++)
- {
- address = strtok(buffer, " \t\r\n");
- mask = strtok(NULL, " \t\r\n");
-
- I_SetBanAddress(address, mask);
-
- Ban_Add(strtok(NULL, "\r\n"));
- }
-
- fclose(f);
-}
-
-void D_SaveBan(void)
-{
- FILE *f;
- banreason_t *reasonlist = reasonhead;
- const char *address, *mask;
- const char *path = va("%s"PATHSEP"%s", srb2home, "ban.txt");
-
- if (!reasonhead)
- {
- remove(path);
- return;
- }
-
- f = fopen(path, "w");
-
- if (!f)
- {
- CONS_Alert(CONS_WARNING, M_GetText("Could not save ban list into ban.txt\n"));
- return;
- }
-
- for (size_t i = 0;(address = I_GetBanAddress(i)) != NULL;i++)
- {
- if (!I_GetBanMask || (mask = I_GetBanMask(i)) == NULL)
- fprintf(f, "%s 0", address);
- else
- fprintf(f, "%s %s", address, mask);
-
- if (reasonlist && reasonlist->reason)
- fprintf(f, " %s\n", reasonlist->reason);
- else
- fprintf(f, " %s\n", "NA");
-
- if (reasonlist) reasonlist = reasonlist->next;
- }
-
- fclose(f);
-}
-
-void Command_ShowBan(void) //Print out ban list
-{
- size_t i;
- const char *address, *mask;
- banreason_t *reasonlist = reasonhead;
-
- if (I_GetBanAddress)
- CONS_Printf(M_GetText("Ban List:\n"));
- else
- return;
-
- for (i = 0;(address = I_GetBanAddress(i)) != NULL;i++)
- {
- if (!I_GetBanMask || (mask = I_GetBanMask(i)) == NULL)
- CONS_Printf("%s: %s ", sizeu1(i+1), address);
- else
- CONS_Printf("%s: %s/%s ", sizeu1(i+1), address, mask);
-
- if (reasonlist && reasonlist->reason)
- CONS_Printf("(%s)\n", reasonlist->reason);
- else
- CONS_Printf("\n");
-
- if (reasonlist) reasonlist = reasonlist->next;
- }
-
- if (i == 0 && !address)
- CONS_Printf(M_GetText("(empty)\n"));
-}
-
-void Command_ClearBans(void)
-{
- if (!I_ClearBans)
- return;
-
- Ban_Clear();
- D_SaveBan();
-}
-
-void Command_Ban(void)
-{
- if (COM_Argc() < 2)
- {
- CONS_Printf(M_GetText("Ban <playername/playernum> <reason>: ban and kick a player\n"));
- return;
- }
-
- if (!netgame) // Don't kick Tails in splitscreen!
- {
- CONS_Printf(M_GetText("This only works in a netgame.\n"));
- return;
- }
-
- if (server || IsPlayerAdmin(consoleplayer))
- {
- UINT8 buf[3 + MAX_REASONLENGTH];
- UINT8 *p = buf;
- const SINT8 pn = nametonum(COM_Argv(1));
- const INT32 node = playernode[(INT32)pn];
-
- if (pn == -1 || pn == 0)
- return;
-
- WRITEUINT8(p, pn);
-
- if (server && I_Ban && !I_Ban(node)) // only the server is allowed to do this right now
- {
- CONS_Alert(CONS_WARNING, M_GetText("Too many bans! Geez, that's a lot of people you're excluding...\n"));
- WRITEUINT8(p, KICK_MSG_GO_AWAY);
- SendNetXCmd(XD_KICK, &buf, 2);
- }
- else
- {
- if (server) // only the server is allowed to do this right now
- {
- Ban_Add(COM_Argv(2));
- D_SaveBan(); // save the ban list
- }
-
- if (COM_Argc() == 2)
- {
- WRITEUINT8(p, KICK_MSG_BANNED);
- SendNetXCmd(XD_KICK, &buf, 2);
- }
- else
- {
- size_t j = COM_Argc();
- char message[MAX_REASONLENGTH];
-
- //Steal from the motd code so you don't have to put the reason in quotes.
- strlcpy(message, COM_Argv(2), sizeof message);
- for (size_t i = 3; i < j; i++)
- {
- strlcat(message, " ", sizeof message);
- strlcat(message, COM_Argv(i), sizeof message);
- }
-
- WRITEUINT8(p, KICK_MSG_CUSTOM_BAN);
- WRITESTRINGN(p, message, MAX_REASONLENGTH);
- SendNetXCmd(XD_KICK, &buf, p - buf);
- }
- }
- }
- else
- CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
-
-}
-
-void Command_BanIP(void)
-{
- if (COM_Argc() < 2)
- {
- CONS_Printf(M_GetText("banip <ip> <reason>: ban an ip address\n"));
- return;
- }
-
- if (server) // Only the server can use this, otherwise does nothing.
- {
- const char *address = (COM_Argv(1));
- const char *reason;
-
- if (COM_Argc() == 2)
- reason = NULL;
- else
- reason = COM_Argv(2);
-
-
- if (I_SetBanAddress && I_SetBanAddress(address, NULL))
- {
- if (reason)
- CONS_Printf("Banned IP address %s for: %s\n", address, reason);
- else
- CONS_Printf("Banned IP address %s\n", address);
-
- Ban_Add(reason);
- D_SaveBan();
- }
- else
- {
- return;
- }
- }
-}
-
-void Command_ReloadBan(void) //recheck ban.txt
-{
- Ban_Load_File(true);
-}
-
-void Command_Kick(void)
-{
- if (COM_Argc() < 2)
- {
- CONS_Printf(M_GetText("kick <playername/playernum> <reason>: kick a player\n"));
- return;
- }
-
- if (!netgame) // Don't kick Tails in splitscreen!
- {
- CONS_Printf(M_GetText("This only works in a netgame.\n"));
- return;
- }
-
- if (server || IsPlayerAdmin(consoleplayer))
- {
- UINT8 buf[3 + MAX_REASONLENGTH];
- UINT8 *p = buf;
- const SINT8 pn = nametonum(COM_Argv(1));
-
- if (pn == -1 || pn == 0)
- return;
-
- // Special case if we are trying to kick a player who is downloading the game state:
- // trigger a timeout instead of kicking them, because a kick would only
- // take effect after they have finished downloading
- if (server && playernode[pn] != UINT8_MAX && netnodes[playernode[pn]].sendingsavegame)
- {
- Net_ConnectionTimeout(playernode[pn]);
- return;
- }
-
- WRITESINT8(p, pn);
-
- if (COM_Argc() == 2)
- {
- WRITEUINT8(p, KICK_MSG_GO_AWAY);
- SendNetXCmd(XD_KICK, &buf, 2);
- }
- else
- {
- size_t j = COM_Argc();
- char message[MAX_REASONLENGTH];
-
- //Steal from the motd code so you don't have to put the reason in quotes.
- strlcpy(message, COM_Argv(2), sizeof message);
- for (size_t i = 3; i < j; i++)
- {
- strlcat(message, " ", sizeof message);
- strlcat(message, COM_Argv(i), sizeof message);
- }
-
- WRITEUINT8(p, KICK_MSG_CUSTOM_KICK);
- WRITESTRINGN(p, message, MAX_REASONLENGTH);
- SendNetXCmd(XD_KICK, &buf, p - buf);
- }
- }
- else
- CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
-}
-
-void Command_connect(void)
-{
- if (COM_Argc() < 2 || *COM_Argv(1) == 0)
- {
- CONS_Printf(M_GetText(
- "Connect <serveraddress> (port): connect to a server\n"
- "Connect ANY: connect to the first lan server found\n"
- //"Connect SELF: connect to your own server.\n"
- ));
- return;
- }
-
- if (Playing() || titledemo)
- {
- CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
- return;
- }
-
- server = false;
-/*
- if (!stricmp(COM_Argv(1), "self"))
- {
- servernode = 0;
- server = true;
- /// \bug should be but...
- //SV_SpawnServer();
- }
- else
-*/
- {
- // used in menu to connect to a server in the list
- if (netgame && !stricmp(COM_Argv(1), "node"))
- {
- servernode = (SINT8)atoi(COM_Argv(2));
- }
- else if (netgame)
- {
- CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
- return;
- }
- else if (I_NetOpenSocket)
- {
- I_NetOpenSocket();
- netgame = true;
- multiplayer = true;
-
- if (!stricmp(COM_Argv(1), "any"))
- servernode = BROADCASTADDR;
- else if (I_NetMakeNodewPort)
- {
- if (COM_Argc() >= 3) // address AND port
- servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
- else // address only, or address:port
- servernode = I_NetMakeNode(COM_Argv(1));
- }
- else
- {
- CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
- D_CloseConnection();
- return;
- }
- }
- else
- CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
- }
-
- splitscreen = false;
- SplitScreen_OnChange();
- botingame = false;
- botskin = 0;
- CL_ConnectToServer();
-}
-
-void Command_GetPlayerNum(void)
-{
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i])
- {
- if (serverplayer == i)
- CONS_Printf(M_GetText("num:%2d node:%2d %s\n"), i, playernode[i], player_names[i]);
- else
- CONS_Printf(M_GetText("\x82num:%2d node:%2d %s\n"), i, playernode[i], player_names[i]);
- }
-}
-
-/** Lists all players and their player numbers.
- *
- * \sa Command_GetPlayerNum
- */
-void Command_Nodes(void)
-{
- size_t maxlen = 0;
- const char *address;
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- const size_t plen = strlen(player_names[i]);
- if (playeringame[i] && plen > maxlen)
- maxlen = plen;
- }
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (playeringame[i])
- {
- CONS_Printf("%.2u: %*s", i, (int)maxlen, player_names[i]);
-
- if (playernode[i] != UINT8_MAX)
- {
- CONS_Printf(" - node %.2d", playernode[i]);
- if (I_GetNodeAddress && (address = I_GetNodeAddress(playernode[i])) != NULL)
- CONS_Printf(" - %s", address);
- }
-
- if (IsPlayerAdmin(i))
- CONS_Printf(M_GetText(" (verified admin)"));
-
- if (players[i].spectator)
- CONS_Printf(M_GetText(" (spectator)"));
-
- CONS_Printf("\n");
- }
- }
-}
diff --git a/src/netcode/commands.h b/src/netcode/commands.h
deleted file mode 100644
index 5ff4d1cae6d0455fe459b09fba7d38ab91e7a0d7..0000000000000000000000000000000000000000
--- a/src/netcode/commands.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file commands.h
-/// \brief Various netgame commands, such as kick and ban
-
-#ifndef __COMMANDS__
-#define __COMMANDS__
-
-#include "../doomdef.h"
-
-#define MAX_REASONLENGTH 30
-
-void Ban_Add(const char *reason);
-void D_SaveBan(void);
-void Ban_Load_File(boolean warning);
-void Command_ShowBan(void);
-void Command_ClearBans(void);
-void Command_Ban(void);
-void Command_BanIP(void);
-void Command_ReloadBan(void);
-void Command_Kick(void);
-void Command_connect(void);
-void Command_GetPlayerNum(void);
-void Command_Nodes(void);
-
-#endif
diff --git a/src/netcode/d_clisrv.c b/src/netcode/d_clisrv.c
deleted file mode 100644
index 18eae580cd0817f6407d205460b7ecdfc17cdce2..0000000000000000000000000000000000000000
--- a/src/netcode/d_clisrv.c
+++ /dev/null
@@ -1,1564 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file d_clisrv.c
-/// \brief SRB2 Network game communication and protocol, all OS independent parts.
-
-#include <time.h>
-#ifdef __GNUC__
-#include <unistd.h> //for unlink
-#endif
-
-#include "../i_time.h"
-#include "i_net.h"
-#include "../i_system.h"
-#include "../i_video.h"
-#include "d_net.h"
-#include "../d_main.h"
-#include "../g_game.h"
-#include "../st_stuff.h"
-#include "../hu_stuff.h"
-#include "../keys.h"
-#include "../g_input.h"
-#include "../i_gamepad.h"
-#include "../m_menu.h"
-#include "../console.h"
-#include "d_netfil.h"
-#include "../byteptr.h"
-#include "../p_saveg.h"
-#include "../z_zone.h"
-#include "../p_local.h"
-#include "../p_haptic.h"
-#include "../m_misc.h"
-#include "../am_map.h"
-#include "../m_random.h"
-#include "mserv.h"
-#include "../y_inter.h"
-#include "../r_local.h"
-#include "../m_argv.h"
-#include "../p_setup.h"
-#include "../lzf.h"
-#include "../lua_script.h"
-#include "../lua_hook.h"
-#include "../lua_libs.h"
-#include "../md5.h"
-#include "../m_perfstats.h"
-#include "server_connection.h"
-#include "client_connection.h"
-#include "tic_command.h"
-#include "net_command.h"
-#include "gamestate.h"
-#include "commands.h"
-#include "protocol.h"
-
-//
-// NETWORKING
-//
-// gametic is the tic about to (or currently being) run
-// Server:
-// maketic is the tic that hasn't had control made for it yet
-// nettics is the tic for each node
-// firstticstosend is the lowest value of nettics
-// Client:
-// neededtic is the tic needed by the client to run the game
-// firstticstosend is used to optimize a condition
-// Normally maketic >= gametic > 0
-
-boolean server = true; // true or false but !server == client
-boolean serverrunning = false;
-INT32 serverplayer = 0;
-char motd[254], server_context[8]; // Message of the Day, Unique Context (even without Mumble support)
-
-netnode_t netnodes[MAXNETNODES];
-
-// Server specific vars
-UINT8 playernode[MAXPLAYERS];
-
-UINT16 pingmeasurecount = 1;
-UINT32 realpingtable[MAXPLAYERS]; //the base table of ping where an average will be sent to everyone.
-UINT32 playerpingtable[MAXPLAYERS]; //table of player latency values.
-static INT32 pingtimeout[MAXPLAYERS];
-tic_t servermaxping = 800; // server's max ping. Defaults to 800
-
-tic_t maketic;
-
-INT16 consistancy[BACKUPTICS];
-
-// true when a player is connecting or disconnecting so that the gameplay has stopped in its tracks
-boolean hu_stopped = false;
-
-UINT8 adminpassmd5[16];
-boolean adminpasswordset = false;
-
-tic_t neededtic;
-SINT8 servernode = 0; // the number of the server node
-
-boolean acceptnewnode = true;
-
-UINT16 software_MAXPACKETLENGTH;
-
-static CV_PossibleValue_t netticbuffer_cons_t[] = {{0, "MIN"}, {3, "MAX"}, {0, NULL}};
-consvar_t cv_netticbuffer = CVAR_INIT ("netticbuffer", "1", CV_SAVE, netticbuffer_cons_t, NULL);
-
-static CV_PossibleValue_t resynchattempts_cons_t[] = {{1, "MIN"}, {20, "MAX"}, {0, "No"}, {0, NULL}};
-consvar_t cv_resynchattempts = CVAR_INIT ("resynchattempts", "10", CV_SAVE|CV_NETVAR, resynchattempts_cons_t, NULL);
-
-consvar_t cv_blamecfail = CVAR_INIT ("blamecfail", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
-
-static CV_PossibleValue_t playbackspeed_cons_t[] = {{1, "MIN"}, {10, "MAX"}, {0, NULL}};
-consvar_t cv_playbackspeed = CVAR_INIT ("playbackspeed", "1", 0, playbackspeed_cons_t, NULL);
-
-void ResetNode(INT32 node)
-{
- memset(&netnodes[node], 0, sizeof(*netnodes));
- netnodes[node].player = -1;
- netnodes[node].player2 = -1;
-}
-
-void CL_Reset(void)
-{
- if (metalrecording)
- G_StopMetalRecording(false);
- if (metalplayback)
- G_StopMetalDemo();
- if (demorecording)
- G_CheckDemoStatus();
-
- // reset client/server code
- DEBFILE(va("\n-=-=-=-=-=-=-= Client reset =-=-=-=-=-=-=-\n\n"));
-
- if (servernode > 0 && servernode < MAXNETNODES)
- {
- netnodes[(UINT8)servernode].ingame = false;
- Net_CloseConnection(servernode);
- }
- D_CloseConnection(); // netgame = false
- multiplayer = false;
- servernode = 0;
- server = true;
- doomcom->numnodes = 1;
- doomcom->numslots = 1;
- SV_StopServer();
- SV_ResetServer();
-
- // make sure we don't leave any fileneeded gunk over from a failed join
- FreeFileNeeded();
- fileneedednum = 0;
-
- totalfilesrequestednum = 0;
- totalfilesrequestedsize = 0;
- firstconnectattempttime = 0;
- serverisfull = false;
- connectiontimeout = (tic_t)cv_nettimeout.value; //reset this temporary hack
-
- // D_StartTitle should get done now, but the calling function will handle it
-}
-
-//
-// CL_ClearPlayer
-//
-// Clears the player data so that a future client can use this slot
-//
-void CL_ClearPlayer(INT32 playernum)
-{
- if (players[playernum].mo)
- P_RemoveMobj(players[playernum].mo);
- memset(&players[playernum], 0, sizeof (player_t));
- memset(playeraddress[playernum], 0, sizeof(*playeraddress));
-}
-
-// Xcmd XD_ADDPLAYER
-static void Got_AddPlayer(UINT8 **p, INT32 playernum)
-{
- INT16 node, newplayernum;
- boolean splitscreenplayer;
- boolean rejoined;
- player_t *newplayer;
-
- if (playernum != serverplayer && !IsPlayerAdmin(playernum))
- {
- // protect against hacked/buggy client
- CONS_Alert(CONS_WARNING, M_GetText("Illegal add player command received from %s\n"), player_names[playernum]);
- if (server)
- SendKick(playernum, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
- return;
- }
-
- node = READUINT8(*p);
- newplayernum = READUINT8(*p);
- splitscreenplayer = newplayernum & 0x80;
- newplayernum &= ~0x80;
-
- rejoined = playeringame[newplayernum];
-
- if (!rejoined)
- {
- // Clear player before joining, lest some things get set incorrectly
- // HACK: don't do this for splitscreen, it relies on preset values
- if (!splitscreen && !botingame)
- CL_ClearPlayer(newplayernum);
- playeringame[newplayernum] = true;
- G_AddPlayer(newplayernum);
- if (newplayernum+1 > doomcom->numslots)
- doomcom->numslots = (INT16)(newplayernum+1);
-
- if (server && I_GetNodeAddress)
- {
- const char *address = I_GetNodeAddress(node);
- char *port = NULL;
- if (address) // MI: fix msvcrt.dll!_mbscat crash?
- {
- strcpy(playeraddress[newplayernum], address);
- port = strchr(playeraddress[newplayernum], ':');
- if (port)
- *port = '\0';
- }
- }
- }
-
- newplayer = &players[newplayernum];
-
- newplayer->jointime = 0;
- newplayer->quittime = 0;
-
- READSTRINGN(*p, player_names[newplayernum], MAXPLAYERNAME);
-
- // the server is creating my player
- if (node == mynode)
- {
- playernode[newplayernum] = 0; // for information only
- if (!splitscreenplayer)
- {
- consoleplayer = newplayernum;
- displayplayer = newplayernum;
- secondarydisplayplayer = newplayernum;
- DEBFILE("spawning me\n");
- ticcmd_oldangleturn[0] = newplayer->oldrelangleturn;
- }
- else
- {
- secondarydisplayplayer = newplayernum;
- DEBFILE("spawning my brother\n");
- if (botingame)
- newplayer->bot = 1;
- ticcmd_oldangleturn[1] = newplayer->oldrelangleturn;
- }
- P_ForceLocalAngle(newplayer, (angle_t)(newplayer->angleturn << 16));
- D_SendPlayerConfig();
- addedtogame = true;
-
- if (rejoined)
- {
- if (newplayer->mo)
- {
- newplayer->viewheight = 41*newplayer->height/48;
-
- if (newplayer->mo->eflags & MFE_VERTICALFLIP)
- newplayer->viewz = newplayer->mo->z + newplayer->mo->height - newplayer->viewheight;
- else
- newplayer->viewz = newplayer->mo->z + newplayer->viewheight;
- }
-
- // wake up the status bar
- ST_Start();
- // wake up the heads up text
- HU_Start();
-
- if (camera.chase && !splitscreenplayer)
- P_ResetCamera(newplayer, &camera);
- if (camera2.chase && splitscreenplayer)
- P_ResetCamera(newplayer, &camera2);
- }
- }
-
- if (netgame)
- {
- char joinmsg[256];
-
- if (rejoined)
- strcpy(joinmsg, M_GetText("\x82*%s has rejoined the game (player %d)"));
- else
- strcpy(joinmsg, M_GetText("\x82*%s has joined the game (player %d)"));
- strcpy(joinmsg, va(joinmsg, player_names[newplayernum], newplayernum));
-
- // Merge join notification + IP to avoid clogging console/chat
- if (server && cv_showjoinaddress.value && I_GetNodeAddress)
- {
- const char *address = I_GetNodeAddress(node);
- if (address)
- strcat(joinmsg, va(" (%s)", address));
- }
-
- HU_AddChatText(joinmsg, false);
- }
-
- if (server && multiplayer && motd[0] != '\0')
- COM_BufAddText(va("sayto %d %s\n", newplayernum, motd));
-
- if (!rejoined)
- LUA_HookInt(newplayernum, HOOK(PlayerJoin));
-}
-
-static void UnlinkPlayerFromNode(INT32 playernum)
-{
- INT32 node = playernode[playernum];
-
- if (node == UINT8_MAX)
- return;
-
- playernode[playernum] = UINT8_MAX;
-
- netnodes[node].numplayers--;
- if (netnodes[node].numplayers <= 0)
- {
- netnodes[node].ingame = false;
- Net_CloseConnection(node);
- ResetNode(node);
- }
-}
-
-static void PT_ClientQuit(SINT8 node, INT32 netconsole)
-{
- if (client)
- return;
-
- if (netnodes[node].ingame && netconsole != -1 && playeringame[netconsole])
- SendKicksForNode(node, KICK_MSG_PLAYER_QUIT | KICK_MSG_KEEP_BODY);
-
- Net_CloseConnection(node);
- netnodes[node].ingame = false;
- netnodes[node].player = -1;
- netnodes[node].player2 = -1;
-}
-
-static void Got_KickCmd(UINT8 **p, INT32 playernum)
-{
- INT32 pnum, msg;
- char buf[3 + MAX_REASONLENGTH];
- char *reason = buf;
- kickreason_t kickreason = KR_KICK;
- boolean keepbody;
-
- pnum = READUINT8(*p);
- msg = READUINT8(*p);
- keepbody = (msg & KICK_MSG_KEEP_BODY) != 0;
- msg &= ~KICK_MSG_KEEP_BODY;
-
- if (pnum == serverplayer && IsPlayerAdmin(playernum))
- {
- CONS_Printf(M_GetText("Server is being shut down remotely. Goodbye!\n"));
-
- if (server)
- COM_BufAddText("quit\n");
-
- return;
- }
-
- // Is playernum authorized to make this kick?
- if (playernum != serverplayer && !IsPlayerAdmin(playernum)
- && !(playernode[playernum] != UINT8_MAX && netnodes[playernode[playernum]].numplayers == 2
- && netnodes[playernode[playernum]].player2 == pnum))
- {
- // We received a kick command from someone who isn't the
- // server or admin, and who isn't in splitscreen removing
- // player 2. Thus, it must be someone with a modified
- // binary, trying to kick someone but without having
- // authorization.
-
- // We deal with this by changing the kick reason to
- // "consistency failure" and kicking the offending user
- // instead.
-
- // Note: Splitscreen in netgames is broken because of
- // this. Only the server has any idea of which players
- // are using splitscreen on the same computer, so
- // clients cannot always determine if a kick is
- // legitimate.
-
- CONS_Alert(CONS_WARNING, M_GetText("Illegal kick command received from %s for player %d\n"), player_names[playernum], pnum);
-
- // In debug, print a longer message with more details.
- // TODO Callum: Should we translate this?
-/*
- CONS_Debug(DBG_NETPLAY,
- "So, you must be asking, why is this an illegal kick?\n"
- "Well, let's take a look at the facts, shall we?\n"
- "\n"
- "playernum (this is the guy who did it), he's %d.\n"
- "pnum (the guy he's trying to kick) is %d.\n"
- "playernum's node is %d.\n"
- "That node has %d players.\n"
- "Player 2 on that node is %d.\n"
- "pnum's node is %d.\n"
- "That node has %d players.\n"
- "Player 2 on that node is %d.\n"
- "\n"
- "If you think this is a bug, please report it, including all of the details above.\n",
- playernum, pnum,
- playernode[playernum], netnodes[playernode[playernum]].numplayers,
- netnodes[playernode[playernum]].player2,
- playernode[pnum], netnodes[playernode[pnum]].numplayers,
- netnodes[playernode[pnum]].player2);
-*/
- pnum = playernum;
- msg = KICK_MSG_CON_FAIL;
- keepbody = true;
- }
-
- //CONS_Printf("\x82%s ", player_names[pnum]);
-
- // If a verified admin banned someone, the server needs to know about it.
- // If the playernum isn't zero (the server) then the server needs to record the ban.
- if (server && playernum && (msg == KICK_MSG_BANNED || msg == KICK_MSG_CUSTOM_BAN))
- {
- if (I_Ban && !I_Ban(playernode[(INT32)pnum]))
- CONS_Alert(CONS_WARNING, M_GetText("Too many bans! Geez, that's a lot of people you're excluding...\n"));
- else
- Ban_Add(reason);
- }
-
- switch (msg)
- {
- case KICK_MSG_GO_AWAY:
- if (!players[pnum].quittime)
- HU_AddChatText(va("\x82*%s has been kicked (No reason given)", player_names[pnum]), false);
- kickreason = KR_KICK;
- break;
- case KICK_MSG_PING_HIGH:
- HU_AddChatText(va("\x82*%s left the game (Broke ping limit)", player_names[pnum]), false);
- kickreason = KR_PINGLIMIT;
- break;
- case KICK_MSG_CON_FAIL:
- HU_AddChatText(va("\x82*%s left the game (Synch failure)", player_names[pnum]), false);
- kickreason = KR_SYNCH;
-
- if (M_CheckParm("-consisdump")) // Helps debugging some problems
- {
- CONS_Printf(M_GetText("Player kicked is #%d, dumping consistency...\n"), pnum);
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (!playeringame[i])
- continue;
- CONS_Printf("-------------------------------------\n");
- CONS_Printf("Player %d: %s\n", i, player_names[i]);
- CONS_Printf("Skin: %d\n", players[i].skin);
- CONS_Printf("Color: %d\n", players[i].skincolor);
- CONS_Printf("Speed: %d\n",players[i].speed>>FRACBITS);
- if (players[i].mo)
- {
- if (!players[i].mo->skin)
- CONS_Printf("Mobj skin: NULL!\n");
- else
- CONS_Printf("Mobj skin: %s\n", ((skin_t *)players[i].mo->skin)->name);
- CONS_Printf("Position: %d, %d, %d\n", players[i].mo->x, players[i].mo->y, players[i].mo->z);
- if (!players[i].mo->state)
- CONS_Printf("State: S_NULL\n");
- else
- CONS_Printf("State: %d\n", (statenum_t)(players[i].mo->state-states));
- }
- else
- CONS_Printf("Mobj: NULL\n");
- CONS_Printf("-------------------------------------\n");
- }
- }
- break;
- case KICK_MSG_TIMEOUT:
- HU_AddChatText(va("\x82*%s left the game (Connection timeout)", player_names[pnum]), false);
- kickreason = KR_TIMEOUT;
- break;
- case KICK_MSG_PLAYER_QUIT:
- if (netgame && !players[pnum].quittime) // not splitscreen/bots or soulless body
- HU_AddChatText(va("\x82*%s left the game", player_names[pnum]), false);
- kickreason = KR_LEAVE;
- break;
- case KICK_MSG_BANNED:
- HU_AddChatText(va("\x82*%s has been banned (No reason given)", player_names[pnum]), false);
- kickreason = KR_BAN;
- break;
- case KICK_MSG_CUSTOM_KICK:
- READSTRINGN(*p, reason, MAX_REASONLENGTH+1);
- HU_AddChatText(va("\x82*%s has been kicked (%s)", player_names[pnum], reason), false);
- kickreason = KR_KICK;
- break;
- case KICK_MSG_CUSTOM_BAN:
- READSTRINGN(*p, reason, MAX_REASONLENGTH+1);
- HU_AddChatText(va("\x82*%s has been banned (%s)", player_names[pnum], reason), false);
- kickreason = KR_BAN;
- break;
- }
-
- if (pnum == consoleplayer)
- {
- LUA_HookBool(false, HOOK(GameQuit));
-#ifdef DUMPCONSISTENCY
- if (msg == KICK_MSG_CON_FAIL) SV_SavedGame();
-#endif
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- if (msg == KICK_MSG_CON_FAIL)
- M_StartMessage(M_GetText("Server closed connection\n(synch failure)\nPress ESC\n"), NULL, MM_NOTHING);
- else if (msg == KICK_MSG_PING_HIGH)
- M_StartMessage(M_GetText("Server closed connection\n(Broke ping limit)\nPress ESC\n"), NULL, MM_NOTHING);
- else if (msg == KICK_MSG_BANNED)
- M_StartMessage(M_GetText("You have been banned by the server\n\nPress ESC\n"), NULL, MM_NOTHING);
- else if (msg == KICK_MSG_CUSTOM_KICK)
- M_StartMessage(va(M_GetText("You have been kicked\n(%s)\nPress ESC\n"), reason), NULL, MM_NOTHING);
- else if (msg == KICK_MSG_CUSTOM_BAN)
- M_StartMessage(va(M_GetText("You have been banned\n(%s)\nPress ESC\n"), reason), NULL, MM_NOTHING);
- else
- M_StartMessage(M_GetText("You have been kicked by the server\n\nPress ESC\n"), NULL, MM_NOTHING);
- }
- else if (keepbody)
- {
- if (server)
- UnlinkPlayerFromNode(pnum);
- players[pnum].quittime = 1;
- }
- else
- CL_RemovePlayer(pnum, kickreason);
-}
-
-// If in a special stage, redistribute the player's
-// spheres across the remaining players.
-// I feel like this shouldn't even be in this file at all, but well.
-static void RedistributeSpecialStageSpheres(INT32 playernum)
-{
- if (!G_IsSpecialStage(gamemap) || D_NumPlayers() <= 1)
- return;
-
- INT32 count = D_NumPlayers() - 1;
- INT32 spheres = players[playernum].spheres;
- INT32 rings = players[playernum].rings;
-
- while (spheres || rings)
- {
- INT32 sincrement = max(spheres / count, 1);
- INT32 rincrement = max(rings / count, 1);
-
- INT32 n;
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (!playeringame[i] || i == playernum)
- continue;
-
- n = min(spheres, sincrement);
- P_GivePlayerSpheres(&players[i], n);
- spheres -= n;
-
- n = min(rings, rincrement);
- P_GivePlayerRings(&players[i], n);
- rings -= n;
- }
- }
-}
-
-//
-// CL_RemovePlayer
-//
-// Removes a player from the current game
-//
-void CL_RemovePlayer(INT32 playernum, kickreason_t reason)
-{
- // Sanity check: exceptional cases (i.e. c-fails) can cause multiple
- // kick commands to be issued for the same player.
- if (!playeringame[playernum])
- return;
-
- if (server)
- UnlinkPlayerFromNode(playernum);
-
- if (gametyperules & GTR_TEAMFLAGS)
- P_PlayerFlagBurst(&players[playernum], false); // Don't take the flag with you!
-
- RedistributeSpecialStageSpheres(playernum);
-
- LUA_HookPlayerQuit(&players[playernum], reason); // Lua hook for player quitting
-
- // don't look through someone's view who isn't there
- if (playernum == displayplayer)
- {
- // Call ViewpointSwitch hooks here.
- // The viewpoint was forcibly changed.
- LUA_HookViewpointSwitch(&players[consoleplayer], &players[consoleplayer], true);
- displayplayer = consoleplayer;
- }
-
- // Reset player data
- CL_ClearPlayer(playernum);
-
- // remove avatar of player
- playeringame[playernum] = false;
- while (!playeringame[doomcom->numslots-1] && doomcom->numslots > 1)
- doomcom->numslots--;
-
- // Reset the name
- sprintf(player_names[playernum], "Player %d", playernum+1);
-
- player_name_changes[playernum] = 0;
-
- if (IsPlayerAdmin(playernum))
- {
- RemoveAdminPlayer(playernum); // don't stay admin after you're gone
- }
-
- LUA_InvalidatePlayer(&players[playernum]);
-
- if (G_TagGametype()) //Check if you still have a game. Location flexible. =P
- P_CheckSurvivors();
- else if (gametyperules & GTR_RACE)
- P_CheckRacers();
-}
-
-//
-// D_QuitNetGame
-// Called before quitting to leave a net game
-// without hanging the other players
-//
-void D_QuitNetGame(void)
-{
- mousegrabbedbylua = true;
- I_UpdateMouseGrab();
-
- if (!netgame || !netbuffer)
- return;
-
- DEBFILE("===========================================================================\n"
- " Quitting Game, closing connection\n"
- "===========================================================================\n");
-
- // abort send/receive of files
- CloseNetFile();
- RemoveAllLuaFileTransfers();
- waitingforluafiletransfer = false;
- waitingforluafilecommand = false;
-
- if (server)
- {
- netbuffer->packettype = PT_SERVERSHUTDOWN;
- for (INT32 i = 0; i < MAXNETNODES; i++)
- if (netnodes[i].ingame)
- HSendPacket(i, true, 0, 0);
-#ifdef MASTERSERVER
- if (serverrunning && ms_RoomId > 0)
- UnregisterServer();
-#endif
- }
- else if (servernode > 0 && servernode < MAXNETNODES && netnodes[(UINT8)servernode].ingame)
- {
- netbuffer->packettype = PT_CLIENTQUIT;
- HSendPacket(servernode, true, 0, 0);
- }
-
- D_CloseConnection();
- ClearAdminPlayers();
-
- DEBFILE("===========================================================================\n"
- " Log finish\n"
- "===========================================================================\n");
-#ifdef DEBUGFILE
- if (debugfile)
- {
- fclose(debugfile);
- debugfile = NULL;
- }
-#endif
-}
-
-void CL_HandleTimeout(void)
-{
- LUA_HookBool(false, HOOK(GameQuit));
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText("Server Timeout\n\nPress Esc\n"), NULL, MM_NOTHING);
-}
-
-void CL_AddSplitscreenPlayer(void)
-{
- if (cl_mode == CL_CONNECTED)
- CL_SendJoin();
-}
-
-void CL_RemoveSplitscreenPlayer(void)
-{
- if (cl_mode != CL_CONNECTED)
- return;
-
- SendKick(secondarydisplayplayer, KICK_MSG_PLAYER_QUIT);
-}
-
-void SV_ResetServer(void)
-{
- // +1 because this command will be executed in com_executebuffer in
- // tryruntic so gametic will be incremented, anyway maketic > gametic
- // is not an issue
-
- maketic = gametic + 1;
- neededtic = maketic;
- tictoclear = maketic;
-
- joindelay = 0;
-
- for (INT32 i = 0; i < MAXNETNODES; i++)
- ResetNode(i);
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- LUA_InvalidatePlayer(&players[i]);
- playeringame[i] = false;
- playernode[i] = UINT8_MAX;
- memset(playeraddress[i], 0, sizeof(*playeraddress));
- sprintf(player_names[i], "Player %d", i + 1);
- adminplayers[i] = -1; // Populate the entire adminplayers array with -1.
- }
-
- memset(player_name_changes, 0, sizeof player_name_changes);
-
- mynode = 0;
- cl_packetmissed = false;
- cl_redownloadinggamestate = false;
-
- if (dedicated)
- {
- netnodes[0].ingame = true;
- serverplayer = 0;
- }
- else
- serverplayer = consoleplayer;
-
- if (server)
- servernode = 0;
-
- doomcom->numslots = 0;
-
- // clear server_context
- memset(server_context, '-', 8);
-
- CV_RevertNetVars();
-
- DEBFILE("\n-=-=-=-=-=-=-= Server Reset =-=-=-=-=-=-=-\n\n");
-}
-
-static inline void SV_GenContext(void)
-{
- // generate server_context, as exactly 8 bytes of randomly mixed A-Z and a-z
- // (hopefully M_Random is initialized!! if not this will be awfully silly!)
- for (UINT8 i = 0; i < 8; i++)
- {
- const char a = M_RandomKey(26*2);
- if (a < 26) // uppercase
- server_context[i] = 'A'+a;
- else // lowercase
- server_context[i] = 'a'+(a-26);
- }
-}
-
-void SV_SpawnServer(void)
-{
- if (demoplayback)
- G_StopDemo(); // reset engine parameter
- if (metalplayback)
- G_StopMetalDemo();
-
- if (!serverrunning)
- {
- CONS_Printf(M_GetText("Starting Server....\n"));
- serverrunning = true;
- SV_ResetServer();
- SV_GenContext();
- if (netgame && I_NetOpenSocket)
- {
- I_NetOpenSocket();
-#ifdef MASTERSERVER
- if (ms_RoomId > 0)
- RegisterServer();
-#endif
- }
-
- // non dedicated server just connect to itself
- if (!dedicated)
- CL_ConnectToServer();
- else doomcom->numslots = 1;
- }
-}
-
-// called at singleplayer start and stopdemo
-void SV_StartSinglePlayerServer(void)
-{
- server = true;
- netgame = false;
- multiplayer = false;
- G_SetGametype(GT_COOP);
-
- // no more tic the game with this settings!
- SV_StopServer();
-
- if (splitscreen)
- multiplayer = true;
-}
-
-void SV_StopServer(void)
-{
- if (gamestate == GS_INTERMISSION)
- Y_EndIntermission();
- gamestate = wipegamestate = GS_NULL;
-
- localtextcmd[0] = 0;
- localtextcmd2[0] = 0;
-
- for (tic_t i = firstticstosend; i < firstticstosend + BACKUPTICS; i++)
- D_Clearticcmd(i);
-
- consoleplayer = 0;
- cl_mode = CL_SEARCHING;
- maketic = gametic+1;
- neededtic = maketic;
- serverrunning = false;
-}
-
-/** Called when a PT_SERVERSHUTDOWN packet is received
- *
- * \param node The packet sender (should be the server)
- *
- */
-static void PT_ServerShutdown(SINT8 node)
-{
- if (node != servernode || server || cl_mode == CL_SEARCHING)
- return;
-
- (void)node;
- LUA_HookBool(false, HOOK(GameQuit));
- D_QuitNetGame();
- CL_Reset();
- D_StartTitle();
- M_StartMessage(M_GetText("Server has shutdown\n\nPress Esc\n"), NULL, MM_NOTHING);
-}
-
-static void PT_Login(SINT8 node, INT32 netconsole)
-{
- (void)node;
-
- if (client)
- return;
-
-#ifndef NOMD5
- UINT8 finalmd5[16];/* Well, it's the cool thing to do? */
-
- if (doomcom->datalength < 16)/* ignore partial sends */
- return;
-
- if (!adminpasswordset)
- {
- CONS_Printf(M_GetText("Password from %s failed (no password set).\n"), player_names[netconsole]);
- return;
- }
-
- // Do the final pass to compare with the sent md5
- D_MD5PasswordPass(adminpassmd5, 16, va("PNUM%02d", netconsole), &finalmd5);
-
- if (!memcmp(netbuffer->u.md5sum, finalmd5, 16))
- {
- CONS_Printf(M_GetText("%s passed authentication.\n"), player_names[netconsole]);
- COM_BufInsertText(va("promote %d\n", netconsole)); // do this immediately
- }
- else
- CONS_Printf(M_GetText("Password from %s failed.\n"), player_names[netconsole]);
-#else
- (void)netconsole;
-#endif
-}
-
-static void PT_AskLuaFile(SINT8 node)
-{
- if (server && luafiletransfers && luafiletransfers->nodestatus[node] == LFTNS_ASKED)
- AddLuaFileToSendQueue(node, luafiletransfers->realfilename);
-}
-
-static void PT_HasLuaFile(SINT8 node)
-{
- if (server && luafiletransfers && luafiletransfers->nodestatus[node] == LFTNS_SENDING)
- SV_HandleLuaFileSent(node);
-}
-
-static void PT_SendingLuaFile(SINT8 node)
-{
- (void)node;
-
- if (client)
- CL_PrepareDownloadLuaFile();
-}
-
-/*
-Ping Update except better:
-We call this once per second and check for people's pings. If their ping happens to be too high, we increment some timer and kick them out.
-If they're not lagging, decrement the timer by 1. Of course, reset all of this if they leave.
-*/
-
-static inline void PingUpdate(void)
-{
- boolean laggers[MAXPLAYERS];
- UINT8 numlaggers = 0;
- memset(laggers, 0, sizeof(boolean) * MAXPLAYERS);
-
- netbuffer->packettype = PT_PING;
-
- //check for ping limit breakage.
- if (cv_maxping.value)
- {
- for (INT32 i = 1; i < MAXPLAYERS; i++)
- {
- if (playeringame[i] && !players[i].quittime
- && (realpingtable[i] / pingmeasurecount > (unsigned)cv_maxping.value))
- {
- if (players[i].jointime > 30 * TICRATE)
- laggers[i] = true;
- numlaggers++;
- }
- else
- pingtimeout[i] = 0;
- }
-
- //kick lagging players... unless everyone but the server's ping sucks.
- //in that case, it is probably the server's fault.
- if (numlaggers < D_NumPlayers() - 1)
- {
- for (INT32 i = 1; i < MAXPLAYERS; i++)
- {
- if (playeringame[i] && laggers[i])
- {
- pingtimeout[i]++;
- // ok your net has been bad for too long, you deserve to die.
- if (pingtimeout[i] > cv_pingtimeout.value)
- {
- pingtimeout[i] = 0;
- SendKick(i, KICK_MSG_PING_HIGH | KICK_MSG_KEEP_BODY);
- }
- }
- /*
- you aren't lagging,
- but you aren't free yet.
- In case you'll keep spiking,
- we just make the timer go back down. (Very unstable net must still get kicked).
- */
- else
- pingtimeout[i] = (pingtimeout[i] == 0 ? 0 : pingtimeout[i]-1);
- }
- }
- }
-
- //make the ping packet and clear server data for next one
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- netbuffer->u.pingtable[i] = realpingtable[i] / pingmeasurecount;
- //server takes a snapshot of the real ping for display.
- //otherwise, pings fluctuate a lot and would be odd to look at.
- playerpingtable[i] = realpingtable[i] / pingmeasurecount;
- realpingtable[i] = 0; //Reset each as we go.
- }
-
- // send the server's maxping as last element of our ping table. This is useful to let us know when we're about to get kicked.
- netbuffer->u.pingtable[MAXPLAYERS] = cv_maxping.value;
-
- //send out our ping packets
- for (INT32 i = 0; i < MAXNETNODES; i++)
- if (netnodes[i].ingame)
- HSendPacket(i, true, 0, sizeof(INT32) * (MAXPLAYERS+1));
-
- pingmeasurecount = 1; //Reset count
-}
-
-static void PT_Ping(SINT8 node, INT32 netconsole)
-{
- // Only accept PT_PING from the server.
- if (node != servernode)
- {
- CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_PING", node);
- if (server)
- SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
- return;
- }
-
- //Update client ping table from the server.
- if (client)
- {
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i])
- playerpingtable[i] = (tic_t)netbuffer->u.pingtable[i];
-
- servermaxping = (tic_t)netbuffer->u.pingtable[MAXPLAYERS];
- }
-}
-
-/** Handles a packet received from a node that isn't in game
- *
- * \param node The packet sender
- * \todo Choose a better name, as the packet can also come from the server apparently?
- * \sa HandlePacketFromPlayer
- * \sa GetPackets
- *
- */
-static void HandlePacketFromAwayNode(SINT8 node)
-{
- if (node != servernode)
- DEBFILE(va("Received packet from unknown host %d\n", node));
-
- switch (netbuffer->packettype)
- {
- case PT_ASKINFOVIAMS : PT_AskInfoViaMS (node ); break;
- case PT_SERVERINFO : PT_ServerInfo (node ); break;
- case PT_TELLFILESNEEDED: PT_TellFilesNeeded(node ); break;
- case PT_MOREFILESNEEDED: PT_MoreFilesNeeded(node ); break;
- case PT_ASKINFO : PT_AskInfo (node ); break;
- case PT_SERVERREFUSE : PT_ServerRefuse (node ); break;
- case PT_SERVERCFG : PT_ServerCFG (node ); break;
- case PT_FILEFRAGMENT : PT_FileFragment (node, -1); break;
- case PT_FILEACK : PT_FileAck (node ); break;
- case PT_FILERECEIVED : PT_FileReceived (node ); break;
- case PT_REQUESTFILE : PT_RequestFile (node ); break;
- case PT_CLIENTQUIT : PT_ClientQuit (node, -1); break;
- case PT_SERVERTICS : PT_ServerTics (node, -1); break;
- case PT_CLIENTJOIN : PT_ClientJoin (node ); break;
- case PT_SERVERSHUTDOWN : PT_ServerShutdown (node ); break;
- case PT_CLIENTCMD : break; // This is not an "unknown packet"
- case PT_PLAYERINFO : break; // This is not an "unknown packet"
-
- default:
- DEBFILE(va("unknown packet received (%d) from unknown host\n",netbuffer->packettype));
- Net_CloseConnection(node);
- }
-}
-
-/** Handles a packet received from a node that is in game
- *
- * \param node The packet sender
- * \todo Choose a better name
- * \sa HandlePacketFromAwayNode
- * \sa GetPackets
- *
- */
-static void HandlePacketFromPlayer(SINT8 node)
-{
- INT32 netconsole;
-
- if (dedicated && node == 0)
- netconsole = 0;
- else
- netconsole = netnodes[node].player;
-#ifdef PARANOIA
- if (netconsole >= MAXPLAYERS)
- I_Error("bad table nodetoplayer: node %d player %d", doomcom->remotenode, netconsole);
-#endif
-
- switch (netbuffer->packettype)
- {
- // SERVER RECEIVE
- case PT_CLIENTCMD:
- case PT_CLIENT2CMD:
- case PT_CLIENTMIS:
- case PT_CLIENT2MIS:
- case PT_NODEKEEPALIVE:
- case PT_NODEKEEPALIVEMIS:
- PT_ClientCmd(node, netconsole);
- break;
- case PT_TEXTCMD : PT_TextCmd (node, netconsole); break;
- case PT_TEXTCMD2 : PT_TextCmd (node, netconsole); break;
- case PT_LOGIN : PT_Login (node, netconsole); break;
- case PT_CLIENTQUIT : PT_ClientQuit (node, netconsole); break;
- case PT_CANRECEIVEGAMESTATE: PT_CanReceiveGamestate(node ); break;
- case PT_ASKLUAFILE : PT_AskLuaFile (node ); break;
- case PT_HASLUAFILE : PT_HasLuaFile (node ); break;
- case PT_RECEIVEDGAMESTATE : PT_ReceivedGamestate (node ); break;
- case PT_SERVERINFO : PT_ServerInfo (node ); break;
-
- // CLIENT RECEIVE
- case PT_SERVERTICS : PT_ServerTics (node, netconsole); break;
- case PT_PING : PT_Ping (node, netconsole); break;
- case PT_FILEFRAGMENT : PT_FileFragment (node, netconsole); break;
- case PT_FILEACK : PT_FileAck (node ); break;
- case PT_FILERECEIVED : PT_FileReceived (node ); break;
- case PT_WILLRESENDGAMESTATE: PT_WillResendGamestate(node ); break;
- case PT_SENDINGLUAFILE : PT_SendingLuaFile (node ); break;
- case PT_SERVERSHUTDOWN : PT_ServerShutdown (node ); break;
- case PT_SERVERCFG : break;
- case PT_CLIENTJOIN : break;
-
- default:
- DEBFILE(va("UNKNOWN PACKET TYPE RECEIVED %d from host %d\n",
- netbuffer->packettype, node));
- }
-}
-
-/** Handles all received packets, if any
- *
- * \todo Add details to this description (lol)
- *
- */
-void GetPackets(void)
-{
- while (HGetPacket())
- {
- SINT8 node = doomcom->remotenode;
-
- // Packet received from someone already playing
- if (netnodes[node].ingame)
- HandlePacketFromPlayer(node);
- // Packet received from someone not playing
- else
- HandlePacketFromAwayNode(node);
- }
-}
-
-boolean TryRunTics(tic_t realtics)
-{
- // the machine has lagged but it is not so bad
- if (realtics > TICRATE/7)
- {
- if (server)
- realtics = 1;
- else
- realtics = TICRATE/7;
- }
-
- if (singletics)
- realtics = 1;
-
- if (realtics >= 1)
- {
- COM_BufTicker();
- if (mapchangepending)
- D_MapChange(-1, 0, ultimatemode, false, 2, false, fromlevelselect); // finish the map change
- }
-
- NetUpdate();
-
- if (demoplayback)
- {
- neededtic = gametic + realtics;
- // start a game after a demo
- maketic += realtics;
- firstticstosend = maketic;
- tictoclear = firstticstosend;
- }
-
- GetPackets();
-
-#ifdef DEBUGFILE
- if (debugfile && (realtics || neededtic > gametic))
- {
- fprintf(debugfile, "------------ Tryruntic: REAL:%d NEED:%d GAME:%d LOAD: %d\n",
- realtics, neededtic, gametic, debugload);
- debugload = 100000;
- }
-#endif
-
- if (neededtic > gametic)
- {
- if (realtics)
- hu_stopped = false;
-
- if (advancedemo)
- {
- if (timedemo_quit)
- COM_ImmedExecute("quit");
- else
- D_StartTitle();
- }
- else
- // run the count * tics
- while (neededtic > gametic)
- {
- boolean update_stats = !(paused || P_AutoPause());
-
- DEBFILE(va("============ Running tic %d (local %d)\n", gametic, localgametic));
-
- if (update_stats)
- PS_START_TIMING(ps_tictime);
-
- G_Ticker((gametic % NEWTICRATERATIO) == 0);
- ExtraDataTicker();
- gametic++;
- consistancy[gametic%BACKUPTICS] = Consistancy();
-
- if (update_stats)
- {
- PS_STOP_TIMING(ps_tictime);
- PS_UpdateTickStats();
- }
-
- // Leave a certain amount of tics present in the net buffer as long as we've ran at least one tic this frame.
- if (client && gamestate == GS_LEVEL && leveltime > 3 && neededtic <= gametic + cv_netticbuffer.value)
- break;
- }
-
- return true;
- }
- else
- {
- if (realtics)
- hu_stopped = true;
-
- return false;
- }
-}
-
-void NetUpdate(void)
-{
- static tic_t gametime = 0;
- static tic_t resptime = 0;
- tic_t nowtime;
- INT32 realtics;
-
- nowtime = I_GetTime();
- realtics = nowtime - gametime;
-
- if (realtics <= 0) // nothing new to update
- return;
- if (realtics > 5)
- {
- if (server)
- realtics = 1;
- else
- realtics = 5;
- }
-
- gametime = nowtime;
-
- if (server)
- {
- if (netgame && !(gametime % 35)) // update once per second.
- PingUpdate();
- // update node latency values so we can take an average later.
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && playernode[i] != UINT8_MAX)
- realpingtable[i] += G_TicsToMilliseconds(GetLag(playernode[i]));
- pingmeasurecount++;
- }
-
- if (client)
- maketic = neededtic;
-
- Local_Maketic(realtics);
-
- if (server)
- CL_SendClientCmd(); // send it
-
- GetPackets(); // get packet from client or from server
-
- // The client sends the command after receiving from the server
- // The server sends it before because this is better in single player
-
-#ifdef MASTERSERVER
- MasterClient_Ticker(); // Acking the Master Server
-#endif
-
- if (client)
- {
- // If the client just finished redownloading the game state, load it
- if (cl_redownloadinggamestate && fileneeded[0].status == FS_FOUND)
- CL_ReloadReceivedSavegame();
-
- CL_SendClientCmd(); // Send tic cmd
- hu_redownloadinggamestate = cl_redownloadinggamestate;
- }
- else
- {
- if (!demoplayback)
- {
- hu_redownloadinggamestate = false;
-
- firstticstosend = gametic;
- for (INT32 i = 0; i < MAXNETNODES; i++)
- if (netnodes[i].ingame && netnodes[i].tic < firstticstosend)
- {
- firstticstosend = netnodes[i].tic;
-
- if (maketic + 1 >= netnodes[i].tic + BACKUPTICS)
- Net_ConnectionTimeout(i);
- }
-
- // Don't erase tics not acknowledged
- INT32 counts = realtics;
- if (maketic + counts >= firstticstosend + BACKUPTICS)
- counts = firstticstosend+BACKUPTICS-maketic-1;
-
- for (INT32 i = 0; i < counts; i++)
- SV_Maketic(); // Create missed tics and increment maketic
-
- for (; tictoclear < firstticstosend; tictoclear++) // Clear only when acknowledged
- D_Clearticcmd(tictoclear); // Clear the maketic the new tic
-
- SV_SendTics();
-
- neededtic = maketic; // The server is a client too
- }
- }
-
- Net_AckTicker();
-
- // Handle timeouts to prevent definitive freezes from happenning
- if (server)
- {
- for (INT32 i = 1; i < MAXNETNODES; i++)
- if (netnodes[i].ingame && netnodes[i].freezetimeout < I_GetTime())
- Net_ConnectionTimeout(i);
-
- // In case the cvar value was lowered
- if (joindelay)
- joindelay = min(joindelay - 1, 3 * (tic_t)cv_joindelay.value * TICRATE);
- }
-
- nowtime /= NEWTICRATERATIO;
- if (nowtime > resptime)
- {
- resptime = nowtime;
-#ifdef HAVE_THREADS
- I_lock_mutex(&m_menu_mutex);
-#endif
- M_Ticker();
-#ifdef HAVE_THREADS
- I_unlock_mutex(m_menu_mutex);
-#endif
- CON_Ticker();
- }
-
- FileSendTicker();
-}
-
-// called one time at init
-void D_ClientServerInit(void)
-{
- DEBFILE(va("- - -== SRB2 v%d.%.2d.%d "VERSIONSTRING" debugfile ==- - -\n",
- VERSION/100, VERSION%100, SUBVERSION));
-
- COM_AddCommand("getplayernum", Command_GetPlayerNum);
- COM_AddCommand("kick", Command_Kick);
- COM_AddCommand("ban", Command_Ban);
- COM_AddCommand("banip", Command_BanIP);
- COM_AddCommand("clearbans", Command_ClearBans);
- COM_AddCommand("showbanlist", Command_ShowBan);
- COM_AddCommand("reloadbans", Command_ReloadBan);
- COM_AddCommand("connect", Command_connect);
- COM_AddCommand("nodes", Command_Nodes);
- COM_AddCommand("resendgamestate", Command_ResendGamestate);
-#ifdef PACKETDROP
- COM_AddCommand("drop", Command_Drop);
- COM_AddCommand("droprate", Command_Droprate);
-#endif
-#ifdef _DEBUG
- COM_AddCommand("numnodes", Command_Numnodes);
-#endif
-
- RegisterNetXCmd(XD_KICK, Got_KickCmd);
- RegisterNetXCmd(XD_ADDPLAYER, Got_AddPlayer);
-#ifdef DUMPCONSISTENCY
- CV_RegisterVar(&cv_dumpconsistency);
-#endif
- Ban_Load_File(false);
-
- gametic = 0;
- localgametic = 0;
-
- // do not send anything before the real begin
- SV_StopServer();
- SV_ResetServer();
- if (dedicated)
- SV_SpawnServer();
-}
-
-SINT8 nametonum(const char *name)
-{
- INT32 playernum;
-
- if (!strcmp(name, "0"))
- return 0;
-
- playernum = (SINT8)atoi(name);
-
- if (playernum < 0 || playernum >= MAXPLAYERS)
- return -1;
-
- if (playernum)
- {
- if (playeringame[playernum])
- return (SINT8)playernum;
- else
- return -1;
- }
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && !stricmp(player_names[i], name))
- return (SINT8)i;
-
- CONS_Printf(M_GetText("There is no player named \"%s\"\n"), name);
-
- return -1;
-}
-
-// Is there a game running?
-boolean Playing(void)
-{
- return (server && serverrunning) || (client && cl_mode == CL_CONNECTED);
-}
-
-/** Returns the number of players playing.
- * \return Number of players. Can be zero if we're running a ::dedicated
- * server.
- * \author Graue <graue@oceanbase.org>
- */
-INT32 D_NumPlayers(void)
-{
- INT32 num = 0;
- for (INT32 ix = 0; ix < MAXPLAYERS; ix++)
- if (playeringame[ix])
- num++;
- return num;
-}
-
-//
-// Consistancy
-//
-// Note: It is called consistAncy on purpose.
-//
-INT16 Consistancy(void)
-{
- UINT32 ret = 0;
-#ifdef MOBJCONSISTANCY
- thinker_t *th;
- mobj_t *mo;
-#endif
-
- DEBFILE(va("TIC %u ", gametic));
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (!playeringame[i])
- ret ^= 0xCCCC;
- else if (!players[i].mo);
- else
- {
- ret += players[i].mo->x;
- ret -= players[i].mo->y;
- ret += players[i].powers[pw_shield];
- ret *= i+1;
- }
- }
- // I give up
- // Coop desynching enemies is painful
- if (!G_PlatformGametype())
- ret += P_GetRandSeed();
-
-#ifdef MOBJCONSISTANCY
- if (gamestate == GS_LEVEL)
- {
- for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
- {
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
- continue;
-
- mo = (mobj_t *)th;
-
- if (mo->flags & (MF_SPECIAL | MF_SOLID | MF_PUSHABLE | MF_BOSS | MF_MISSILE | MF_SPRING | MF_MONITOR | MF_FIRE | MF_ENEMY | MF_PAIN | MF_STICKY))
- {
- ret -= mo->type;
- ret += mo->x;
- ret -= mo->y;
- ret += mo->z;
- ret -= mo->momx;
- ret += mo->momy;
- ret -= mo->momz;
- ret += mo->angle;
- ret -= mo->flags;
- ret += mo->flags2;
- ret -= mo->eflags;
- if (mo->target)
- {
- ret += mo->target->type;
- ret -= mo->target->x;
- ret += mo->target->y;
- ret -= mo->target->z;
- ret += mo->target->momx;
- ret -= mo->target->momy;
- ret += mo->target->momz;
- ret -= mo->target->angle;
- ret += mo->target->flags;
- ret -= mo->target->flags2;
- ret += mo->target->eflags;
- ret -= mo->target->state - states;
- ret += mo->target->tics;
- ret -= mo->target->sprite;
- ret += mo->target->frame;
- }
- else
- ret ^= 0x3333;
- if (mo->tracer && mo->tracer->type != MT_OVERLAY)
- {
- ret += mo->tracer->type;
- ret -= mo->tracer->x;
- ret += mo->tracer->y;
- ret -= mo->tracer->z;
- ret += mo->tracer->momx;
- ret -= mo->tracer->momy;
- ret += mo->tracer->momz;
- ret -= mo->tracer->angle;
- ret += mo->tracer->flags;
- ret -= mo->tracer->flags2;
- ret += mo->tracer->eflags;
- ret -= mo->tracer->state - states;
- ret += mo->tracer->tics;
- ret -= mo->tracer->sprite;
- ret += mo->tracer->frame;
- }
- else
- ret ^= 0xAAAA;
- ret -= mo->state - states;
- ret += mo->tics;
- ret -= mo->sprite;
- ret += mo->frame;
- }
- }
- }
-#endif
-
- DEBFILE(va("Consistancy = %u\n", (ret & 0xFFFF)));
-
- return (INT16)(ret & 0xFFFF);
-}
-
-tic_t GetLag(INT32 node)
-{
- return gametic - netnodes[node].tic;
-}
-
-void D_MD5PasswordPass(const UINT8 *buffer, size_t len, const char *salt, void *dest)
-{
-#ifdef NOMD5
- (void)buffer;
- (void)len;
- (void)salt;
- memset(dest, 0, 16);
-#else
- char tmpbuf[256];
- const size_t sl = strlen(salt);
-
- if (len > 256-sl)
- len = 256-sl;
-
- memcpy(tmpbuf, buffer, len);
- memmove(&tmpbuf[len], salt, sl);
- //strcpy(&tmpbuf[len], salt);
- len += strlen(salt);
- if (len < 256)
- memset(&tmpbuf[len],0,256-len);
-
- // Yes, we intentionally md5 the ENTIRE buffer regardless of size...
- md5_buffer(tmpbuf, 256, dest);
-#endif
-}
diff --git a/src/netcode/d_clisrv.h b/src/netcode/d_clisrv.h
deleted file mode 100644
index 0abd638ce937e7173d73584a98d083b68f1cdb17..0000000000000000000000000000000000000000
--- a/src/netcode/d_clisrv.h
+++ /dev/null
@@ -1,131 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file d_clisrv.h
-/// \brief high level networking stuff
-
-#ifndef __D_CLISRV__
-#define __D_CLISRV__
-
-#include "protocol.h"
-#include "../d_ticcmd.h"
-#include "d_net.h"
-#include "d_netcmd.h"
-#include "d_net.h"
-#include "../tables.h"
-#include "../d_player.h"
-#include "mserv.h"
-
-#define CLIENTBACKUPTICS 32
-
-#ifdef PACKETDROP
-void Command_Drop(void);
-void Command_Droprate(void);
-#endif
-#ifdef _DEBUG
-void Command_Numnodes(void);
-#endif
-
-extern INT32 mapchangepending;
-
-// Points inside doomcom
-extern doomdata_t *netbuffer;
-
-#define BASEPACKETSIZE offsetof(doomdata_t, u)
-#define BASESERVERTICSSIZE offsetof(doomdata_t, u.serverpak.cmds[0])
-
-typedef enum
-{
- KR_KICK = 1, //Kicked by server
- KR_PINGLIMIT = 2, //Broke Ping Limit
- KR_SYNCH = 3, //Synch Failure
- KR_TIMEOUT = 4, //Connection Timeout
- KR_BAN = 5, //Banned by server
- KR_LEAVE = 6, //Quit the game
-
-} kickreason_t;
-
-/* the max number of name changes in some time period */
-#define MAXNAMECHANGES (5)
-#define NAMECHANGERATE (60*TICRATE)
-
-extern boolean server;
-extern boolean serverrunning;
-#define client (!server)
-extern boolean dedicated; // For dedicated server
-extern UINT16 software_MAXPACKETLENGTH;
-extern boolean acceptnewnode;
-extern SINT8 servernode;
-extern tic_t maketic;
-extern tic_t neededtic;
-extern INT16 consistancy[BACKUPTICS];
-
-void Command_Ping_f(void);
-extern tic_t connectiontimeout;
-extern UINT16 pingmeasurecount;
-extern UINT32 realpingtable[MAXPLAYERS];
-extern UINT32 playerpingtable[MAXPLAYERS];
-extern tic_t servermaxping;
-
-extern consvar_t cv_netticbuffer, cv_resynchattempts, cv_blamecfail, cv_playbackspeed;
-
-// Used in d_net, the only dependence
-void D_ClientServerInit(void);
-
-// Create any new ticcmds and broadcast to other players.
-void NetUpdate(void);
-
-void GetPackets(void);
-void ResetNode(INT32 node);
-INT16 Consistancy(void);
-
-void SV_StartSinglePlayerServer(void);
-void SV_SpawnServer(void);
-void SV_StopServer(void);
-void SV_ResetServer(void);
-void CL_AddSplitscreenPlayer(void);
-void CL_RemoveSplitscreenPlayer(void);
-void CL_Reset(void);
-void CL_ClearPlayer(INT32 playernum);
-void CL_RemovePlayer(INT32 playernum, kickreason_t reason);
-void CL_HandleTimeout(void);
-// Is there a game running
-boolean Playing(void);
-
-// Broadcasts special packets to other players
-// to notify of game exit
-void D_QuitNetGame(void);
-
-//? How many ticks to run?
-boolean TryRunTics(tic_t realtic);
-
-// extra data for lmps
-// these functions scare me. they contain magic.
-/*boolean AddLmpExtradata(UINT8 **demo_p, INT32 playernum);
-void ReadLmpExtraData(UINT8 **demo_pointer, INT32 playernum);*/
-
-// translate a playername in a player number return -1 if not found and
-// print a error message in the console
-SINT8 nametonum(const char *name);
-
-extern char motd[254], server_context[8];
-extern UINT8 playernode[MAXPLAYERS];
-
-INT32 D_NumPlayers(void);
-
-tic_t GetLag(INT32 node);
-
-void D_MD5PasswordPass(const UINT8 *buffer, size_t len, const char *salt, void *dest);
-
-extern UINT8 adminpassmd5[16];
-extern boolean adminpasswordset;
-
-extern boolean hu_stopped;
-
-#endif
diff --git a/src/netcode/gamestate.c b/src/netcode/gamestate.c
deleted file mode 100644
index c1ceb95b5d446c935ea286763e4355173e64de2d..0000000000000000000000000000000000000000
--- a/src/netcode/gamestate.c
+++ /dev/null
@@ -1,336 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file gamestate.c
-/// \brief Gamestate (re)sending
-
-#include "d_clisrv.h"
-#include "d_netfil.h"
-#include "gamestate.h"
-#include "i_net.h"
-#include "protocol.h"
-#include "server_connection.h"
-#include "../am_map.h"
-#include "../byteptr.h"
-#include "../console.h"
-#include "../d_main.h"
-#include "../doomstat.h"
-#include "../doomtype.h"
-#include "../f_finale.h"
-#include "../g_demo.h"
-#include "../g_game.h"
-#include "../i_time.h"
-#include "../lua_script.h"
-#include "../lzf.h"
-#include "../m_misc.h"
-#include "../p_haptic.h"
-#include "../p_local.h"
-#include "../p_saveg.h"
-#include "../r_main.h"
-#include "../tables.h"
-#include "../z_zone.h"
-
-#define SAVEGAMESIZE (768*1024)
-
-UINT8 hu_redownloadinggamestate = 0;
-boolean cl_redownloadinggamestate = false;
-
-boolean SV_ResendingSavegameToAnyone(void)
-{
- for (INT32 i = 0; i < MAXNETNODES; i++)
- if (netnodes[i].resendingsavegame)
- return true;
- return false;
-}
-
-void SV_SendSaveGame(INT32 node, boolean resending)
-{
- size_t length, compressedlen;
- UINT8 *savebuffer;
- UINT8 *compressedsave;
- UINT8 *buffertosend;
-
- // first save it in a malloced buffer
- savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
- if (!savebuffer)
- {
- CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
- return;
- }
-
- // Leave room for the uncompressed length.
- save_p = savebuffer + sizeof(UINT32);
-
- P_SaveNetGame(resending);
-
- length = save_p - savebuffer;
- if (length > SAVEGAMESIZE)
- {
- free(savebuffer);
- save_p = NULL;
- I_Error("Savegame buffer overrun");
- }
-
- // Allocate space for compressed save: one byte fewer than for the
- // uncompressed data to ensure that the compression is worthwhile.
- compressedsave = malloc(length - 1);
- if (!compressedsave)
- {
- CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
- return;
- }
-
- // Attempt to compress it.
- if((compressedlen = lzf_compress(savebuffer + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
- {
- // Compressing succeeded; send compressed data
-
- free(savebuffer);
-
- // State that we're compressed.
- buffertosend = compressedsave;
- WRITEUINT32(compressedsave, length - sizeof(UINT32));
- length = compressedlen + sizeof(UINT32);
- }
- else
- {
- // Compression failed to make it smaller; send original
-
- free(compressedsave);
-
- // State that we're not compressed
- buffertosend = savebuffer;
- WRITEUINT32(savebuffer, 0);
- }
-
- AddRamToSendQueue(node, buffertosend, length, SF_RAM, 0);
- save_p = NULL;
-
- // Remember when we started sending the savegame so we can handle timeouts
- netnodes[node].sendingsavegame = true;
- netnodes[node].freezetimeout = I_GetTime() + jointimeout + length / 1024; // 1 extra tic for each kilobyte
-}
-
-#ifdef DUMPCONSISTENCY
-#define TMPSAVENAME "badmath.sav"
-static consvar_t cv_dumpconsistency = CVAR_INIT ("dumpconsistency", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
-
-void SV_SavedGame(void)
-{
- size_t length;
- UINT8 *savebuffer;
- char tmpsave[256];
-
- if (!cv_dumpconsistency.value)
- return;
-
- sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
-
- // first save it in a malloced buffer
- save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
- if (!save_p)
- {
- CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
- return;
- }
-
- P_SaveNetGame(false);
-
- length = save_p - savebuffer;
- if (length > SAVEGAMESIZE)
- {
- free(savebuffer);
- save_p = NULL;
- I_Error("Savegame buffer overrun");
- }
-
- // then save it!
- if (!FIL_WriteFile(tmpsave, savebuffer, length))
- CONS_Printf(M_GetText("Didn't save %s for netgame"), tmpsave);
-
- free(savebuffer);
- save_p = NULL;
-}
-
-#undef TMPSAVENAME
-#endif
-#define TMPSAVENAME "$$$.sav"
-
-
-void CL_LoadReceivedSavegame(boolean reloading)
-{
- UINT8 *savebuffer = NULL;
- size_t length, decompressedlen;
- char tmpsave[256];
-
- FreeFileNeeded();
-
- sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
-
- length = FIL_ReadFile(tmpsave, &savebuffer);
-
- CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(length));
- if (!length)
- {
- I_Error("Can't read savegame sent");
- return;
- }
-
- save_p = savebuffer;
-
- // Decompress saved game if necessary.
- decompressedlen = READUINT32(save_p);
- if(decompressedlen > 0)
- {
- UINT8 *decompressedbuffer = Z_Malloc(decompressedlen, PU_STATIC, NULL);
- lzf_decompress(save_p, length - sizeof(UINT32), decompressedbuffer, decompressedlen);
- Z_Free(savebuffer);
- save_p = savebuffer = decompressedbuffer;
- }
-
- paused = false;
- demoplayback = false;
- titlemapinaction = TITLEMAP_OFF;
- titledemo = false;
- automapactive = false;
-
- P_StopRumble(NULL);
-
- // load a base level
- if (P_LoadNetGame(reloading))
- {
- const UINT8 actnum = mapheaderinfo[gamemap-1]->actnum;
- CONS_Printf(M_GetText("Map is now \"%s"), G_BuildMapName(gamemap));
- if (strcmp(mapheaderinfo[gamemap-1]->lvlttl, ""))
- {
- CONS_Printf(": %s", mapheaderinfo[gamemap-1]->lvlttl);
- if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
- CONS_Printf(M_GetText(" Zone"));
- if (actnum > 0)
- CONS_Printf(" %2d", actnum);
- }
- CONS_Printf("\"\n");
- }
-
- // done
- Z_Free(savebuffer);
- save_p = NULL;
- if (unlink(tmpsave) == -1)
- CONS_Alert(CONS_ERROR, M_GetText("Can't delete %s\n"), tmpsave);
- consistancy[gametic%BACKUPTICS] = Consistancy();
- CON_ToggleOff();
-
- // Tell the server we have received and reloaded the gamestate
- // so they know they can resume the game
- netbuffer->packettype = PT_RECEIVEDGAMESTATE;
- HSendPacket(servernode, true, 0, 0);
-}
-
-void CL_ReloadReceivedSavegame(void)
-{
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- LUA_InvalidatePlayer(&players[i]);
- sprintf(player_names[i], "Player %d", i + 1);
- }
-
- CL_LoadReceivedSavegame(true);
-
- neededtic = max(neededtic, gametic);
- maketic = neededtic;
-
- ticcmd_oldangleturn[0] = players[consoleplayer].oldrelangleturn;
- P_ForceLocalAngle(&players[consoleplayer], (angle_t)(players[consoleplayer].angleturn << 16));
- if (splitscreen)
- {
- ticcmd_oldangleturn[1] = players[secondarydisplayplayer].oldrelangleturn;
- P_ForceLocalAngle(&players[secondarydisplayplayer], (angle_t)(players[secondarydisplayplayer].angleturn << 16));
- }
-
- camera.subsector = R_PointInSubsector(camera.x, camera.y);
- camera2.subsector = R_PointInSubsector(camera2.x, camera2.y);
-
- cl_redownloadinggamestate = false;
-
- CONS_Printf(M_GetText("Game state reloaded\n"));
-}
-
-void Command_ResendGamestate(void)
-{
- SINT8 playernum;
-
- if (COM_Argc() == 1)
- {
- CONS_Printf(M_GetText("resendgamestate <playername/playernum>: resend the game state to a player\n"));
- return;
- }
- else if (client)
- {
- CONS_Printf(M_GetText("Only the server can use this.\n"));
- return;
- }
-
- playernum = nametonum(COM_Argv(1));
- if (playernum == -1 || playernum == 0)
- return;
-
- // Send a PT_WILLRESENDGAMESTATE packet to the client so they know what's going on
- netbuffer->packettype = PT_WILLRESENDGAMESTATE;
- if (!HSendPacket(playernode[playernum], true, 0, 0))
- {
- CONS_Alert(CONS_ERROR, M_GetText("A problem occured, please try again.\n"));
- return;
- }
-}
-
-void PT_CanReceiveGamestate(SINT8 node)
-{
- if (client || netnodes[node].sendingsavegame)
- return;
-
- CONS_Printf(M_GetText("Resending game state to %s...\n"), player_names[netnodes[node].player]);
-
- SV_SendSaveGame(node, true); // Resend a complete game state
- netnodes[node].resendingsavegame = true;
-}
-
-void PT_ReceivedGamestate(SINT8 node)
-{
- netnodes[node].sendingsavegame = false;
- netnodes[node].resendingsavegame = false;
- netnodes[node].savegameresendcooldown = I_GetTime() + 5 * TICRATE;
-}
-
-void PT_WillResendGamestate(SINT8 node)
-{
- (void)node;
-
- char tmpsave[256];
-
- if (server || cl_redownloadinggamestate)
- return;
-
- // Send back a PT_CANRECEIVEGAMESTATE packet to the server
- // so they know they can start sending the game state
- netbuffer->packettype = PT_CANRECEIVEGAMESTATE;
- if (!HSendPacket(servernode, true, 0, 0))
- return;
-
- CONS_Printf(M_GetText("Reloading game state...\n"));
-
- sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
-
- // Don't get a corrupt savegame error because tmpsave already exists
- if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
- I_Error("Can't delete %s\n", tmpsave);
-
- CL_PrepareDownloadSaveGame(tmpsave);
-
- cl_redownloadinggamestate = true;
-}
diff --git a/src/netcode/gamestate.h b/src/netcode/gamestate.h
deleted file mode 100644
index 9d277977220fd171e95ae0de33a2ea215c3c30b1..0000000000000000000000000000000000000000
--- a/src/netcode/gamestate.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file gamestate.h
-/// \brief Gamestate (re)sending
-
-#ifndef __GAMESTATE__
-#define __GAMESTATE__
-
-#include "../doomtype.h"
-
-extern UINT8 hu_redownloadinggamestate;
-extern boolean cl_redownloadinggamestate;
-
-boolean SV_ResendingSavegameToAnyone(void);
-void SV_SendSaveGame(INT32 node, boolean resending);
-void SV_SavedGame(void);
-void CL_LoadReceivedSavegame(boolean reloading);
-void CL_ReloadReceivedSavegame(void);
-void Command_ResendGamestate(void);
-void PT_CanReceiveGamestate(SINT8 node);
-void PT_ReceivedGamestate(SINT8 node);
-void PT_WillResendGamestate(SINT8 node);
-
-#endif
diff --git a/src/netcode/net_command.c b/src/netcode/net_command.c
deleted file mode 100644
index efc8bd0efc4e9046989d604feedba5cbcc66897f..0000000000000000000000000000000000000000
--- a/src/netcode/net_command.c
+++ /dev/null
@@ -1,386 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file net_command.c
-/// \brief Net command handling
-
-#include "net_command.h"
-#include "tic_command.h"
-#include "gamestate.h"
-#include "server_connection.h"
-#include "d_clisrv.h"
-#include "i_net.h"
-#include "../byteptr.h"
-#include "../g_game.h"
-#include "../z_zone.h"
-#include "../doomtype.h"
-
-textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE] = {NULL};
-UINT8 localtextcmd[MAXTEXTCMD];
-UINT8 localtextcmd2[MAXTEXTCMD]; // splitscreen
-static void (*listnetxcmd[MAXNETXCMD])(UINT8 **p, INT32 playernum);
-
-void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum))
-{
-#ifdef PARANOIA
- if (id >= MAXNETXCMD)
- I_Error("Command id %d too big", id);
- if (listnetxcmd[id] != 0)
- I_Error("Command id %d already used", id);
-#endif
- listnetxcmd[id] = cmd_f;
-}
-
-void SendNetXCmd(netxcmd_t id, const void *param, size_t nparam)
-{
- if (localtextcmd[0]+2+nparam > MAXTEXTCMD)
- {
- // for future reference: if (cv_debug) != debug disabled.
- CONS_Alert(CONS_ERROR, M_GetText("NetXCmd buffer full, cannot add netcmd %d! (size: %d, needed: %s)\n"), id, localtextcmd[0], sizeu1(nparam));
- return;
- }
- localtextcmd[0]++;
- localtextcmd[localtextcmd[0]] = (UINT8)id;
- if (param && nparam)
- {
- M_Memcpy(&localtextcmd[localtextcmd[0]+1], param, nparam);
- localtextcmd[0] = (UINT8)(localtextcmd[0] + (UINT8)nparam);
- }
-}
-
-// splitscreen player
-void SendNetXCmd2(netxcmd_t id, const void *param, size_t nparam)
-{
- if (localtextcmd2[0]+2+nparam > MAXTEXTCMD)
- {
- I_Error("No more place in the buffer for netcmd %d\n",id);
- return;
- }
- localtextcmd2[0]++;
- localtextcmd2[localtextcmd2[0]] = (UINT8)id;
- if (param && nparam)
- {
- M_Memcpy(&localtextcmd2[localtextcmd2[0]+1], param, nparam);
- localtextcmd2[0] = (UINT8)(localtextcmd2[0] + (UINT8)nparam);
- }
-}
-
-UINT8 GetFreeXCmdSize(void)
-{
- // -1 for the size and another -1 for the ID.
- return (UINT8)(localtextcmd[0] - 2);
-}
-
-// Frees all textcmd memory for the specified tic
-void D_FreeTextcmd(tic_t tic)
-{
- textcmdtic_t **tctprev = &textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
- textcmdtic_t *textcmdtic = *tctprev;
-
- while (textcmdtic && textcmdtic->tic != tic)
- {
- tctprev = &textcmdtic->next;
- textcmdtic = textcmdtic->next;
- }
-
- if (textcmdtic)
- {
- // Remove this tic from the list.
- *tctprev = textcmdtic->next;
-
- // Free all players.
- for (INT32 i = 0; i < TEXTCMD_HASH_SIZE; i++)
- {
- textcmdplayer_t *textcmdplayer = textcmdtic->playercmds[i];
-
- while (textcmdplayer)
- {
- textcmdplayer_t *tcpnext = textcmdplayer->next;
- Z_Free(textcmdplayer);
- textcmdplayer = tcpnext;
- }
- }
-
- // Free this tic's own memory.
- Z_Free(textcmdtic);
- }
-}
-
-// Gets the buffer for the specified ticcmd, or NULL if there isn't one
-UINT8* D_GetExistingTextcmd(tic_t tic, INT32 playernum)
-{
- textcmdtic_t *textcmdtic = textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
- while (textcmdtic && textcmdtic->tic != tic) textcmdtic = textcmdtic->next;
-
- // Do we have an entry for the tic? If so, look for player.
- if (textcmdtic)
- {
- textcmdplayer_t *textcmdplayer = textcmdtic->playercmds[playernum & (TEXTCMD_HASH_SIZE - 1)];
- while (textcmdplayer && textcmdplayer->playernum != playernum) textcmdplayer = textcmdplayer->next;
-
- if (textcmdplayer) return textcmdplayer->cmd;
- }
-
- return NULL;
-}
-
-// Gets the buffer for the specified ticcmd, creating one if necessary
-UINT8* D_GetTextcmd(tic_t tic, INT32 playernum)
-{
- textcmdtic_t *textcmdtic = textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
- textcmdtic_t **tctprev = &textcmds[tic & (TEXTCMD_HASH_SIZE - 1)];
- textcmdplayer_t *textcmdplayer, **tcpprev;
-
- // Look for the tic.
- while (textcmdtic && textcmdtic->tic != tic)
- {
- tctprev = &textcmdtic->next;
- textcmdtic = textcmdtic->next;
- }
-
- // If we don't have an entry for the tic, make it.
- if (!textcmdtic)
- {
- textcmdtic = *tctprev = Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL);
- textcmdtic->tic = tic;
- }
-
- tcpprev = &textcmdtic->playercmds[playernum & (TEXTCMD_HASH_SIZE - 1)];
- textcmdplayer = *tcpprev;
-
- // Look for the player.
- while (textcmdplayer && textcmdplayer->playernum != playernum)
- {
- tcpprev = &textcmdplayer->next;
- textcmdplayer = textcmdplayer->next;
- }
-
- // If we don't have an entry for the player, make it.
- if (!textcmdplayer)
- {
- textcmdplayer = *tcpprev = Z_Calloc(sizeof (textcmdplayer_t), PU_STATIC, NULL);
- textcmdplayer->playernum = playernum;
- }
-
- return textcmdplayer->cmd;
-}
-
-void ExtraDataTicker(void)
-{
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] || i == 0)
- {
- UINT8 *bufferstart = D_GetExistingTextcmd(gametic, i);
-
- if (bufferstart)
- {
- UINT8 *curpos = bufferstart;
- UINT8 *bufferend = &curpos[curpos[0]+1];
-
- curpos++;
- while (curpos < bufferend)
- {
- if (*curpos < MAXNETXCMD && listnetxcmd[*curpos])
- {
- const UINT8 id = *curpos;
- curpos++;
- DEBFILE(va("executing x_cmd %s ply %u ", netxcmdnames[id - 1], i));
- (listnetxcmd[id])(&curpos, i);
- DEBFILE("done\n");
- }
- else
- {
- if (server)
- {
- SendKick(i, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
- DEBFILE(va("player %d kicked [gametic=%u] reason as follows:\n", i, gametic));
- }
- CONS_Alert(CONS_WARNING, M_GetText("Got unknown net command [%s]=%d (max %d)\n"), sizeu1(curpos - bufferstart), *curpos, bufferstart[0]);
- break;
- }
- }
- }
- }
-
- // If you are a client, you can safely forget the net commands for this tic
- // If you are the server, you need to remember them until every client has been acknowledged,
- // because if you need to resend a PT_SERVERTICS packet, you will need to put the commands in it
- if (client)
- D_FreeTextcmd(gametic);
-}
-
-// used at txtcmds received to check packetsize bound
-size_t TotalTextCmdPerTic(tic_t tic)
-{
- size_t total = 1; // num of textcmds in the tic (ntextcmd byte)
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- UINT8 *textcmd = D_GetExistingTextcmd(tic, i);
- if ((!i || playeringame[i]) && textcmd)
- total += 2 + textcmd[0]; // "+2" for size and playernum
- }
-
- return total;
-}
-
-void PT_TextCmd(SINT8 node, INT32 netconsole)
-{
- if (client)
- return;
-
- // splitscreen special
- if (netbuffer->packettype == PT_TEXTCMD2)
- netconsole = netnodes[node].player2;
-
- if (netconsole < 0 || netconsole >= MAXPLAYERS)
- Net_UnAcknowledgePacket(node);
- else
- {
- size_t j;
- tic_t tic = maketic;
- UINT8 *textcmd;
-
- // ignore if the textcmd has a reported size of zero
- // this shouldn't be sent at all
- if (!netbuffer->u.textcmd[0])
- {
- DEBFILE(va("GetPacket: Textcmd with size 0 detected! (node %u, player %d)\n",
- node, netconsole));
- Net_UnAcknowledgePacket(node);
- return;
- }
-
- // ignore if the textcmd size var is actually larger than it should be
- // BASEPACKETSIZE + 1 (for size) + textcmd[0] should == datalength
- if (netbuffer->u.textcmd[0] > (size_t)doomcom->datalength-BASEPACKETSIZE-1)
- {
- DEBFILE(va("GetPacket: Bad Textcmd packet size! (expected %d, actual %s, node %u, player %d)\n",
- netbuffer->u.textcmd[0], sizeu1((size_t)doomcom->datalength-BASEPACKETSIZE-1),
- node, netconsole));
- Net_UnAcknowledgePacket(node);
- return;
- }
-
- // check if tic that we are making isn't too large else we cannot send it :(
- // doomcom->numslots+1 "+1" since doomcom->numslots can change within this time and sent time
- j = software_MAXPACKETLENGTH
- - (netbuffer->u.textcmd[0]+2+BASESERVERTICSSIZE
- + (doomcom->numslots+1)*sizeof(ticcmd_t));
-
- // search a tic that have enougth space in the ticcmd
- while ((textcmd = D_GetExistingTextcmd(tic, netconsole)),
- (TotalTextCmdPerTic(tic) > j || netbuffer->u.textcmd[0] + (textcmd ? textcmd[0] : 0) > MAXTEXTCMD)
- && tic < firstticstosend + BACKUPTICS)
- tic++;
-
- if (tic >= firstticstosend + BACKUPTICS)
- {
- DEBFILE(va("GetPacket: Textcmd too long (max %s, used %s, mak %d, "
- "tosend %u, node %u, player %d)\n", sizeu1(j), sizeu2(TotalTextCmdPerTic(maketic)),
- maketic, firstticstosend, node, netconsole));
- Net_UnAcknowledgePacket(node);
- return;
- }
-
- // Make sure we have a buffer
- if (!textcmd) textcmd = D_GetTextcmd(tic, netconsole);
-
- DEBFILE(va("textcmd put in tic %u at position %d (player %d) ftts %u mk %u\n",
- tic, textcmd[0]+1, netconsole, firstticstosend, maketic));
-
- M_Memcpy(&textcmd[textcmd[0]+1], netbuffer->u.textcmd+1, netbuffer->u.textcmd[0]);
- textcmd[0] += (UINT8)netbuffer->u.textcmd[0];
- }
-}
-
-void SV_WriteNetCommandsForTic(tic_t tic, UINT8 **buf)
-{
- UINT8 *numcmds;
-
- numcmds = (*buf)++;
- *numcmds = 0;
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- UINT8 *cmd = D_GetExistingTextcmd(tic, i);
- INT32 size = cmd ? cmd[0] : 0;
-
- if ((!i || playeringame[i]) && size)
- {
- (*numcmds)++;
- WRITEUINT8(*buf, i);
- M_Memcpy(*buf, cmd, size + 1);
- *buf += size + 1;
- }
- }
-}
-
-void CL_CopyNetCommandsFromServerPacket(tic_t tic)
-{
- servertics_pak *packet = &netbuffer->u.serverpak;
- UINT8 *cmds = (UINT8*)&packet->cmds[packet->numslots * packet->numtics];
- UINT8 numcmds;
-
- numcmds = *cmds++;
-
- for (UINT32 i = 0; i < numcmds; i++)
- {
- INT32 playernum = *cmds++; // playernum
- size_t size = cmds[0]+1;
-
- if (tic >= gametic) // Don't copy old net commands
- M_Memcpy(D_GetTextcmd(tic, playernum), cmds, size);
- cmds += size;
- }
-}
-
-void CL_SendNetCommands(void)
-{
- // Send extra data if needed
- if (localtextcmd[0])
- {
- netbuffer->packettype = PT_TEXTCMD;
- M_Memcpy(netbuffer->u.textcmd,localtextcmd, localtextcmd[0]+1);
- // All extra data have been sent
- if (HSendPacket(servernode, true, 0, localtextcmd[0]+1)) // Send can fail...
- localtextcmd[0] = 0;
- }
-
- // Send extra data if needed for player 2 (splitscreen)
- if (localtextcmd2[0])
- {
- netbuffer->packettype = PT_TEXTCMD2;
- M_Memcpy(netbuffer->u.textcmd, localtextcmd2, localtextcmd2[0]+1);
- // All extra data have been sent
- if (HSendPacket(servernode, true, 0, localtextcmd2[0]+1)) // Send can fail...
- localtextcmd2[0] = 0;
- }
-}
-
-void SendKick(UINT8 playernum, UINT8 msg)
-{
- UINT8 buf[2];
-
- if (!(server && cv_rejointimeout.value))
- msg &= ~KICK_MSG_KEEP_BODY;
-
- buf[0] = playernum;
- buf[1] = msg;
- SendNetXCmd(XD_KICK, &buf, 2);
-}
-
-void SendKicksForNode(SINT8 node, UINT8 msg)
-{
- if (!netnodes[node].ingame)
- return;
-
- for (INT32 playernum = netnodes[node].player; playernum != -1; playernum = netnodes[node].player2)
- if (playernum != -1 && playeringame[playernum])
- SendKick(playernum, msg);
-}
diff --git a/src/netcode/net_command.h b/src/netcode/net_command.h
deleted file mode 100644
index cc26aeb0ef39e19e818887321355e19058c5d510..0000000000000000000000000000000000000000
--- a/src/netcode/net_command.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file net_command.h
-/// \brief Net command handling
-
-#ifndef __D_NET_COMMAND__
-#define __D_NET_COMMAND__
-
-#include "d_clisrv.h"
-#include "../doomtype.h"
-
-// Must be a power of two
-#define TEXTCMD_HASH_SIZE 4
-
-typedef struct textcmdplayer_s
-{
- INT32 playernum;
- UINT8 cmd[MAXTEXTCMD];
- struct textcmdplayer_s *next;
-} textcmdplayer_t;
-
-typedef struct textcmdtic_s
-{
- tic_t tic;
- textcmdplayer_t *playercmds[TEXTCMD_HASH_SIZE];
- struct textcmdtic_s *next;
-} textcmdtic_t;
-
-extern textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE];
-
-extern UINT8 localtextcmd[MAXTEXTCMD];
-extern UINT8 localtextcmd2[MAXTEXTCMD]; // splitscreen
-
-void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum));
-void SendNetXCmd(netxcmd_t id, const void *param, size_t nparam);
-void SendNetXCmd2(netxcmd_t id, const void *param, size_t nparam); // splitsreen player
-
-UINT8 GetFreeXCmdSize(void);
-void D_FreeTextcmd(tic_t tic);
-
-// Gets the buffer for the specified ticcmd, or NULL if there isn't one
-UINT8* D_GetExistingTextcmd(tic_t tic, INT32 playernum);
-
-// Gets the buffer for the specified ticcmd, creating one if necessary
-UINT8* D_GetTextcmd(tic_t tic, INT32 playernum);
-
-void ExtraDataTicker(void);
-
-// used at txtcmds received to check packetsize bound
-size_t TotalTextCmdPerTic(tic_t tic);
-
-void PT_TextCmd(SINT8 node, INT32 netconsole);
-void SV_WriteNetCommandsForTic(tic_t tic, UINT8 **buf);
-void CL_CopyNetCommandsFromServerPacket(tic_t tic);
-void CL_SendNetCommands(void);
-void SendKick(UINT8 playernum, UINT8 msg);
-void SendKicksForNode(SINT8 node, UINT8 msg);
-
-#endif
diff --git a/src/netcode/server_connection.c b/src/netcode/server_connection.c
deleted file mode 100644
index f8ec3c7bd5d0410939bf743e52aadbccc0d5bdfb..0000000000000000000000000000000000000000
--- a/src/netcode/server_connection.c
+++ /dev/null
@@ -1,507 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file server_connection.c
-/// \brief Server-side part of connection handling
-
-#include "server_connection.h"
-#include "i_net.h"
-#include "d_clisrv.h"
-#include "d_netfil.h"
-#include "mserv.h"
-#include "net_command.h"
-#include "gamestate.h"
-#include "../byteptr.h"
-#include "../g_game.h"
-#include "../g_state.h"
-#include "../p_setup.h"
-#include "../p_tick.h"
-#include "../command.h"
-#include "../doomstat.h"
-
-// Minimum timeout for sending the savegame
-// The actual timeout will be longer depending on the savegame length
-tic_t jointimeout = (10*TICRATE);
-
-// Incremented by cv_joindelay when a client joins, decremented each tic.
-// If higher than cv_joindelay * 2 (3 joins in a short timespan), joins are temporarily disabled.
-tic_t joindelay = 0;
-
-// Minimum timeout for sending the savegame
-// The actual timeout will be longer depending on the savegame length
-char playeraddress[MAXPLAYERS][64];
-
-consvar_t cv_showjoinaddress = CVAR_INIT ("showjoinaddress", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
-
-consvar_t cv_allownewplayer = CVAR_INIT ("allowjoin", "On", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
-
-static CV_PossibleValue_t maxplayers_cons_t[] = {{2, "MIN"}, {32, "MAX"}, {0, NULL}};
-consvar_t cv_maxplayers = CVAR_INIT ("maxplayers", "8", CV_SAVE|CV_NETVAR, maxplayers_cons_t, NULL);
-
-static CV_PossibleValue_t joindelay_cons_t[] = {{1, "MIN"}, {3600, "MAX"}, {0, "Off"}, {0, NULL}};
-consvar_t cv_joindelay = CVAR_INIT ("joindelay", "10", CV_SAVE|CV_NETVAR, joindelay_cons_t, NULL);
-
-static CV_PossibleValue_t rejointimeout_cons_t[] = {{1, "MIN"}, {60 * FRACUNIT, "MAX"}, {0, "Off"}, {0, NULL}};
-consvar_t cv_rejointimeout = CVAR_INIT ("rejointimeout", "2", CV_SAVE|CV_NETVAR|CV_FLOAT, rejointimeout_cons_t, NULL);
-
-static INT32 FindRejoinerNum(SINT8 node)
-{
- char strippednodeaddress[64];
- const char *nodeaddress;
- char *port;
-
- // Make sure there is no dead dress before proceeding to the stripping
- if (!I_GetNodeAddress)
- return -1;
- nodeaddress = I_GetNodeAddress(node);
- if (!nodeaddress)
- return -1;
-
- // Strip the address of its port
- strcpy(strippednodeaddress, nodeaddress);
- port = strchr(strippednodeaddress, ':');
- if (port)
- *port = '\0';
-
- // Check if any player matches the stripped address
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (playeringame[i] && playeraddress[i][0] && playernode[i] == UINT8_MAX
- && !strcmp(playeraddress[i], strippednodeaddress))
- return i;
- }
-
- return -1;
-}
-
-static UINT8
-GetRefuseReason (INT32 node)
-{
- if (!node || FindRejoinerNum(node) != -1)
- return 0;
- else if (bannednode && bannednode[node])
- return REFUSE_BANNED;
- else if (!cv_allownewplayer.value)
- return REFUSE_JOINS_DISABLED;
- else if (D_NumPlayers() >= cv_maxplayers.value)
- return REFUSE_SLOTS_FULL;
- else
- return 0;
-}
-
-static void SV_SendServerInfo(INT32 node, tic_t servertime)
-{
- UINT8 *p;
-
- netbuffer->packettype = PT_SERVERINFO;
- netbuffer->u.serverinfo._255 = 255;
- netbuffer->u.serverinfo.packetversion = PACKETVERSION;
- netbuffer->u.serverinfo.version = VERSION;
- netbuffer->u.serverinfo.subversion = SUBVERSION;
- strncpy(netbuffer->u.serverinfo.application, SRB2APPLICATION,
- sizeof netbuffer->u.serverinfo.application);
- // return back the time value so client can compute their ping
- netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
- netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
-
- netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
- netbuffer->u.serverinfo.maxplayer = (UINT8)cv_maxplayers.value;
-
- netbuffer->u.serverinfo.refusereason = GetRefuseReason(node);
-
- strncpy(netbuffer->u.serverinfo.gametypename, Gametype_Names[gametype],
- sizeof netbuffer->u.serverinfo.gametypename);
- netbuffer->u.serverinfo.modifiedgame = (UINT8)modifiedgame;
- netbuffer->u.serverinfo.cheatsenabled = CV_CheatsEnabled();
- netbuffer->u.serverinfo.flags = (dedicated ? SV_DEDICATED : 0);
- strncpy(netbuffer->u.serverinfo.servername, cv_servername.string,
- MAXSERVERNAME);
- strncpy(netbuffer->u.serverinfo.mapname, G_BuildMapName(gamemap), 7);
-
- M_Memcpy(netbuffer->u.serverinfo.mapmd5, mapmd5, 16);
-
- memset(netbuffer->u.serverinfo.maptitle, 0, sizeof netbuffer->u.serverinfo.maptitle);
-
- if (mapheaderinfo[gamemap-1] && *mapheaderinfo[gamemap-1]->lvlttl)
- {
- char *read = mapheaderinfo[gamemap-1]->lvlttl, *writ = netbuffer->u.serverinfo.maptitle;
- while (writ < (netbuffer->u.serverinfo.maptitle+32) && *read != '\0')
- {
- if (!(*read & 0x80))
- {
- *writ = toupper(*read);
- writ++;
- }
- read++;
- }
- *writ = '\0';
- //strncpy(netbuffer->u.serverinfo.maptitle, (char *)mapheaderinfo[gamemap-1]->lvlttl, 33);
- }
- else
- strncpy(netbuffer->u.serverinfo.maptitle, "UNKNOWN", 32);
-
- if (mapheaderinfo[gamemap-1] && !(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
- netbuffer->u.serverinfo.iszone = 1;
- else
- netbuffer->u.serverinfo.iszone = 0;
-
- if (mapheaderinfo[gamemap-1])
- netbuffer->u.serverinfo.actnum = mapheaderinfo[gamemap-1]->actnum;
-
- p = PutFileNeeded(0);
-
- HSendPacket(node, false, 0, p - ((UINT8 *)&netbuffer->u));
-}
-
-static void SV_SendPlayerInfo(INT32 node)
-{
- netbuffer->packettype = PT_PLAYERINFO;
-
- for (UINT8 i = 0; i < MAXPLAYERS; i++)
- {
- if (!playeringame[i])
- {
- netbuffer->u.playerinfo[i].num = 255; // This slot is empty.
- continue;
- }
-
- netbuffer->u.playerinfo[i].num = i;
- strncpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
- netbuffer->u.playerinfo[i].name[MAXPLAYERNAME] = '\0';
-
- //fetch IP address
- //No, don't do that, you fuckface.
- memset(netbuffer->u.playerinfo[i].address, 0, 4);
-
- if (G_GametypeHasTeams())
- {
- if (!players[i].ctfteam)
- netbuffer->u.playerinfo[i].team = 255;
- else
- netbuffer->u.playerinfo[i].team = (UINT8)players[i].ctfteam;
- }
- else
- {
- if (players[i].spectator)
- netbuffer->u.playerinfo[i].team = 255;
- else
- netbuffer->u.playerinfo[i].team = 0;
- }
-
- netbuffer->u.playerinfo[i].score = LONG(players[i].score);
- netbuffer->u.playerinfo[i].timeinserver = SHORT((UINT16)(players[i].jointime / TICRATE));
- netbuffer->u.playerinfo[i].skin = (UINT8)(players[i].skin
-#ifdef DEVELOP // it's safe to do this only because PLAYERINFO isn't read by the game itself
- % 3
-#endif
- );
-
- // Extra data
- netbuffer->u.playerinfo[i].data = 0; //players[i].skincolor;
-
- if (players[i].pflags & PF_TAGIT)
- netbuffer->u.playerinfo[i].data |= 0x20;
-
- if (players[i].gotflag)
- netbuffer->u.playerinfo[i].data |= 0x40;
-
- if (players[i].powers[pw_super])
- netbuffer->u.playerinfo[i].data |= 0x80;
- }
-
- HSendPacket(node, false, 0, sizeof(plrinfo_pak) * MAXPLAYERS);
-}
-
-/** Sends a PT_SERVERCFG packet
- *
- * \param node The destination
- * \return True if the packet was successfully sent
- *
- */
-static boolean SV_SendServerConfig(INT32 node)
-{
- boolean waspacketsent;
-
- netbuffer->packettype = PT_SERVERCFG;
-
- netbuffer->u.servercfg.serverplayer = (UINT8)serverplayer;
- netbuffer->u.servercfg.totalslotnum = (UINT8)(doomcom->numslots);
- netbuffer->u.servercfg.gametic = (tic_t)LONG(gametic);
- netbuffer->u.servercfg.clientnode = (UINT8)node;
- netbuffer->u.servercfg.gamestate = (UINT8)gamestate;
- netbuffer->u.servercfg.gametype = (UINT8)gametype;
- netbuffer->u.servercfg.modifiedgame = (UINT8)modifiedgame;
-
- memcpy(netbuffer->u.servercfg.server_context, server_context, 8);
-
- {
- const size_t len = sizeof (serverconfig_pak);
-
-#ifdef DEBUGFILE
- if (debugfile)
- {
- fprintf(debugfile, "ServerConfig Packet about to be sent, size of packet:%s to node:%d\n",
- sizeu1(len), node);
- }
-#endif
-
- waspacketsent = HSendPacket(node, true, 0, len);
- }
-
-#ifdef DEBUGFILE
- if (debugfile)
- {
- if (waspacketsent)
- {
- fprintf(debugfile, "ServerConfig Packet was sent\n");
- }
- else
- {
- fprintf(debugfile, "ServerConfig Packet could not be sent right now\n");
- }
- }
-#endif
-
- return waspacketsent;
-}
-
-// Adds a node to the game (player will follow at map change or at savegame....)
-static inline void SV_AddNode(INT32 node)
-{
- netnodes[node].tic = gametic;
- netnodes[node].supposedtic = gametic;
- // little hack because the server connects to itself and puts
- // nodeingame when connected not here
- if (node)
- netnodes[node].ingame = true;
-}
-
-static void SV_AddPlayer(SINT8 node, const char *name)
-{
- INT32 n;
- UINT8 buf[2 + MAXPLAYERNAME];
- UINT8 *p;
- INT32 newplayernum;
-
- newplayernum = FindRejoinerNum(node);
- if (newplayernum == -1)
- {
- // search for a free playernum
- // we can't use playeringame since it is not updated here
- for (newplayernum = dedicated ? 1 : 0; newplayernum < MAXPLAYERS; newplayernum++)
- {
- if (playeringame[newplayernum])
- continue;
- for (n = 0; n < MAXNETNODES; n++)
- if (netnodes[n].player == newplayernum || netnodes[n].player2 == newplayernum)
- break;
- if (n == MAXNETNODES)
- break;
- }
- }
-
- // should never happen since we check the playernum
- // before accepting the join
- I_Assert(newplayernum < MAXPLAYERS);
-
- playernode[newplayernum] = (UINT8)node;
-
- p = buf + 2;
- buf[0] = (UINT8)node;
- buf[1] = newplayernum;
- if (netnodes[node].numplayers < 1)
- {
- netnodes[node].player = newplayernum;
- }
- else
- {
- netnodes[node].player2 = newplayernum;
- buf[1] |= 0x80;
- }
- WRITESTRINGN(p, name, MAXPLAYERNAME);
- netnodes[node].numplayers++;
-
- SendNetXCmd(XD_ADDPLAYER, &buf, p - buf);
-
- DEBFILE(va("Server added player %d node %d\n", newplayernum, node));
-}
-
-static void SV_SendRefuse(INT32 node, const char *reason)
-{
- strcpy(netbuffer->u.serverrefuse.reason, reason);
-
- netbuffer->packettype = PT_SERVERREFUSE;
- HSendPacket(node, true, 0, strlen(netbuffer->u.serverrefuse.reason) + 1);
- Net_CloseConnection(node);
-}
-
-static const char *
-GetRefuseMessage (SINT8 node, INT32 rejoinernum)
-{
- clientconfig_pak *cc = &netbuffer->u.clientcfg;
-
- boolean rejoining = (rejoinernum != -1);
-
- if (!node)/* server connecting to itself */
- return NULL;
-
- if (
- cc->modversion != MODVERSION ||
- strncmp(cc->application, SRB2APPLICATION,
- sizeof cc->application)
- ){
- return/* this is probably client's fault */
- "Incompatible.";
- }
- else if (bannednode && bannednode[node])
- {
- return
- "You have been banned\n"
- "from the server.";
- }
- else if (cc->localplayers != 1)
- {
- return
- "Wrong player count.";
- }
-
- if (!rejoining)
- {
- if (!cv_allownewplayer.value)
- {
- return
- "The server is not accepting\n"
- "joins for the moment.";
- }
- else if (D_NumPlayers() >= cv_maxplayers.value)
- {
- return va(
- "Maximum players reached: %d",
- cv_maxplayers.value);
- }
- }
-
- if (luafiletransfers)
- {
- return
- "The serveris broadcasting a file\n"
- "requested by a Lua script.\n"
- "Please wait a bit and then\n"
- "try rejoining.";
- }
-
- if (netgame)
- {
- const tic_t th = 2 * cv_joindelay.value * TICRATE;
-
- if (joindelay > th)
- {
- return va(
- "Too many people are connecting.\n"
- "Please wait %d seconds and then\n"
- "try rejoining.",
- (joindelay - th) / TICRATE);
- }
- }
-
- return NULL;
-}
-
-/** Called when a PT_CLIENTJOIN packet is received
- *
- * \param node The packet sender
- *
- */
-void PT_ClientJoin(SINT8 node)
-{
- char names[MAXSPLITSCREENPLAYERS][MAXPLAYERNAME + 1];
- INT32 numplayers = netbuffer->u.clientcfg.localplayers;
- INT32 rejoinernum;
-
- // Ignore duplicate packets
- if (client || netnodes[node].ingame)
- return;
-
- rejoinernum = FindRejoinerNum(node);
-
- const char *refuse = GetRefuseMessage(node, rejoinernum);
- if (refuse)
- {
- SV_SendRefuse(node, refuse);
- return;
- }
-
- for (INT32 i = 0; i < numplayers; i++)
- {
- strlcpy(names[i], netbuffer->u.clientcfg.names[i], MAXPLAYERNAME + 1);
- if (!EnsurePlayerNameIsGood(names[i], rejoinernum))
- {
- SV_SendRefuse(node, "Bad player name");
- return;
- }
- }
-
- SV_AddNode(node);
-
- if (!SV_SendServerConfig(node))
- {
- /// \note Shouldn't SV_SendRefuse be called before ResetNode?
- ResetNode(node);
- SV_SendRefuse(node, M_GetText("Server couldn't send info, please try again"));
- /// \todo fix this !!!
- return;
- }
- DEBFILE("new node joined\n");
-
- if (gamestate == GS_LEVEL || gamestate == GS_INTERMISSION)
- {
- SV_SendSaveGame(node, false); // send a complete game state
- DEBFILE("send savegame\n");
- }
-
- // Splitscreen can allow 2 players in one node
- for (INT32 i = 0; i < numplayers; i++)
- SV_AddPlayer(node, names[i]);
-
- joindelay += cv_joindelay.value * TICRATE;
-}
-
-void PT_AskInfoViaMS(SINT8 node)
-{
- Net_CloseConnection(node);
-}
-
-void PT_TellFilesNeeded(SINT8 node)
-{
- if (server && serverrunning)
- {
- UINT8 *p;
- INT32 firstfile = netbuffer->u.filesneedednum;
-
- netbuffer->packettype = PT_MOREFILESNEEDED;
- netbuffer->u.filesneededcfg.first = firstfile;
- netbuffer->u.filesneededcfg.more = 0;
-
- p = PutFileNeeded(firstfile);
-
- HSendPacket(node, false, 0, p - ((UINT8 *)&netbuffer->u));
- }
- else // Shouldn't get this if you aren't the server...?
- Net_CloseConnection(node);
-}
-
-void PT_AskInfo(SINT8 node)
-{
- if (server && serverrunning)
- {
- SV_SendServerInfo(node, (tic_t)LONG(netbuffer->u.askinfo.time));
- SV_SendPlayerInfo(node); // Send extra info
- }
- Net_CloseConnection(node);
-}
diff --git a/src/netcode/server_connection.h b/src/netcode/server_connection.h
deleted file mode 100644
index 7481d0eb56e365b6ceba24b46e4245e26aceb715..0000000000000000000000000000000000000000
--- a/src/netcode/server_connection.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file server_connection.h
-/// \brief Server-side part of connection handling
-
-#ifndef __D_SERVER_CONNECTION__
-#define __D_SERVER_CONNECTION__
-
-#include "../command.h"
-#include "../doomdef.h"
-#include "../doomtype.h"
-
-void PT_ClientJoin(SINT8 node);
-void PT_AskInfoViaMS(SINT8 node);
-void PT_TellFilesNeeded(SINT8 node);
-void PT_AskInfo(SINT8 node);
-
-extern tic_t jointimeout;
-extern tic_t joindelay;
-extern char playeraddress[MAXPLAYERS][64];
-extern consvar_t cv_showjoinaddress, cv_allownewplayer, cv_maxplayers, cv_joindelay, cv_rejointimeout;
-
-#endif
diff --git a/src/netcode/tic_command.c b/src/netcode/tic_command.c
deleted file mode 100644
index 620a10f7a26be5b17b88f2002a4f54ecd7f4c0b6..0000000000000000000000000000000000000000
--- a/src/netcode/tic_command.c
+++ /dev/null
@@ -1,454 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file tic_command.c
-/// \brief Tic command handling
-
-#include "tic_command.h"
-#include "d_clisrv.h"
-#include "net_command.h"
-#include "client_connection.h"
-#include "gamestate.h"
-#include "i_net.h"
-#include "../d_main.h"
-#include "../g_game.h"
-#include "../i_system.h"
-#include "../i_time.h"
-#include "../byteptr.h"
-#include "../doomstat.h"
-#include "../doomtype.h"
-
-tic_t firstticstosend; // Smallest netnode.tic
-tic_t tictoclear = 0; // Optimize D_ClearTiccmd
-ticcmd_t localcmds;
-ticcmd_t localcmds2;
-boolean cl_packetmissed;
-ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS];
-
-static inline void *G_DcpyTiccmd(void* dest, const ticcmd_t* src, const size_t n)
-{
- const size_t d = n / sizeof(ticcmd_t);
- const size_t r = n % sizeof(ticcmd_t);
- UINT8 *ret = dest;
-
- if (r)
- M_Memcpy(dest, src, n);
- else if (d)
- G_MoveTiccmd(dest, src, d);
- return ret+n;
-}
-
-static inline void *G_ScpyTiccmd(ticcmd_t* dest, void* src, const size_t n)
-{
- const size_t d = n / sizeof(ticcmd_t);
- const size_t r = n % sizeof(ticcmd_t);
- UINT8 *ret = src;
-
- if (r)
- M_Memcpy(dest, src, n);
- else if (d)
- G_MoveTiccmd(dest, src, d);
- return ret+n;
-}
-
-/** Guesses the full value of a tic from its lowest byte, for a specific node
- *
- * \param low The lowest byte of the tic value
- * \param node The node to deduce the tic for
- * \return The full tic value
- *
- */
-tic_t ExpandTics(INT32 low, INT32 node)
-{
- INT32 delta;
-
- delta = low - (netnodes[node].tic & UINT8_MAX);
-
- if (delta >= -64 && delta <= 64)
- return (netnodes[node].tic & ~UINT8_MAX) + low;
- else if (delta > 64)
- return (netnodes[node].tic & ~UINT8_MAX) - 256 + low;
- else //if (delta < -64)
- return (netnodes[node].tic & ~UINT8_MAX) + 256 + low;
-}
-
-void D_Clearticcmd(tic_t tic)
-{
- D_FreeTextcmd(tic);
-
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- netcmds[tic%BACKUPTICS][i].angleturn = 0;
-
- DEBFILE(va("clear tic %5u (%2u)\n", tic, tic%BACKUPTICS));
-}
-
-void D_ResetTiccmds(void)
-{
- memset(&localcmds, 0, sizeof(ticcmd_t));
- memset(&localcmds2, 0, sizeof(ticcmd_t));
-
- // Reset the net command list
- for (INT32 i = 0; i < TEXTCMD_HASH_SIZE; i++)
- while (textcmds[i])
- D_Clearticcmd(textcmds[i]->tic);
-}
-
-// Check ticcmd for "speed hacks"
-static void CheckTiccmdHacks(INT32 playernum)
-{
- ticcmd_t *cmd = &netcmds[maketic%BACKUPTICS][playernum];
- if (cmd->forwardmove > MAXPLMOVE || cmd->forwardmove < -MAXPLMOVE
- || cmd->sidemove > MAXPLMOVE || cmd->sidemove < -MAXPLMOVE)
- {
- CONS_Alert(CONS_WARNING, M_GetText("Illegal movement value received from node %d\n"), playernum);
- SendKick(playernum, KICK_MSG_CON_FAIL);
- }
-}
-
-// Check player consistancy during the level
-static void CheckConsistancy(SINT8 nodenum, tic_t tic)
-{
- netnode_t *node = &netnodes[nodenum];
- INT16 neededconsistancy = consistancy[tic%BACKUPTICS];
- INT16 clientconsistancy = SHORT(netbuffer->u.clientpak.consistancy);
-
- if (tic > gametic || tic + BACKUPTICS - 1 <= gametic || gamestate != GS_LEVEL
- || neededconsistancy == clientconsistancy || SV_ResendingSavegameToAnyone()
- || node->resendingsavegame || node->savegameresendcooldown > I_GetTime())
- return;
-
- if (cv_resynchattempts.value)
- {
- // Tell the client we are about to resend them the gamestate
- netbuffer->packettype = PT_WILLRESENDGAMESTATE;
- HSendPacket(nodenum, true, 0, 0);
-
- node->resendingsavegame = true;
-
- if (cv_blamecfail.value)
- CONS_Printf(M_GetText("Synch failure for player %d (%s); expected %hd, got %hd\n"),
- node->player+1, player_names[node->player],
- neededconsistancy, clientconsistancy);
-
- DEBFILE(va("Restoring player %d (synch failure) [%update] %d!=%d\n",
- node->player, tic, neededconsistancy, clientconsistancy));
- }
- else
- {
- SendKick(node->player, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
-
- DEBFILE(va("player %d kicked (synch failure) [%u] %d!=%d\n",
- node->player, tic, neededconsistancy, clientconsistancy));
- }
-}
-
-void PT_ClientCmd(SINT8 nodenum, INT32 netconsole)
-{
- netnode_t *node = &netnodes[nodenum];
- tic_t realend, realstart;
-
- if (client)
- return;
-
- // To save bytes, only the low byte of tic numbers are sent
- // Use ExpandTics to figure out what the rest of the bytes are
- realstart = ExpandTics(netbuffer->u.clientpak.client_tic, nodenum);
- realend = ExpandTics(netbuffer->u.clientpak.resendfrom, nodenum);
-
- if (netbuffer->packettype == PT_CLIENTMIS || netbuffer->packettype == PT_CLIENT2MIS
- || netbuffer->packettype == PT_NODEKEEPALIVEMIS
- || node->supposedtic < realend)
- {
- node->supposedtic = realend;
- }
- // Discard out of order packet
- if (node->tic > realend)
- {
- DEBFILE(va("out of order ticcmd discarded nettics = %u\n", node->tic));
- return;
- }
-
- // Update the nettics
- node->tic = realend;
-
- // Don't do anything for packets of type NODEKEEPALIVE?
- if (netconsole == -1 || netbuffer->packettype == PT_NODEKEEPALIVE
- || netbuffer->packettype == PT_NODEKEEPALIVEMIS)
- return;
-
- // As long as clients send valid ticcmds, the server can keep running, so reset the timeout
- /// \todo Use a separate cvar for that kind of timeout?
- node->freezetimeout = I_GetTime() + connectiontimeout;
-
- // Copy ticcmd
- G_MoveTiccmd(&netcmds[maketic%BACKUPTICS][netconsole], &netbuffer->u.clientpak.cmd, 1);
-
- // Splitscreen cmd
- if ((netbuffer->packettype == PT_CLIENT2CMD || netbuffer->packettype == PT_CLIENT2MIS)
- && node->player2 >= 0)
- G_MoveTiccmd(&netcmds[maketic%BACKUPTICS][(UINT8)node->player2],
- &netbuffer->u.client2pak.cmd2, 1);
-
- CheckTiccmdHacks(netconsole);
- CheckConsistancy(nodenum, realstart);
-}
-
-void PT_ServerTics(SINT8 node, INT32 netconsole)
-{
- tic_t realend, realstart;
-
- if (!netnodes[node].ingame)
- {
- // Do not remove my own server (we have just get a out of order packet)
- if (node != servernode)
- {
- DEBFILE(va("unknown packet received (%d) from unknown host\n",netbuffer->packettype));
- Net_CloseConnection(node);
- }
- return;
- }
-
- // Only accept PT_SERVERTICS from the server.
- if (node != servernode)
- {
- CONS_Alert(CONS_WARNING, M_GetText("%s received from non-host %d\n"), "PT_SERVERTICS", node);
- if (server)
- SendKick(netconsole, KICK_MSG_CON_FAIL | KICK_MSG_KEEP_BODY);
- return;
- }
-
- realstart = netbuffer->u.serverpak.starttic;
- realend = realstart + netbuffer->u.serverpak.numtics;
-
- realend = min(realend, gametic + CLIENTBACKUPTICS);
- cl_packetmissed = realstart > neededtic;
-
- if (realstart <= neededtic && realend > neededtic)
- {
- UINT8 *pak = (UINT8 *)&netbuffer->u.serverpak.cmds;
-
- for (tic_t i = realstart; i < realend; i++)
- {
- // clear first
- D_Clearticcmd(i);
-
- // copy the tics
- pak = G_ScpyTiccmd(netcmds[i%BACKUPTICS], pak,
- netbuffer->u.serverpak.numslots*sizeof (ticcmd_t));
-
- CL_CopyNetCommandsFromServerPacket(i);
- }
-
- neededtic = realend;
- }
- else
- {
- DEBFILE(va("frame not in bound: %u\n", neededtic));
- }
-}
-
-// send the client packet to the server
-void CL_SendClientCmd(void)
-{
- size_t packetsize = 0;
-
- netbuffer->packettype = PT_CLIENTCMD;
-
- if (cl_packetmissed)
- netbuffer->packettype++;
- netbuffer->u.clientpak.resendfrom = (UINT8)(neededtic & UINT8_MAX);
- netbuffer->u.clientpak.client_tic = (UINT8)(gametic & UINT8_MAX);
-
- if (gamestate == GS_WAITINGPLAYERS)
- {
- // Send PT_NODEKEEPALIVE packet
- netbuffer->packettype += 4;
- packetsize = sizeof (clientcmd_pak) - sizeof (ticcmd_t) - sizeof (INT16);
- HSendPacket(servernode, false, 0, packetsize);
- }
- else if (gamestate != GS_NULL && (addedtogame || dedicated))
- {
- G_MoveTiccmd(&netbuffer->u.clientpak.cmd, &localcmds, 1);
- netbuffer->u.clientpak.consistancy = SHORT(consistancy[gametic%BACKUPTICS]);
-
- // Send a special packet with 2 cmd for splitscreen
- if (splitscreen || botingame)
- {
- netbuffer->packettype += 2;
- G_MoveTiccmd(&netbuffer->u.client2pak.cmd2, &localcmds2, 1);
- packetsize = sizeof (client2cmd_pak);
- }
- else
- packetsize = sizeof (clientcmd_pak);
-
- HSendPacket(servernode, false, 0, packetsize);
- }
-
- if (cl_mode == CL_CONNECTED || dedicated)
- CL_SendNetCommands();
-}
-
-// PT_SERVERTICS packets can grow too large for a single UDP packet,
-// So this checks how many tics worth of data can be sent in one packet.
-// The rest can be sent later, usually the next tic.
-static tic_t SV_CalculateNumTicsForPacket(SINT8 nodenum, tic_t firsttic, tic_t lasttic)
-{
- size_t size = BASESERVERTICSSIZE;
-
- for (tic_t tic = firsttic; tic < lasttic; tic++)
- {
- size += sizeof (ticcmd_t) * doomcom->numslots;
- size += TotalTextCmdPerTic(tic);
-
- if (size > software_MAXPACKETLENGTH)
- {
- DEBFILE(va("packet too large (%s) at tic %d (should be from %d to %d)\n",
- sizeu1(size), tic, firsttic, lasttic));
- lasttic = tic;
-
- // Too bad: too many players have sent extra data
- // and there is too much data for a single tic.
- // To avoid that, keep the data for the next tic (see PT_TEXTCMD).
- if (lasttic == firsttic)
- {
- if (size > MAXPACKETLENGTH)
- I_Error("Too many players: can't send %s data for %d players to node %d\n"
- "Well sorry nobody is perfect....\n",
- sizeu1(size), doomcom->numslots, nodenum);
- else
- {
- lasttic++; // send it anyway!
- DEBFILE("sending it anyway\n");
- }
- }
- break;
- }
- }
-
- return lasttic - firsttic;
-}
-
-// Sends the server packet
-// Sends tic/net commands from firstticstosend to maketic-1
-void SV_SendTics(void)
-{
- tic_t realfirsttic, lasttictosend;
-
- // Send to all clients except yourself
- // For each node, create a packet with x tics and send it
- // x is computed using node.supposedtic, max packet size and maketic
- for (INT32 n = 1; n < MAXNETNODES; n++)
- if (netnodes[n].ingame)
- {
- netnode_t *node = netnodes[n];
-
- // assert node->supposedtic>=node->tic
- realfirsttic = node->supposedtic;
- lasttictosend = min(maketic, node->tic + CLIENTBACKUPTICS);
-
- if (realfirsttic >= lasttictosend)
- {
- // Well, we have sent all the tics, so we will use extra bandwidth
- // to resend packets that are supposed lost.
- // This is necessary since lost packet detection
- // works when we receive a packet with firsttic > neededtic (PT_SERVERTICS)
- DEBFILE(va("Nothing to send node %u mak=%u sup=%u net=%u \n",
- n, maketic, node->supposedtic, node->tic));
-
- realfirsttic = node->tic;
-
- if (realfirsttic >= lasttictosend || (I_GetTime() + n)&3)
- // All tics are Ok
- continue;
-
- DEBFILE(va("Sent %d anyway\n", realfirsttic));
- }
- realfirsttic = max(realfirsttic, firstticstosend);
-
- lasttictosend = realfirsttic + SV_CalculateNumTicsForPacket(n, realfirsttic, lasttictosend);
-
- // Prepare the packet header
- netbuffer->packettype = PT_SERVERTICS;
- netbuffer->u.serverpak.starttic = realfirsttic;
- netbuffer->u.serverpak.numtics = (UINT8)(lasttictosend - realfirsttic);
- netbuffer->u.serverpak.numslots = (UINT8)SHORT(doomcom->numslots);
-
- // Fill and send the packet
- UINT8 *bufpos = (UINT8 *)&netbuffer->u.serverpak.cmds;
- for (tic_t i = realfirsttic; i < lasttictosend; i++)
- bufpos = G_DcpyTiccmd(bufpos, netcmds[i%BACKUPTICS], doomcom->numslots * sizeof (ticcmd_t));
- for (tic_t i = realfirsttic; i < lasttictosend; i++)
- SV_WriteNetCommandsForTic(i, &bufpos);
- size_t packsize = bufpos - (UINT8 *)&(netbuffer->u);
- HSendPacket(n, false, 0, packsize);
-
- // When tics are too large, only one tic is sent so don't go backwards!
- if (lasttictosend-doomcom->extratics > realfirsttic)
- node->supposedtic = lasttictosend-doomcom->extratics;
- else
- node->supposedtic = lasttictosend;
- node->supposedtic = max(node->supposedtic, node->tic);
- }
-
- // node 0 is me!
- netnodes[0].supposedtic = maketic;
-}
-
-void Local_Maketic(INT32 realtics)
-{
- I_OsPolling(); // I_Getevent
- D_ProcessEvents(); // menu responder, cons responder,
- // game responder calls HU_Responder, AM_Responder,
- // and G_MapEventsToControls
- if (!dedicated)
- rendergametic = gametic;
- // translate inputs (keyboard/mouse/gamepad) into game controls
- G_BuildTiccmd(&localcmds, realtics, 1);
- if (splitscreen || botingame)
- G_BuildTiccmd(&localcmds2, realtics, 2);
-
- localcmds.angleturn |= TICCMD_RECEIVED;
- localcmds2.angleturn |= TICCMD_RECEIVED;
-}
-
-// create missed tic
-void SV_Maketic(void)
-{
- for (INT32 i = 0; i < MAXPLAYERS; i++)
- {
- if (!playeringame[i])
- continue;
-
- // We didn't receive this tic
- if ((netcmds[maketic % BACKUPTICS][i].angleturn & TICCMD_RECEIVED) == 0)
- {
- ticcmd_t * ticcmd = &netcmds[(maketic ) % BACKUPTICS][i];
- ticcmd_t *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i];
-
- if (players[i].quittime)
- {
- // Copy the angle/aiming from the previous tic
- // and empty the other inputs
- memset(ticcmd, 0, sizeof(netcmds[0][0]));
- ticcmd->angleturn = prevticcmd->angleturn | TICCMD_RECEIVED;
- ticcmd->aiming = prevticcmd->aiming;
- }
- else
- {
- DEBFILE(va("MISS tic%4d for player %d\n", maketic, i));
- // Copy the input from the previous tic
- *ticcmd = *prevticcmd;
- ticcmd->angleturn &= ~TICCMD_RECEIVED;
- }
- }
- }
-
- // All tics have been processed, make the next
- maketic++;
-}
diff --git a/src/netcode/tic_command.h b/src/netcode/tic_command.h
deleted file mode 100644
index 289750fb3083bfa75af7ea7070c7865bb6564074..0000000000000000000000000000000000000000
--- a/src/netcode/tic_command.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2022 by Sonic Team Junior.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file tic_command.h
-/// \brief Tic command handling
-
-#ifndef __D_TIC_COMMAND__
-#define __D_TIC_COMMAND__
-
-#include "d_clisrv.h"
-#include "../d_ticcmd.h"
-#include "../doomdef.h"
-#include "../doomtype.h"
-
-extern tic_t firstticstosend; // min of the nettics
-extern tic_t tictoclear; // optimize d_clearticcmd
-
-extern ticcmd_t localcmds;
-extern ticcmd_t localcmds2;
-extern boolean cl_packetmissed;
-
-extern ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS];
-
-tic_t ExpandTics(INT32 low, INT32 node);
-void D_Clearticcmd(tic_t tic);
-void D_ResetTiccmds(void);
-
-void PT_ClientCmd(SINT8 nodenum, INT32 netconsole);
-void PT_ServerTics(SINT8 node, INT32 netconsole);
-
-// send the client packet to the server
-void CL_SendClientCmd(void);
-
-void SV_SendTics(void);
-void Local_Maketic(INT32 realtics);
-void SV_Maketic(void);
-
-#endif
diff --git a/src/p_ceilng.c b/src/p_ceilng.c
index 949eeddf2ec373f0809eb643693d0ba78b596688..66f2dd58ecfba7e346d746166f31f8edb942c77a 100644
--- a/src/p_ceilng.c
+++ b/src/p_ceilng.c
@@ -17,7 +17,7 @@
#include "r_main.h"
#include "s_sound.h"
#include "z_zone.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
// ==========================================================================
// CEILINGS
diff --git a/src/p_haptic.c b/src/p_haptic.c
index 4d22fbd777616a0b92b71e3d97aa3b78a1cbab3a..dbfa587379edbd32f9196b7501273fd6811ed596 100644
--- a/src/p_haptic.c
+++ b/src/p_haptic.c
@@ -11,7 +11,7 @@
#include "p_haptic.h"
#include "g_game.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "i_gamepad.h"
#include "doomstat.h"
diff --git a/src/p_inter.c b/src/p_inter.c
index f33494d1f21c13e960c59769640e673138003103..f3c13e3151b145cd059efe1247da759c6e98cf98 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -30,7 +30,6 @@
#include "m_misc.h"
#include "v_video.h" // video flags for CEchos
#include "f_finale.h"
-#include "netcode/net_command.h"
// CTF player names
#define CTFTEAMCODE(pl) pl->ctfteam ? (pl->ctfteam == 1 ? "\x85" : "\x84") : ""
diff --git a/src/p_lights.c b/src/p_lights.c
index a1f4de853f05ac3d894e5286980beaf74ae3fe92..4c783f884edd5f322dd86e1e7270e462f757383a 100644
--- a/src/p_lights.c
+++ b/src/p_lights.c
@@ -17,7 +17,7 @@
#include "r_state.h"
#include "z_zone.h"
#include "m_random.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
/** Removes any active lighting effects in a sector.
*
diff --git a/src/p_mobj.c b/src/p_mobj.c
index daf8e026237f3ad1d9a940eb008a79c8411ae93d..c14ffb251296789708b92a2dac2baffdff4d0e1e 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -36,7 +36,6 @@
#include "p_slopes.h"
#include "f_finale.h"
#include "m_cond.h"
-#include "netcode/net_command.h"
static CV_PossibleValue_t CV_BobSpeed[] = {{0, "MIN"}, {4*FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_movebob = CVAR_INIT ("movebob", "1.0", CV_FLOAT|CV_SAVE, CV_BobSpeed, NULL);
diff --git a/src/p_setup.c b/src/p_setup.c
index 916fb7524dd8dc3cc005e2094572152850110eba..d7b532282c05bfc3fc56003ebeb04637135a72af 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -87,8 +87,6 @@
#include "taglist.h"
-#include "netcode/net_command.h"
-
//
// Map MD5, calculated on level load.
// Sent to clients in PT_SERVERINFO.
diff --git a/src/p_tick.c b/src/p_tick.c
index e92dfe8e4793eda74db64fcc2b5568060c76f052..fe6a4d33f28639f11c10f836dcad6ce8e88762b9 100644
--- a/src/p_tick.c
+++ b/src/p_tick.c
@@ -26,8 +26,6 @@
#include "r_main.h"
#include "r_fps.h"
#include "i_video.h" // rendermode
-#include "netcode/net_command.h"
-#include "netcode/server_connection.h"
// Object place
#include "m_cheat.h"
diff --git a/src/p_user.c b/src/p_user.c
index de3bd0af21dcabbc285c6b4a100ff97e6a9e99a6..4ca4e6c8ad7b5fdc18b036197da5e1bed5a48794 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -18,8 +18,7 @@
#include "doomdef.h"
#include "i_system.h"
#include "d_event.h"
-#include "netcode/d_net.h"
-#include "netcode/net_command.h"
+#include "d_net.h"
#include "g_game.h"
#include "p_local.h"
#include "r_fps.h"
diff --git a/src/r_segs.c b/src/r_segs.c
index 704f333342a70c0170ce474e0139c9fcfc78fe48..43a7f945fd37bdfde19ed0857a24f402270a7fda 100644
--- a/src/r_segs.c
+++ b/src/r_segs.c
@@ -20,7 +20,7 @@
#include "w_wad.h"
#include "z_zone.h"
-#include "netcode/d_netcmd.h"
+#include "d_netcmd.h"
#include "m_misc.h"
#include "p_local.h" // Camera...
#include "p_slopes.h"
diff --git a/src/r_things.c b/src/r_things.c
index 5e444d0b917cfeaf36fa8031905fa35dc17b42c0..4617619773228afa486a5fa0178598adc368410c 100644
--- a/src/r_things.c
+++ b/src/r_things.c
@@ -34,7 +34,7 @@
#include "p_tick.h"
#include "p_local.h"
#include "p_slopes.h"
-#include "netcode/d_netfil.h" // blargh. for nameonly().
+#include "d_netfil.h" // blargh. for nameonly().
#include "m_cheat.h" // objectplace
#ifdef HWRENDER
#include "hardware/hw_md2.h"
diff --git a/src/screen.c b/src/screen.c
index ad9c91462f58a3acfd8e94a8052b1aff792f67b0..d4785f94113ac918827bb9bf470950d226cf4a41 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -27,7 +27,7 @@
#include "hu_stuff.h"
#include "z_zone.h"
#include "d_main.h"
-#include "netcode/d_clisrv.h"
+#include "d_clisrv.h"
#include "f_finale.h"
#include "y_inter.h" // usebuffer
#include "i_sound.h" // closed captions
diff --git a/src/sdl/i_gamepad.c b/src/sdl/i_gamepad.c
index f27504f7667a225beccdfd15a21da4de6b03c082..ecde251fba5e92812a925bbfb0fd95adc2f50fc2 100644
--- a/src/sdl/i_gamepad.c
+++ b/src/sdl/i_gamepad.c
@@ -15,7 +15,7 @@
#include "../i_system.h"
#include "../doomdef.h"
#include "../d_main.h"
-#include "../netcode/d_netcmd.h"
+#include "../d_netcmd.h"
#include "../g_game.h"
#include "../m_argv.h"
#include "../m_menu.h"
diff --git a/src/sdl/i_net.c b/src/sdl/i_net.c
index 515a855684e1e3d13dce6d35a785a2c7d07c9e93..ee4a34c13dd8d4d10950d53d972d0cf873068943 100644
--- a/src/sdl/i_net.c
+++ b/src/sdl/i_net.c
@@ -21,16 +21,16 @@
#include "../i_system.h"
#include "../d_event.h"
-#include "../netcode/d_net.h"
+#include "../d_net.h"
#include "../m_argv.h"
#include "../doomstat.h"
-#include "../netcode/i_net.h"
+#include "../i_net.h"
#include "../z_zone.h"
-#include "../netcode/i_tcp.h"
+#include "../i_tcp.h"
#ifdef HAVE_SDL
diff --git a/src/sdl/i_system.c b/src/sdl/i_system.c
index 47402e5497e2fcceb5abdbb05ba85d7ba0c59b27..ee082fd5d33198d065e4e34f0960df70834de906 100644
--- a/src/sdl/i_system.c
+++ b/src/sdl/i_system.c
@@ -188,8 +188,7 @@ static char returnWadPath[256];
#include "../i_gamepad.h"
#include "../i_threads.h"
#include "../screen.h" //vid.WndParent
-#include "../netcode/d_net.h"
-#include "../netcode/commands.h"
+#include "../d_net.h"
#include "../g_game.h"
#include "../filesrch.h"
#include "endtxt.h"
@@ -208,7 +207,7 @@ static char returnWadPath[256];
#if !defined(NOMUMBLE) && defined(HAVE_MUMBLE)
// Mumble context string
-#include "../netcode/d_clisrv.h"
+#include "../d_clisrv.h"
#include "../byteptr.h"
#endif
@@ -1593,7 +1592,9 @@ void I_Quit(void)
SDLforceUngrabMouse();
quiting = SDL_FALSE;
M_SaveConfig(NULL); //save game config, cvars..
+#ifndef NONET
D_SaveBan(); // save the ban list
+#endif
G_SaveGameData(); // Tails 12-08-2002
//added:16-02-98: when recording a demo, should exit using 'q' key,
// but sometimes we forget and use 'F10'.. so save here too.
@@ -1708,7 +1709,9 @@ void I_Error(const char *error, ...)
// ---
M_SaveConfig(NULL); // save game config, cvars..
+#ifndef NONET
D_SaveBan(); // save the ban list
+#endif
G_SaveGameData(); // Tails 12-08-2002
// Shutdown. Here might be other errors.
diff --git a/src/sdl/i_ttf.c b/src/sdl/i_ttf.c
index 1f838e9b46267dfc5adec7f1f75541bf7765754b..f2cd497eec03f24a6e3088e7e4f64e0925e16cc1 100644
--- a/src/sdl/i_ttf.c
+++ b/src/sdl/i_ttf.c
@@ -21,7 +21,7 @@
#include "SDL_ttf.h"
#include "../doomdef.h"
#include "../doomstat.h"
-#include "../netcode/d_netfil.h"
+#include "../d_netfil.h"
#include "../filesrch.h"
#include "i_ttf.h"
diff --git a/src/snake.c b/src/snake.c
deleted file mode 100644
index 21e79401dfd4c30ef3e384c3780ede2af11c5538..0000000000000000000000000000000000000000
--- a/src/snake.c
+++ /dev/null
@@ -1,535 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 2023-2023 by Louis-Antoine de Moulins de Rochefort.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file snake.c
-/// \brief Snake minigame for the download screen.
-
-#include "snake.h"
-#include "g_input.h"
-#include "m_random.h"
-#include "s_sound.h"
-#include "screen.h"
-#include "v_video.h"
-#include "w_wad.h"
-#include "z_zone.h"
-
-#define SPEED 5
-
-#define NUM_BLOCKS_X 20
-#define NUM_BLOCKS_Y 10
-#define BLOCK_SIZE 12
-#define BORDER_SIZE 12
-
-#define MAP_WIDTH (NUM_BLOCKS_X * BLOCK_SIZE)
-#define MAP_HEIGHT (NUM_BLOCKS_Y * BLOCK_SIZE)
-
-#define LEFT_X ((BASEVIDWIDTH - MAP_WIDTH) / 2 - BORDER_SIZE)
-#define RIGHT_X (LEFT_X + MAP_WIDTH + BORDER_SIZE * 2 - 1)
-#define BOTTOM_Y (BASEVIDHEIGHT - 48)
-#define TOP_Y (BOTTOM_Y - MAP_HEIGHT - BORDER_SIZE * 2 + 1)
-
-enum bonustype_s {
- BONUS_NONE = 0,
- BONUS_SLOW,
- BONUS_FAST,
- BONUS_GHOST,
- BONUS_NUKE,
- BONUS_SCISSORS,
- BONUS_REVERSE,
- BONUS_EGGMAN,
- NUM_BONUSES,
-};
-
-typedef struct snake_s
-{
- boolean paused;
- boolean pausepressed;
- tic_t time;
- tic_t nextupdate;
- boolean gameover;
- UINT8 background;
-
- UINT16 snakelength;
- enum bonustype_s snakebonus;
- tic_t snakebonustime;
- UINT8 snakex[NUM_BLOCKS_X * NUM_BLOCKS_Y];
- UINT8 snakey[NUM_BLOCKS_X * NUM_BLOCKS_Y];
- UINT8 snakedir[NUM_BLOCKS_X * NUM_BLOCKS_Y];
-
- UINT8 applex;
- UINT8 appley;
-
- enum bonustype_s bonustype;
- UINT8 bonusx;
- UINT8 bonusy;
-} snake_t;
-
-static const char *bonuspatches[] = {
- NULL,
- "DL_SLOW",
- "TVSSC0",
- "TVIVC0",
- "TVARC0",
- "DL_SCISSORS",
- "TVRCC0",
- "TVEGC0",
-};
-
-static const char *backgrounds[] = {
- "RVPUMICF",
- "FRSTRCKF",
- "TAR",
- "MMFLRB4",
- "RVDARKF1",
- "RVZWALF1",
- "RVZWALF4",
- "RVZWALF5",
- "RVZGRS02",
- "RVZGRS04",
-};
-
-static void Initialise(snake_t *snake)
-{
- snake->paused = false;
- snake->pausepressed = false;
- snake->time = 0;
- snake->nextupdate = SPEED;
- snake->gameover = false;
- snake->background = M_RandomKey(sizeof(backgrounds) / sizeof(*backgrounds));
-
- snake->snakelength = 1;
- snake->snakebonus = BONUS_NONE;
- snake->snakex[0] = M_RandomKey(NUM_BLOCKS_X);
- snake->snakey[0] = M_RandomKey(NUM_BLOCKS_Y);
- snake->snakedir[0] = 0;
- snake->snakedir[1] = 0;
-
- snake->applex = M_RandomKey(NUM_BLOCKS_X);
- snake->appley = M_RandomKey(NUM_BLOCKS_Y);
-
- snake->bonustype = BONUS_NONE;
-}
-
-static UINT8 GetOppositeDir(UINT8 dir)
-{
- if (dir == 1 || dir == 3)
- return dir + 1;
- else if (dir == 2 || dir == 4)
- return dir - 1;
- else
- return 12 + 5 - dir;
-}
-
-static void FindFreeSlot(snake_t *snake, UINT8 *freex, UINT8 *freey, UINT8 headx, UINT8 heady)
-{
- UINT8 x, y;
- UINT16 i;
-
- do
- {
- x = M_RandomKey(NUM_BLOCKS_X);
- y = M_RandomKey(NUM_BLOCKS_Y);
-
- for (i = 0; i < snake->snakelength; i++)
- if (x == snake->snakex[i] && y == snake->snakey[i])
- break;
- } while (i < snake->snakelength || (x == headx && y == heady)
- || (x == snake->applex && y == snake->appley)
- || (snake->bonustype != BONUS_NONE && x == snake->bonusx && y == snake->bonusy));
-
- *freex = x;
- *freey = y;
-}
-
-void Snake_Allocate(void **opaque)
-{
- if (*opaque)
- Snake_Free(opaque);
- *opaque = malloc(sizeof(snake_t));
- Initialise(*opaque);
-}
-
-void Snake_Update(void *opaque)
-{
- UINT8 x, y;
- UINT8 oldx, oldy;
- UINT16 i;
- UINT16 joystate = 0;
-
- snake_t *snake = opaque;
-
- // Handle retry
- if (snake->gameover && (G_PlayerInputDown(0, GC_JUMP) || gamekeydown[KEY_ENTER]))
- {
- Initialise(snake);
- snake->pausepressed = true; // Avoid accidental pause on respawn
- }
-
- // Handle pause
- if (G_PlayerInputDown(0, GC_PAUSE) || gamekeydown[KEY_ENTER])
- {
- if (!snake->pausepressed)
- snake->paused = !snake->paused;
- snake->pausepressed = true;
- }
- else
- snake->pausepressed = false;
-
- if (snake->paused)
- return;
-
- snake->time++;
-
- x = snake->snakex[0];
- y = snake->snakey[0];
- oldx = snake->snakex[1];
- oldy = snake->snakey[1];
-
- // Update direction
- if (G_PlayerInputDown(0, GC_STRAFELEFT) || gamekeydown[KEY_LEFTARROW] || joystate == 3)
- {
- if (snake->snakelength < 2 || x <= oldx)
- snake->snakedir[0] = 1;
- }
- else if (G_PlayerInputDown(0, GC_STRAFERIGHT) || gamekeydown[KEY_RIGHTARROW] || joystate == 4)
- {
- if (snake->snakelength < 2 || x >= oldx)
- snake->snakedir[0] = 2;
- }
- else if (G_PlayerInputDown(0, GC_FORWARD) || gamekeydown[KEY_UPARROW] || joystate == 1)
- {
- if (snake->snakelength < 2 || y <= oldy)
- snake->snakedir[0] = 3;
- }
- else if (G_PlayerInputDown(0, GC_BACKWARD) || gamekeydown[KEY_DOWNARROW] || joystate == 2)
- {
- if (snake->snakelength < 2 || y >= oldy)
- snake->snakedir[0] = 4;
- }
-
- if (snake->snakebonustime)
- {
- snake->snakebonustime--;
- if (!snake->snakebonustime)
- snake->snakebonus = BONUS_NONE;
- }
-
- snake->nextupdate--;
- if (snake->nextupdate)
- return;
- if (snake->snakebonus == BONUS_SLOW)
- snake->nextupdate = SPEED * 2;
- else if (snake->snakebonus == BONUS_FAST)
- snake->nextupdate = SPEED * 2 / 3;
- else
- snake->nextupdate = SPEED;
-
- if (snake->gameover)
- return;
-
- // Find new position
- switch (snake->snakedir[0])
- {
- case 1:
- if (x > 0)
- x--;
- else
- snake->gameover = true;
- break;
- case 2:
- if (x < NUM_BLOCKS_X - 1)
- x++;
- else
- snake->gameover = true;
- break;
- case 3:
- if (y > 0)
- y--;
- else
- snake->gameover = true;
- break;
- case 4:
- if (y < NUM_BLOCKS_Y - 1)
- y++;
- else
- snake->gameover = true;
- break;
- }
-
- // Check collision with snake
- if (snake->snakebonus != BONUS_GHOST)
- for (i = 1; i < snake->snakelength - 1; i++)
- if (x == snake->snakex[i] && y == snake->snakey[i])
- {
- if (snake->snakebonus == BONUS_SCISSORS)
- {
- snake->snakebonus = BONUS_NONE;
- snake->snakelength = i;
- S_StartSound(NULL, sfx_adderr);
- }
- else
- snake->gameover = true;
- }
-
- if (snake->gameover)
- {
- S_StartSound(NULL, sfx_lose);
- return;
- }
-
- // Check collision with apple
- if (x == snake->applex && y == snake->appley)
- {
- if (snake->snakelength + 3 < NUM_BLOCKS_X * NUM_BLOCKS_Y)
- {
- snake->snakelength++;
- snake->snakex [snake->snakelength - 1] = snake->snakex [snake->snakelength - 2];
- snake->snakey [snake->snakelength - 1] = snake->snakey [snake->snakelength - 2];
- snake->snakedir[snake->snakelength - 1] = snake->snakedir[snake->snakelength - 2];
- }
-
- // Spawn new apple
- FindFreeSlot(snake, &snake->applex, &snake->appley, x, y);
-
- // Spawn new bonus
- if (!(snake->snakelength % 5))
- {
- do
- {
- snake->bonustype = M_RandomKey(NUM_BONUSES - 1) + 1;
- } while (snake->snakelength > NUM_BLOCKS_X * NUM_BLOCKS_Y * 3 / 4
- && (snake->bonustype == BONUS_EGGMAN || snake->bonustype == BONUS_FAST || snake->bonustype == BONUS_REVERSE));
-
- FindFreeSlot(snake, &snake->bonusx, &snake->bonusy, x, y);
- }
-
- S_StartSound(NULL, sfx_s3k6b);
- }
-
- if (snake->snakelength > 1 && snake->snakedir[0])
- {
- UINT8 dir = snake->snakedir[0];
-
- oldx = snake->snakex[1];
- oldy = snake->snakey[1];
-
- // Move
- for (i = snake->snakelength - 1; i > 0; i--)
- {
- snake->snakex[i] = snake->snakex[i - 1];
- snake->snakey[i] = snake->snakey[i - 1];
- snake->snakedir[i] = snake->snakedir[i - 1];
- }
-
- // Handle corners
- if (x < oldx && dir == 3)
- dir = 5;
- else if (x > oldx && dir == 3)
- dir = 6;
- else if (x < oldx && dir == 4)
- dir = 7;
- else if (x > oldx && dir == 4)
- dir = 8;
- else if (y < oldy && dir == 1)
- dir = 9;
- else if (y < oldy && dir == 2)
- dir = 10;
- else if (y > oldy && dir == 1)
- dir = 11;
- else if (y > oldy && dir == 2)
- dir = 12;
- snake->snakedir[1] = dir;
- }
-
- snake->snakex[0] = x;
- snake->snakey[0] = y;
-
- // Check collision with bonus
- if (snake->bonustype != BONUS_NONE && x == snake->bonusx && y == snake->bonusy)
- {
- S_StartSound(NULL, sfx_ncchip);
-
- switch (snake->bonustype)
- {
- case BONUS_SLOW:
- snake->snakebonus = BONUS_SLOW;
- snake->snakebonustime = 20 * TICRATE;
- break;
- case BONUS_FAST:
- snake->snakebonus = BONUS_FAST;
- snake->snakebonustime = 20 * TICRATE;
- break;
- case BONUS_GHOST:
- snake->snakebonus = BONUS_GHOST;
- snake->snakebonustime = 10 * TICRATE;
- break;
- case BONUS_NUKE:
- for (i = 0; i < snake->snakelength; i++)
- {
- snake->snakex [i] = snake->snakex [0];
- snake->snakey [i] = snake->snakey [0];
- snake->snakedir[i] = snake->snakedir[0];
- }
-
- S_StartSound(NULL, sfx_bkpoof);
- break;
- case BONUS_SCISSORS:
- snake->snakebonus = BONUS_SCISSORS;
- snake->snakebonustime = 60 * TICRATE;
- break;
- case BONUS_REVERSE:
- for (i = 0; i < (snake->snakelength + 1) / 2; i++)
- {
- UINT16 i2 = snake->snakelength - 1 - i;
- UINT8 tmpx = snake->snakex [i];
- UINT8 tmpy = snake->snakey [i];
- UINT8 tmpdir = snake->snakedir[i];
-
- // Swap first segment with last segment
- snake->snakex [i] = snake->snakex [i2];
- snake->snakey [i] = snake->snakey [i2];
- snake->snakedir[i] = GetOppositeDir(snake->snakedir[i2]);
- snake->snakex [i2] = tmpx;
- snake->snakey [i2] = tmpy;
- snake->snakedir[i2] = GetOppositeDir(tmpdir);
- }
-
- snake->snakedir[0] = 0;
-
- S_StartSound(NULL, sfx_gravch);
- break;
- default:
- if (snake->snakebonus != BONUS_GHOST)
- {
- snake->gameover = true;
- S_StartSound(NULL, sfx_lose);
- }
- }
-
- snake->bonustype = BONUS_NONE;
- }
-}
-
-void Snake_Draw(void *opaque)
-{
- INT16 i;
-
- snake_t *snake = opaque;
-
- // Background
- V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
-
- V_DrawFlatFill(
- LEFT_X + BORDER_SIZE,
- TOP_Y + BORDER_SIZE,
- MAP_WIDTH,
- MAP_HEIGHT,
- W_GetNumForName(backgrounds[snake->background])
- );
-
- // Borders
- V_DrawFill(LEFT_X, TOP_Y, BORDER_SIZE + MAP_WIDTH, BORDER_SIZE, 242); // Top
- V_DrawFill(LEFT_X + BORDER_SIZE + MAP_WIDTH, TOP_Y, BORDER_SIZE, BORDER_SIZE + MAP_HEIGHT, 242); // Right
- V_DrawFill(LEFT_X + BORDER_SIZE, TOP_Y + BORDER_SIZE + MAP_HEIGHT, BORDER_SIZE + MAP_WIDTH, BORDER_SIZE, 242); // Bottom
- V_DrawFill(LEFT_X, TOP_Y + BORDER_SIZE, BORDER_SIZE, BORDER_SIZE + MAP_HEIGHT, 242); // Left
-
- // Apple
- V_DrawFixedPatch(
- (LEFT_X + BORDER_SIZE + snake->applex * BLOCK_SIZE + BLOCK_SIZE / 2) * FRACUNIT,
- (TOP_Y + BORDER_SIZE + snake->appley * BLOCK_SIZE + BLOCK_SIZE / 2) * FRACUNIT,
- FRACUNIT / 4,
- 0,
- W_CachePatchLongName("DL_APPLE", PU_HUDGFX),
- NULL
- );
-
- // Bonus
- if (snake->bonustype != BONUS_NONE)
- V_DrawFixedPatch(
- (LEFT_X + BORDER_SIZE + snake->bonusx * BLOCK_SIZE + BLOCK_SIZE / 2 ) * FRACUNIT,
- (TOP_Y + BORDER_SIZE + snake->bonusy * BLOCK_SIZE + BLOCK_SIZE / 2 + 4) * FRACUNIT,
- FRACUNIT / 2,
- 0,
- W_CachePatchLongName(bonuspatches[snake->bonustype], PU_HUDGFX),
- NULL
- );
-
- // Snake
- if (!snake->gameover || snake->time % 8 < 8 / 2) // Blink if game over
- {
- for (i = snake->snakelength - 1; i >= 0; i--)
- {
- const char *patchname;
- UINT8 dir = snake->snakedir[i];
-
- if (i == 0) // Head
- {
- switch (dir)
- {
- case 1: patchname = "DL_SNAKEHEAD_L"; break;
- case 2: patchname = "DL_SNAKEHEAD_R"; break;
- case 3: patchname = "DL_SNAKEHEAD_T"; break;
- case 4: patchname = "DL_SNAKEHEAD_B"; break;
- default: patchname = "DL_SNAKEHEAD_M";
- }
- }
- else // Body
- {
- switch (dir)
- {
- case 1: patchname = "DL_SNAKEBODY_L"; break;
- case 2: patchname = "DL_SNAKEBODY_R"; break;
- case 3: patchname = "DL_SNAKEBODY_T"; break;
- case 4: patchname = "DL_SNAKEBODY_B"; break;
- case 5: patchname = "DL_SNAKEBODY_LT"; break;
- case 6: patchname = "DL_SNAKEBODY_RT"; break;
- case 7: patchname = "DL_SNAKEBODY_LB"; break;
- case 8: patchname = "DL_SNAKEBODY_RB"; break;
- case 9: patchname = "DL_SNAKEBODY_TL"; break;
- case 10: patchname = "DL_SNAKEBODY_TR"; break;
- case 11: patchname = "DL_SNAKEBODY_BL"; break;
- case 12: patchname = "DL_SNAKEBODY_BR"; break;
- default: patchname = "DL_SNAKEBODY_B";
- }
- }
-
- V_DrawFixedPatch(
- (LEFT_X + BORDER_SIZE + snake->snakex[i] * BLOCK_SIZE + BLOCK_SIZE / 2) * FRACUNIT,
- (TOP_Y + BORDER_SIZE + snake->snakey[i] * BLOCK_SIZE + BLOCK_SIZE / 2) * FRACUNIT,
- i == 0 && dir == 0 ? FRACUNIT / 5 : FRACUNIT / 2,
- snake->snakebonus == BONUS_GHOST ? V_TRANSLUCENT : 0,
- W_CachePatchLongName(patchname, PU_HUDGFX),
- NULL
- );
- }
- }
-
- // Length
- V_DrawString(RIGHT_X + 4, TOP_Y, V_MONOSPACE, va("%u", snake->snakelength));
-
- // Bonus
- if (snake->snakebonus != BONUS_NONE
- && (snake->snakebonustime >= 3 * TICRATE || snake->time % 4 < 4 / 2))
- V_DrawFixedPatch(
- (RIGHT_X + 10) * FRACUNIT,
- (TOP_Y + 24) * FRACUNIT,
- FRACUNIT / 2,
- 0,
- W_CachePatchLongName(bonuspatches[snake->snakebonus], PU_HUDGFX),
- NULL
- );
-}
-
-void Snake_Free(void **opaque)
-{
- if (*opaque)
- {
- free(opaque);
- *opaque = NULL;
- }
-}
diff --git a/src/snake.h b/src/snake.h
deleted file mode 100644
index a3106bb0f03010814cd89fa53cb566460a5c81af..0000000000000000000000000000000000000000
--- a/src/snake.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SONIC ROBO BLAST 2
-//-----------------------------------------------------------------------------
-// Copyright (C) 2023-2023 by Louis-Antoine de Moulins de Rochefort.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file snake.h
-/// \brief Snake minigame for the download screen.
-
-#ifndef __SNAKE__
-#define __SNAKE__
-
-void Snake_Allocate(void **opaque);
-void Snake_Update(void *opaque);
-void Snake_Draw(void *opaque);
-void Snake_Free(void **opaque);
-
-#endif
diff --git a/src/w_wad.c b/src/w_wad.c
index 1e64cf09362b9717661c0b6c579c19cb63e7c2b5..42c6bf83be9e7dd8a89e67aee6aa7373d96bc53e 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -51,8 +51,8 @@
#include "filesrch.h"
#include "d_main.h"
-#include "netcode/d_netfil.h"
-#include "netcode/d_clisrv.h"
+#include "d_netfil.h"
+#include "d_clisrv.h"
#include "dehacked.h"
#include "r_defs.h"
#include "r_data.h"
diff --git a/src/y_inter.c b/src/y_inter.c
index de757ec7045a8cf06a1c0e376a35603f325eec60..7faceff50ecd627011da0dd7b36d289a7ef0c4ac 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -15,7 +15,7 @@
#include "f_finale.h"
#include "g_game.h"
#include "hu_stuff.h"
-#include "netcode/i_net.h"
+#include "i_net.h"
#include "i_video.h"
#include "p_tick.h"
#include "r_defs.h"