zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2025-04-04 00:41:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

Lobby Overhaul

Browse source 
Rewrote lobby to unify common and Doom-specific packet structure, allowing for saner handling of in-game joining. Added a new per-client stage system that allows individual clients to be handled at a time when gathering and sharing info. Reworked lobby UI to display user info and added kick/ban functionalities. Bans are only a temporary per-game IP ban (use passwords to keep unwanted users out). Increased max player count to 64 and unified engine constant.
This commit is contained in:
Boondorl 2025-03-05 17:52:13 -05:00 committed by Rachael Alexanderson
parent 80d5450af9
commit ad3bcfddba
21 changed files with 1753 additions and 1622 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1947
src/common/engine/i_net.cpp
View file

File diff suppressed because it is too large Load diff

91
src/common/engine/i_net.h
View file

@ -2,45 +2,43 @@
#define __I_NET_H__
#include <stdint.h>
#include "tarray.h"
// Called by D_DoomMain.
int I_InitNetwork (void);
void I_ClearNode(int node);
void I_NetCmd (void);
void I_NetMessage(const char*, ...);
void I_NetError(const char* error);
void I_NetProgress(int val);
void I_NetInit(const char* msg, int num);
bool I_NetLoop(bool (*timer_callback)(void*), void* userdata);
void I_NetDone();
inline constexpr size_t MAXPLAYERS = 64u;
enum ENetConstants
{
DOOMCOM_ID = 0x12345678,
DEFAULT_GAME_ID = 0x12345678,
BACKUPTICS = 35 * 5, // Remember up to 5 seconds of data.
MAXTICDUP = 3,
MAXSENDTICS = 35 * 1, // Only send up to 1 second of data at a time.
LOCALCMDTICS = (BACKUPTICS*MAXTICDUP),
LOCALCMDTICS = (BACKUPTICS * MAXTICDUP),
MAX_MSGLEN = 14000,
CMD_SEND = 1,
CMD_GET = 2,
};
enum ENCMD
enum ENetCommand
{
NCMD_EXIT = 0x80, // Client has left the game
NCMD_RETRANSMIT = 0x40, //
NCMD_SETUP = 0x20, // Guest is letting the host know who it is
NCMD_LEVELREADY = 0x10, // After loading a level, guests send this over to the host who then sends it back after all are received
NCMD_QUITTERS = 0x08, // Client is getting info about one or more players quitting (packet server only)
NCMD_COMPRESSED = 0x04, // Remainder of packet is compressed
NCMD_LATENCYACK = 0x02, // A latency packet was just read, so let the sender know.
NCMD_LATENCY = 0x01, // Latency packet, used for measuring RTT.
CMD_NONE,
CMD_SEND,
CMD_GET,
};
NCMD_USERINFO = NCMD_SETUP + 1, // Guest is getting another client's user info
NCMD_GAMEINFO = NCMD_SETUP + 2, // Guest is getting the state of the game from the host
NCMD_GAMEREADY = NCMD_SETUP + 3, // Host has verified the game is ready to be started
enum ENetFlags
{
NCMD_EXIT = 0x80, // Client has left the game
NCMD_RETRANSMIT = 0x40, //
NCMD_SETUP = 0x20, // Guest is letting the host know who it is
NCMD_LEVELREADY = 0x10, // After loading a level, guests send this over to the host who then sends it back after all are received
NCMD_QUITTERS = 0x08, // Client is getting info about one or more players quitting (packet server only)
NCMD_COMPRESSED = 0x04, // Remainder of packet is compressed
NCMD_LATENCYACK = 0x02, // A latency packet was just read, so let the sender know.
NCMD_LATENCY = 0x01, // Latency packet, used for measuring RTT.
};
enum ENetMode
{
NET_PeerToPeer,
NET_PacketServer
};
struct FClientStack : public TArray<int>
@ -59,31 +57,22 @@ struct FClientStack : public TArray<int>
}
};
extern FClientStack NetworkClients;
//
// Network packet data.
//
struct doomcom_t
{
// info common to all nodes
uint32_t id; // should be DOOMCOM_ID
int16_t ticdup; // 1 = no duplication, 2-3 = dup for slow nets
int16_t numplayers;
// info specific to this node
int16_t consoleplayer;
// communication between DOOM and the driver
int16_t command; // CMD_SEND or CMD_GET
int16_t remoteplayer; // dest for send, set by get (-1 = no packet).
// packet data to be sent
int16_t datalength; // bytes in data to be sent
uint8_t data[MAX_MSGLEN];
};
extern doomcom_t doomcom;
extern bool netgame, multiplayer;
extern int consoleplayer;
extern int Net_Arbitrator;
extern FClientStack NetworkClients;
extern ENetMode NetMode;
extern uint8_t NetBuffer[MAX_MSGLEN];
extern size_t NetBufferLength;
extern uint8_t TicDup;
extern int RemoteClient;
extern uint8_t MaxClients;
extern uint32_t GameID;
bool I_InitNetwork();
void I_ClearClient(size_t client);
void I_NetCmd(ENetCommand cmd);
void I_NetDone();
void HandleIncomingConnection();
#endif

37
src/common/engine/st_start.h
View file

@ -51,15 +51,21 @@ public:
virtual ~FStartupScreen() = default;
virtual void Progress() {}
virtual void AppendStatusLine(const char* status) {}
virtual void LoadingStatus(const char* message, int colors) {}
virtual void NetInit(const char *message, int num_players) {}
virtual void NetProgress(int count) {}
virtual void NetInit(const char* message, bool host) {}
virtual void NetMessage(const char* message) {}
virtual void NetConnect(int client, const char* name, unsigned flags, int status) {}
virtual void NetUpdate(int client, int status) {}
virtual void NetDisconnect(int client) {}
virtual void NetProgress(int cur, int limit) {}
virtual void NetDone() {}
virtual void NetClose() {}
virtual bool ShouldStartNet() { return false; }
virtual bool NetLoop(bool (*timer_callback)(void *), void *userdata) { return false; }
virtual void AppendStatusLine(const char* status) {}
virtual void LoadingStatus(const char* message, int colors) {}
virtual int GetNetKickClient() { return -1; }
virtual int GetNetBanClient() { return -1; }
virtual bool NetLoop(bool (*loopCallback)(void *), void *data) { return false; }
protected:
int MaxPos, CurPos, NotchPos;
@ -71,14 +77,21 @@ public:
FBasicStartupScreen(int max_progress);
~FBasicStartupScreen();
void Progress();
void NetInit(const char* message, int num_players);
void NetProgress(int count);
void NetMessage(const char* format, ...); // cover for printf
void NetDone();
void NetClose();
void Progress() override;
void NetInit(const char* message, bool host) override;
void NetMessage(const char* message) override;
void NetConnect(int client, const char* name, unsigned flags, int status) override;
void NetUpdate(int client, int status) override;
void NetDisconnect(int client) override;
void NetProgress(int cur, int limit) override;
void NetDone() override;
void NetClose() override;
bool ShouldStartNet() override;
bool NetLoop(bool (*timer_callback)(void*), void* userdata);
int GetNetKickClient() override;
int GetNetBanClient() override;
bool NetLoop(bool (*loopCallback)(void*), void* data) override;
protected:
int NetMaxPos, NetCurPos;
};

11
src/common/platform/posix/cocoa/st_console.h
View file

@ -63,11 +63,18 @@ public:
// FStartupScreen functionality
void Progress(int current, int maximum);
void NetInit(const char* message, int playerCount);
void NetProgress(int count);
void NetInit(const char* const message, const bool host);
void NetMessage(const char* const message);
void NetConnect(const int client, const char* const name, const unsigned flags, const int status);
void NetUpdate(const int client, const int status);
void NetDisconnect(const int client);
void NetProgress(const int cur, const int limit);
void NetDone();
void NetClose();
bool ShouldStartNet();
int GetNetKickClient();
int GetNetBanClient();
private:
NSWindow* m_window;

62
src/common/platform/posix/cocoa/st_console.mm
View file

@ -417,7 +417,7 @@ void FConsoleWindow::Progress(const int current, const int maximum)
}
void FConsoleWindow::NetInit(const char* const message, const int playerCount)
void FConsoleWindow::NetInit(const char* const message, const bool host)
{
if (nil == m_netView)
{
@ -442,19 +442,9 @@ void FConsoleWindow::NetInit(const char* const message, const int playerCount)
// Connection progress
m_netProgressBar = [[NSProgressIndicator alloc] initWithFrame:NSMakeRect(12.0f, 40.0f, 488.0f, 16.0f)];
[m_netProgressBar setAutoresizingMask:NSViewWidthSizable];
[m_netProgressBar setMaxValue:playerCount];
if (0 == playerCount)
{
// Joining game
[m_netProgressBar setIndeterminate:YES];
[m_netProgressBar startAnimation:nil];
}
else
{
// Hosting game
[m_netProgressBar setIndeterminate:NO];
}
[m_netProgressBar setMaxValue:0];
[m_netProgressBar setIndeterminate:YES];
[m_netProgressBar startAnimation:nil];
// Cancel network game button
m_netAbortButton = [[NSButton alloc] initWithFrame:NSMakeRect(432.0f, 8.0f, 72.0f, 28.0f)];
@ -486,22 +476,32 @@ void FConsoleWindow::NetInit(const char* const message, const int playerCount)
[m_netMessageText setStringValue:[NSString stringWithUTF8String:message]];
m_netCurPos = 0;
m_netMaxPos = playerCount;
NetProgress(1); // You always know about yourself
}
void FConsoleWindow::NetProgress(const int count)
void FConsoleWindow::NetMessage(const char* const message)
{
if (0 == count)
{
++m_netCurPos;
}
else
{
m_netCurPos = count;
}
[m_netMessageText setStringValue:[NSString stringWithUTF8String:message]];
}
void FConsoleWindow::NetConnect(const int client, const char* const name, const unsigned flags, const int status)
{
}
void FConsoleWindow::NetUpdate(const int client, const int status)
{
}
void FConsoleWindow::NetDisconnect(const int client)
{
}
void FConsoleWindow::NetProgress(const int cur, const int limit)
{
m_netCurPos = cur;
m_netMaxPos = limit;
if (nil == m_netView)
{
return;
@ -541,3 +541,13 @@ bool FConsoleWindow::ShouldStartNet()
{
return false;
}
int FConsoleWindow::GetNetKickClient()
{
return -1;
}
int FConsoleWindow::GetNetBanClient()
{
return -1;
}

42
src/common/platform/posix/cocoa/st_start.mm
View file

@ -95,14 +95,34 @@ void FBasicStartupScreen::Progress()
}
void FBasicStartupScreen::NetInit(const char* const message, const int playerCount)
void FBasicStartupScreen::NetInit(const char* const message, const bool host)
{
FConsoleWindow::GetInstance().NetInit(message, playerCount);
FConsoleWindow::GetInstance().NetInit(message, host);
}
void FBasicStartupScreen::NetProgress(const int count)
void FBasicStartupScreen::NetMessage(const char* const message)
{
FConsoleWindow::GetInstance().NetProgress(count);
FConsoleWindow::GetInstance().NetMessage(message);
}
void FBasicStartupScreen::NetConnect(const int client, const char* const name, const unsigned flags, const int status)
{
FConsoleWindow::GetInstance().NetConnect(client, name, flags, status);
}
void FBasicStartupScreen::NetUpdate(const int client, const int status)
{
FConsoleWindow::GetInstance().NetUpdate(client, status);
}
void FBasicStartupScreen::NetDisconnect(const int client)
{
FConsoleWindow::GetInstance().NetDisconnect(client);
}
void FBasicStartupScreen::NetProgress(const int cur, const int limit)
{
FConsoleWindow::GetInstance().NetProgress(cur, limit);
}
void FBasicStartupScreen::NetDone()
@ -120,11 +140,21 @@ bool FBasicStartupScreen::ShouldStartNet()
return FConsoleWindow::GetInstance().ShouldStartNet();
}
bool FBasicStartupScreen::NetLoop(bool (*timerCallback)(void*), void* const userData)
int FBasicStartupScreen::GetNetKickClient()
{
return FConsoleWindow::GetInstance().GetNetKickClient();
}
int FBasicStartupScreen::GetNetBanClient()
{
return FConsoleWindow::GetInstance().GetNetBanClient();
}
bool FBasicStartupScreen::NetLoop(bool (*loopCallback)(void*), void* const data)
{
while (true)
{
if (timerCallback(userData))
if (loopCallback(data))
{
break;
}

143
src/common/platform/posix/sdl/st_start.cpp
View file

@ -53,13 +53,21 @@ class FTTYStartupScreen : public FStartupScreen
FTTYStartupScreen(int max_progress);
~FTTYStartupScreen();
void Progress();
void NetInit(const char *message, int num_players);
void NetProgress(int count);
void NetDone();
void NetClose();
bool ShouldStartNet();
bool NetLoop(bool (*timer_callback)(void *), void *userdata);
void Progress() override;
void NetInit(const char* message, bool host) override;
void NetMessage(const char* message) override;
void NetConnect(int client, const char* name, unsigned flags, int status) override;
void NetUpdate(int client, int status) override;
void NetDisconnect(int client) override;
void NetProgress(int cur, int limit) override;
void NetDone() override;
void NetClose() override;
bool ShouldStartNet() override;
int GetNetKickClient() override;
int GetNetBanClient() override;
bool NetLoop(bool (*loopCallback)(void*), void* data) override;
protected:
bool DidNetInit;
int NetMaxPos, NetCurPos;
@ -147,7 +155,7 @@ void FTTYStartupScreen::Progress()
//
//===========================================================================
void FTTYStartupScreen::NetInit(const char *message, int numplayers)
void FTTYStartupScreen::NetInit(const char* message, bool host)
{
if (!DidNetInit)
{
@ -163,20 +171,63 @@ void FTTYStartupScreen::NetInit(const char *message, int numplayers)
tcsetattr (STDIN_FILENO, TCSANOW, &rawtermios);
DidNetInit = true;
}
if (numplayers == 1)
{
// Status message without any real progress info.
fprintf (stderr, "\n%s.", message);
}
else
{
fprintf (stderr, "\n%s: ", message);
}
fprintf(stderr, "\n%s.", message);
fflush (stderr);
TheNetMessage = message;
NetMaxPos = numplayers;
NetCurPos = 0;
NetProgress(1); // You always know about yourself
}
void FTTYStartupScreen::NetMessage(const char* message)
{
TheNetMessage = message;
}
void FTTYStartupScreen::NetConnect(int client, const char* name, unsigned flags, int status)
{
}
void FTTYStartupScreen::NetUpdate(int client, int status)
{
}
void FTTYStartupScreen::NetDisconnect(int client)
{
}
//===========================================================================
//
// FTTYStartupScreen :: NetProgress
//
// Sets the network progress meter.
//
//===========================================================================
void FTTYStartupScreen::NetProgress(int cur, int limit)
{
int i;
NetMaxPos = limit;
NetCurPos = cur;
if (NetMaxPos == 0)
{
// Spinny-type progress meter, because we're a guest waiting for the host.
fprintf(stderr, "\r%s: %c", TheNetMessage, SpinnyProgressChars[NetCurPos & 3]);
fflush(stderr);
}
else if (NetMaxPos > 1)
{
// Dotty-type progress meter.
fprintf(stderr, "\r%s: ", TheNetMessage);
for (i = 0; i < NetCurPos; ++i)
{
fputc('.', stderr);
}
fprintf(stderr, "%*c[%2d/%2d]", NetMaxPos + 1 - NetCurPos, ' ', NetCurPos, NetMaxPos);
fflush(stderr);
}
}
//===========================================================================
@ -199,46 +250,6 @@ void FTTYStartupScreen::NetDone()
}
}
//===========================================================================
//
// FTTYStartupScreen :: NetProgress
//
// Sets the network progress meter. If count is 0, it gets bumped by 1.
// Otherwise, it is set to count.
//
//===========================================================================
void FTTYStartupScreen::NetProgress(int count)
{
int i;
if (count == 0)
{
NetCurPos++;
}
else if (count > 0)
{
NetCurPos = count;
}
if (NetMaxPos == 0)
{
// Spinny-type progress meter, because we're a guest waiting for the host.
fprintf (stderr, "\r%s: %c", TheNetMessage, SpinnyProgressChars[NetCurPos & 3]);
fflush (stderr);
}
else if (NetMaxPos > 1)
{
// Dotty-type progress meter.
fprintf (stderr, "\r%s: ", TheNetMessage);
for (i = 0; i < NetCurPos; ++i)
{
fputc ('.', stderr);
}
fprintf (stderr, "%*c[%2d/%2d]", NetMaxPos + 1 - NetCurPos, ' ', NetCurPos, NetMaxPos);
fflush (stderr);
}
}
void FTTYStartupScreen::NetClose()
{
// TODO: Implement this
@ -249,6 +260,16 @@ bool FTTYStartupScreen::ShouldStartNet()
return false;
}
int FTTYStartupScreen::GetNetKickClient()
{
return -1;
}
int FTTYStartupScreen::GetNetBanClient()
{
return -1;
}
//===========================================================================
//
// FTTYStartupScreen :: NetLoop
@ -263,7 +284,7 @@ bool FTTYStartupScreen::ShouldStartNet()
//
//===========================================================================
bool FTTYStartupScreen::NetLoop(bool (*timer_callback)(void *), void *userdata)
bool FTTYStartupScreen::NetLoop(bool (*loopCallback)(void *), void *data)
{
fd_set rfds;
struct timeval tv;
@ -291,7 +312,7 @@ bool FTTYStartupScreen::NetLoop(bool (*timer_callback)(void *), void *userdata)
}
else if (retval == 0)
{
if (timer_callback (userdata))
if (loopCallback (data))
{
fputc ('\n', stderr);
return true;

52
src/common/platform/win32/i_mainwindow.cpp
View file

@ -118,34 +118,64 @@ void MainWindow::ShowErrorPane(const char* text)
restartrequest = ErrorWindow::ExecModal(text, alltext);
}
void MainWindow::ShowNetStartPane(const char* message, int maxpos)
void MainWindow::NetInit(const char* message, bool host)
{
NetStartWindow::ShowNetStartPane(message, maxpos);
NetStartWindow::NetInit(message, host);
}
void MainWindow::HideNetStartPane()
void MainWindow::NetMessage(const char* message)
{
NetStartWindow::HideNetStartPane();
NetStartWindow::NetMessage(message);
}
void MainWindow::CloseNetStartPane()
void MainWindow::NetConnect(int client, const char* name, unsigned flags, int status)
{
NetStartWindow::NetConnect(client, name, flags, status);
}
void MainWindow::NetUpdate(int client, int status)
{
NetStartWindow::NetUpdate(client, status);
}
void MainWindow::NetDisconnect(int client)
{
NetStartWindow::NetDisconnect(client);
}
void MainWindow::NetProgress(int cur, int limit)
{
NetStartWindow::NetProgress(cur, limit);
}
void MainWindow::NetDone()
{
NetStartWindow::NetDone();
}
void MainWindow::NetClose()
{
NetStartWindow::NetClose();
}
bool MainWindow::ShouldStartNetGame()
bool MainWindow::ShouldStartNet()
{
return NetStartWindow::ShouldStartNetGame();
return NetStartWindow::ShouldStartNet();
}
void MainWindow::SetNetStartProgress(int pos)
int MainWindow::GetNetKickClient()
{
NetStartWindow::SetNetStartProgress(pos);
return NetStartWindow::GetNetKickClient();
}
bool MainWindow::RunMessageLoop(bool (*timer_callback)(void*), void* userdata)
int MainWindow::GetNetBanClient()
{
return NetStartWindow::RunMessageLoop(timer_callback, userdata);
return NetStartWindow::GetNetBanClient();
}
bool MainWindow::NetLoop(bool (*loopCallback)(void*), void* data)
{
return NetStartWindow::NetLoop(loopCallback, data);
}
bool MainWindow::CheckForRestart()

18
src/common/platform/win32/i_mainwindow.h
View file

@ -25,12 +25,18 @@ public:
void PrintStr(const char* cp);
void GetLog(std::function<bool(const void* data, uint32_t size, uint32_t& written)> writeFile);
void ShowNetStartPane(const char* message, int maxpos);
void SetNetStartProgress(int pos);
bool RunMessageLoop(bool (*timer_callback)(void*), void* userdata);
void HideNetStartPane();
void CloseNetStartPane();
bool ShouldStartNetGame();
void NetInit(const char* message, bool host);
void NetMessage(const char* message);
void NetConnect(int client, const char* name, unsigned flags, int status);
void NetUpdate(int client, int status);
void NetDisconnect(int client);
void NetProgress(int cur, int limit);
void NetDone();
void NetClose();
bool ShouldStartNet();
int GetNetKickClient();
int GetNetBanClient();
bool NetLoop(bool (*loopCallback)(void*), void* data);
void SetWindowTitle(const char* caption);

95
src/common/platform/win32/st_start.cpp
View file

@ -137,14 +137,46 @@ void FBasicStartupScreen::Progress()
//
//==========================================================================
void FBasicStartupScreen::NetInit(const char *message, int numplayers)
void FBasicStartupScreen::NetInit(const char *message, bool host)
{
NetMaxPos = numplayers;
mainwindow.ShowNetStartPane(message, numplayers);
NetMaxPos = numplayers;
mainwindow.NetInit(message, host);
NetCurPos = 0;
NetProgress(1); // You always know about yourself
}
void FBasicStartupScreen::NetMessage(const char* message)
{
mainwindow.NetMessage(message);
}
void FBasicStartupScreen::NetConnect(int client, const char* name, unsigned flags, int status)
{
mainwindow.NetConnect(client, name, flags, status);
}
void FBasicStartupScreen::NetUpdate(int client, int status)
{
mainwindow.NetUpdate(client, status);
}
void FBasicStartupScreen::NetDisconnect(int client)
{
mainwindow.NetDisconnect(client);
}
//==========================================================================
//
// FBasicStartupScreen :: NetProgress
//
// Sets the network progress meter. If count is 0, it gets bumped by 1.
// Otherwise, it is set to count.
//
//==========================================================================
void FBasicStartupScreen::NetProgress(int cur, int limit)
{
NetMaxPos = limit;
NetCurPos = cur;
mainwindow.NetProgress(cur, limit);
}
//==========================================================================
@ -157,30 +189,27 @@ void FBasicStartupScreen::NetInit(const char *message, int numplayers)
void FBasicStartupScreen::NetDone()
{
mainwindow.HideNetStartPane();
mainwindow.NetDone();
}
//==========================================================================
//
// FBasicStartupScreen :: NetProgress
//
// Sets the network progress meter. If count is 0, it gets bumped by 1.
// Otherwise, it is set to count.
//
//==========================================================================
void FBasicStartupScreen::NetProgress(int count)
void FBasicStartupScreen::NetClose()
{
if (count == 0)
{
NetCurPos++;
}
else
{
NetCurPos = count;
}
mainwindow.NetClose();
}
mainwindow.SetNetStartProgress(count);
bool FBasicStartupScreen::ShouldStartNet()
{
return mainwindow.ShouldStartNet();
}
int FBasicStartupScreen::GetNetKickClient()
{
return mainwindow.GetNetKickClient();
}
int FBasicStartupScreen::GetNetBanClient()
{
return mainwindow.GetNetBanClient();
}
//==========================================================================
@ -197,17 +226,7 @@ void FBasicStartupScreen::NetProgress(int count)
//
//==========================================================================
bool FBasicStartupScreen::NetLoop(bool (*timer_callback)(void *), void *userdata)
bool FBasicStartupScreen::NetLoop(bool (*loopCallback)(void*), void* data)
{
return mainwindow.RunMessageLoop(timer_callback, userdata);
}
void FBasicStartupScreen::NetClose()
{
mainwindow.CloseNetStartPane();
}
bool FBasicStartupScreen::ShouldStartNet()
{
return mainwindow.ShouldStartNetGame();
return mainwindow.NetLoop(loopCallback, data);
}

212
src/common/widgets/netstartwindow.cpp
View file

@ -5,45 +5,141 @@
#include "gstrings.h"
#include <zwidget/core/timer.h>
#include <zwidget/widgets/textlabel/textlabel.h>
#include <zwidget/widgets/listview/listview.h>
#include <zwidget/widgets/pushbutton/pushbutton.h>
NetStartWindow* NetStartWindow::Instance = nullptr;
void NetStartWindow::ShowNetStartPane(const char* message, int maxpos)
void NetStartWindow::NetInit(const char* message, bool host)
{
Size screenSize = GetScreenSize();
double windowWidth = 300.0;
double windowHeight = 150.0;
double windowWidth = 450.0;
double windowHeight = 600.0;
if (!Instance)
{
Instance = new NetStartWindow();
Instance = new NetStartWindow(host);
Instance->SetFrameGeometry((screenSize.width - windowWidth) * 0.5, (screenSize.height - windowHeight) * 0.5, windowWidth, windowHeight);
Instance->Show();
}
Instance->SetMessage(message, maxpos);
Instance->SetMessage(message);
}
void NetStartWindow::HideNetStartPane()
void NetStartWindow::NetMessage(const char* message)
{
if (Instance)
Instance->SetMessage(message);
}
void NetStartWindow::NetConnect(int client, const char* name, unsigned flags, int status)
{
if (!Instance)
return;
std::string value = "";
if (flags & 1)
value.append("*");
if (flags & 2)
value.append("H");
Instance->LobbyWindow->UpdateItem(value, client, 1);
Instance->LobbyWindow->UpdateItem(name, client, 2);
value = "";
if (status == 1)
value = "CONNECTING";
else if (status == 2)
value = "WAITING";
else if (status == 3)
value = "READY";
Instance->LobbyWindow->UpdateItem(value, client, 3);
}
void NetStartWindow::NetUpdate(int client, int status)
{
if (!Instance)
return;
std::string value = "";
if (status == 1)
value = "CONNECTING";
else if (status == 2)
value = "WAITING";
else if (status == 3)
value = "READY";
Instance->LobbyWindow->UpdateItem(value, client, 3);
}
void NetStartWindow::NetDisconnect(int client)
{
if (Instance)
{
for (size_t i = 1u; i < Instance->LobbyWindow->GetColumnAmount(); ++i)
Instance->LobbyWindow->UpdateItem("", client, i);
}
}
void NetStartWindow::NetProgress(int cur, int limit)
{
if (!Instance)
return;
Instance->maxpos = limit;
Instance->SetProgress(cur);
for (size_t start = Instance->LobbyWindow->GetItemAmount(); start < Instance->maxpos; ++start)
Instance->LobbyWindow->AddItem(std::to_string(start));
}
void NetStartWindow::NetDone()
{
delete Instance;
Instance = nullptr;
}
void NetStartWindow::SetNetStartProgress(int pos)
void NetStartWindow::NetClose()
{
if (Instance)
Instance->SetProgress(pos);
if (Instance != nullptr)
Instance->OnClose();
}
bool NetStartWindow::RunMessageLoop(bool (*newtimer_callback)(void*), void* newuserdata)
bool NetStartWindow::ShouldStartNet()
{
if (Instance != nullptr)
return Instance->shouldstart;
return false;
}
int NetStartWindow::GetNetKickClient()
{
if (!Instance || !Instance->kickclients.size())
return -1;
int next = Instance->kickclients.back();
Instance->kickclients.pop_back();
return next;
}
int NetStartWindow::GetNetBanClient()
{
if (!Instance || !Instance->banclients.size())
return -1;
int next = Instance->banclients.back();
Instance->banclients.pop_back();
return next;
}
bool NetStartWindow::NetLoop(bool (*loopCallback)(void*), void* data)
{
if (!Instance)
return false;
Instance->timer_callback = newtimer_callback;
Instance->userdata = newuserdata;
Instance->timer_callback = loopCallback;
Instance->userdata = data;
Instance->CallbackException = {};
DisplayWindow::RunLoop();
@ -57,21 +153,7 @@ bool NetStartWindow::RunMessageLoop(bool (*newtimer_callback)(void*), void* newu
return Instance->exitreason;
}
void NetStartWindow::NetClose()
{
if (Instance != nullptr)
Instance->OnClose();
}
bool NetStartWindow::ShouldStartNetGame()
{
if (Instance != nullptr)
return Instance->shouldstart;
return false;
}
NetStartWindow::NetStartWindow() : Widget(nullptr, WidgetType::Window)
NetStartWindow::NetStartWindow(bool host) : Widget(nullptr, WidgetType::Window)
{
SetWindowBackground(Colorf::fromRgba8(51, 51, 51));
SetWindowBorderColor(Colorf::fromRgba8(51, 51, 51));
@ -81,27 +163,43 @@ NetStartWindow::NetStartWindow() : Widget(nullptr, WidgetType::Window)
MessageLabel = new TextLabel(this);
ProgressLabel = new TextLabel(this);
LobbyWindow = new ListView(this);
AbortButton = new PushButton(this);
ForceStartButton = new PushButton(this);
MessageLabel->SetTextAlignment(TextLabelAlignment::Center);
ProgressLabel->SetTextAlignment(TextLabelAlignment::Center);
AbortButton->OnClick = [=]() { OnClose(); };
ForceStartButton->OnClick = [=]() { ForceStart(); };
AbortButton->SetText("Abort");
ForceStartButton->SetText("Start Game");
if (host)
{
hosting = true;
ForceStartButton = new PushButton(this);
ForceStartButton->OnClick = [=]() { ForceStart(); };
ForceStartButton->SetText("Start Game");
KickButton = new PushButton(this);
KickButton->OnClick = [=]() { OnKick(); };
KickButton->SetText("Kick");
BanButton = new PushButton(this);
BanButton->OnClick = [=]() { OnBan(); };
BanButton->SetText("Ban");
}
// Client number, flags, name, status.
LobbyWindow->SetColumnWidths({ 30.0, 30.0, 200.0, 50.0 });
CallbackTimer = new Timer(this);
CallbackTimer->FuncExpired = [=]() { OnCallbackTimerExpired(); };
CallbackTimer->Start(500);
}
void NetStartWindow::SetMessage(const std::string& message, int newmaxpos)
void NetStartWindow::SetMessage(const std::string& message)
{
MessageLabel->SetText(message);
maxpos = newmaxpos;
}
void NetStartWindow::SetProgress(int newpos)
@ -126,6 +224,36 @@ void NetStartWindow::ForceStart()
shouldstart = true;
}
void NetStartWindow::OnKick()
{
int item = LobbyWindow->GetSelectedItem();
size_t i = 0u;
for (; i < kickclients.size(); ++i)
{
if (kickclients[i] == item)
break;
}
if (i >= kickclients.size())
kickclients.push_back(item);
}
void NetStartWindow::OnBan()
{
int item = LobbyWindow->GetSelectedItem();
size_t i = 0u;
for (; i < banclients.size(); ++i)
{
if (banclients[i] == item)
break;
}
if (i >= banclients.size())
banclients.push_back(item);
}
void NetStartWindow::OnGeometryChanged()
{
double w = GetWidth();
@ -138,11 +266,23 @@ void NetStartWindow::OnGeometryChanged()
labelheight = ProgressLabel->GetPreferredHeight();
ProgressLabel->SetFrameGeometry(Rect::xywh(5.0, y, w - 10.0, labelheight));
y += labelheight;
y += labelheight + 5.0;
labelheight = (GetHeight() - 30.0 - AbortButton->GetPreferredHeight()) - y;
LobbyWindow->SetFrameGeometry(Rect::xywh(5.0, y, w - 10.0, labelheight));
y = GetHeight() - 15.0 - AbortButton->GetPreferredHeight();
AbortButton->SetFrameGeometry((w + 10.0) * 0.5, y, 100.0, AbortButton->GetPreferredHeight());
ForceStartButton->SetFrameGeometry((w - 210.0) * 0.5, y, 100.0, ForceStartButton->GetPreferredHeight());
if (hosting)
{
AbortButton->SetFrameGeometry((w + 215.0) * 0.5, y, 100.0, AbortButton->GetPreferredHeight());
BanButton->SetFrameGeometry((w + 5.0) * 0.5, y, 100.0, BanButton->GetPreferredHeight());
KickButton->SetFrameGeometry((w - 205.0) * 0.5, y, 100.0, KickButton->GetPreferredHeight());
ForceStartButton->SetFrameGeometry((w - 415.0) * 0.5, y, 100.0, ForceStartButton->GetPreferredHeight());
}
else
{
AbortButton->SetFrameGeometry((w - 100.0) * 0.5, y, 100.0, AbortButton->GetPreferredHeight());
}
}
void NetStartWindow::OnCallbackTimerExpired()

29
src/common/widgets/netstartwindow.h
View file

@ -4,37 +4,49 @@
#include <stdexcept>
class TextLabel;
class ListView;
class PushButton;
class Timer;
class NetStartWindow : public Widget
{
public:
static void ShowNetStartPane(const char* message, int maxpos);
static void HideNetStartPane();
static void SetNetStartProgress(int pos);
static bool RunMessageLoop(bool (*timer_callback)(void*), void* userdata);
static void NetInit(const char* message, bool host);
static void NetMessage(const char* message);
static void NetConnect(int client, const char* name, unsigned flags, int status);
static void NetUpdate(int client, int status);
static void NetDisconnect(int client);
static void NetProgress(int cur, int limit);
static void NetDone();
static void NetClose();
static bool ShouldStartNetGame();
static bool ShouldStartNet();
static int GetNetKickClient();
static int GetNetBanClient();
static bool NetLoop(bool (*timer_callback)(void*), void* userdata);
private:
NetStartWindow();
NetStartWindow(bool host);
void SetMessage(const std::string& message, int maxpos);
void SetMessage(const std::string& message);
void SetProgress(int pos);
protected:
void OnClose() override;
void OnGeometryChanged() override;
virtual void ForceStart();
virtual void OnKick();
virtual void OnBan();
private:
void OnCallbackTimerExpired();
TextLabel* MessageLabel = nullptr;
TextLabel* ProgressLabel = nullptr;
ListView* LobbyWindow = nullptr;
PushButton* AbortButton = nullptr;
PushButton* ForceStartButton = nullptr;
PushButton* KickButton = nullptr;
PushButton* BanButton = nullptr;
Timer* CallbackTimer = nullptr;
@ -45,6 +57,9 @@ private:
bool exitreason = false;
bool shouldstart = false;
bool hosting = false;
std::vector<int> kickclients;
std::vector<int> banclients;
std::exception_ptr CallbackException;

516
src/d_net.cpp
View file

@ -87,12 +87,6 @@ extern bool AppActive;
void P_ClearLevelInterpolation();
struct FNetGameInfo
{
uint32_t DetectedPlayers[MAXPLAYERS];
uint8_t GotSetup[MAXPLAYERS];
};
enum ELevelStartStatus
{
LST_READY,
@ -107,8 +101,6 @@ enum ELevelStartStatus
//
// A world tick cannot be ran until CurrentSequence >= gametic for all clients.
#define NetBuffer (doomcom.data)
ENetMode NetMode = NET_PeerToPeer;
int ClientTic = 0;
usercmd_t LocalCmds[LOCALCMDTICS] = {};
int LastSentConsistency = 0; // Last consistency we sent out. If < CurrentConsistency, send them out.
@ -124,12 +116,12 @@ static uint8_t LocalNetBuffer[MAX_MSGLEN] = {};
static uint8_t CurrentLobbyID = 0u; // Ignore commands not from this lobby (useful when transitioning levels).
static int LastGameUpdate = 0; // Track the last time the game actually ran the world.
static int MutedClients = 0; // Ignore messages from these clients.
static uint64_t MutedClients = 0u; // Ignore messages from these clients.
static int LevelStartDebug = 0;
static int LevelStartDelay = 0; // While this is > 0, don't start generating packets yet.
static ELevelStartStatus LevelStartStatus = LST_READY; // Listen for when to actually start making tics.
static int LevelStartAck = 0; // Used by the host to determine if everyone has loaded in.
static uint64_t LevelStartAck = 0u; // Used by the host to determine if everyone has loaded in.
static int FullLatencyCycle = MAXSENDTICS * 3; // Give ~3 seconds to gather latency info about clients on boot up.
static int LastLatencyUpdate = 0; // Update average latency every ~1 second.
@ -146,7 +138,6 @@ void D_ProcessEvents(void);
void G_BuildTiccmd(usercmd_t *cmd);
void D_DoAdvanceDemo(void);
static void SendSetup(const FNetGameInfo& info, int len);
static void RunScript(uint8_t **stream, AActor *pawn, int snum, int argn, int always);
extern bool advancedemo;
@ -231,14 +222,14 @@ public:
void ResetStream()
{
CurrentClientTic = ClientTic / doomcom.ticdup;
CurrentClientTic = ClientTic / TicDup;
CurrentStream = Streams[CurrentClientTic % BACKUPTICS].Stream;
CurrentSize = 0;
}
void NewClientTic()
{
const int tic = ClientTic / doomcom.ticdup;
const int tic = ClientTic / TicDup;
if (CurrentClientTic == tic)
return;
@ -342,14 +333,14 @@ void Net_ClearBuffers()
state.Tics[j].Data.SetData(nullptr, 0);
}
doomcom.command = doomcom.datalength = 0;
doomcom.remoteplayer = -1;
doomcom.numplayers = doomcom.ticdup = 1;
consoleplayer = doomcom.consoleplayer = 0;
LocalNetBufferSize = 0;
NetBufferLength = 0u;
RemoteClient = -1;
MaxClients = TicDup = 1u;
consoleplayer = 0;
LocalNetBufferSize = 0u;
Net_Arbitrator = 0;
MutedClients = 0;
MutedClients = 0u;
CurrentLobbyID = 0u;
NetworkClients.Clear();
NetMode = NET_PeerToPeer;
@ -360,7 +351,7 @@ void Net_ClearBuffers()
SkipCommandTimer = SkipCommandAmount = CommandsAhead = 0;
NetEvents.ResetStream();
LevelStartAck = 0;
LevelStartAck = 0u;
LevelStartDelay = LevelStartDebug = 0;
LevelStartStatus = LST_READY;
@ -377,17 +368,17 @@ void Net_ResetCommands(bool midTic)
++CurrentLobbyID;
SkipCommandTimer = SkipCommandAmount = CommandsAhead = 0;
int tic = gametic / doomcom.ticdup;
int tic = gametic / TicDup;
if (midTic)
{
// If we're mid ticdup cycle, make sure we immediately enter the next one after
// the current tic we're in finishes.
ClientTic = (tic + 1) * doomcom.ticdup;
gametic = (tic * doomcom.ticdup) + (doomcom.ticdup - 1);
ClientTic = (tic + 1) * TicDup;
gametic = (tic * TicDup) + (TicDup - 1);
}
else
{
ClientTic = gametic = tic * doomcom.ticdup;
ClientTic = gametic = tic * TicDup;
--tic;
}
@ -420,17 +411,17 @@ void Net_SetWaiting()
static int GetNetBufferSize()
{
if (NetBuffer[0] & NCMD_EXIT)
return 1 + (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator);
return 1 + (NetMode == NET_PacketServer && RemoteClient == Net_Arbitrator);
// TODO: Need a skipper for this.
if (NetBuffer[0] & NCMD_SETUP)
return doomcom.datalength;
return NetBufferLength;
if (NetBuffer[0] & (NCMD_LATENCY | NCMD_LATENCYACK))
return 2;
if (NetBuffer[0] & NCMD_LEVELREADY)
{
int bytes = 2;
if (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator)
if (NetMode == NET_PacketServer && RemoteClient == Net_Arbitrator)
bytes += 2;
return bytes;
@ -448,23 +439,23 @@ static int GetNetBufferSize()
const int ranTics = NetBuffer[totalBytes++];
if (ranTics > 0)
totalBytes += 4;
if (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator)
if (NetMode == NET_PacketServer && RemoteClient == Net_Arbitrator)
++totalBytes;
// Minimum additional packet size per player:
// 1 byte for player number
// If in packet server mode and from the host, 2 bytes for the latency to the host
int padding = 1;
if (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator)
if (NetMode == NET_PacketServer && RemoteClient == Net_Arbitrator)
padding += 2;
if (doomcom.datalength < totalBytes + playerCount * padding)
if (NetBufferLength < totalBytes + playerCount * padding)
return totalBytes + playerCount * padding;
uint8_t* skipper = &NetBuffer[totalBytes];
for (int p = 0; p < playerCount; ++p)
{
++skipper;
if (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator)
if (NetMode == NET_PacketServer && RemoteClient == Net_Arbitrator)
skipper += 2;
for (int i = 0; i < ranTics; ++i)
@ -489,8 +480,8 @@ static void HSendPacket(int client, size_t size)
if (demoplayback)
return;
doomcom.remoteplayer = client;
doomcom.datalength = size;
RemoteClient = client;
NetBufferLength = size;
if (client == consoleplayer)
{
memcpy(LocalNetBuffer, NetBuffer, size);
@ -501,8 +492,7 @@ static void HSendPacket(int client, size_t size)
if (!netgame)
I_Error("Tried to send a packet to a client while offline");
doomcom.command = CMD_SEND;
I_NetCmd();
I_NetCmd(CMD_SEND);
}
// HGetPacket
@ -515,34 +505,23 @@ static bool HGetPacket()
if (LocalNetBufferSize)
{
memcpy(NetBuffer, LocalNetBuffer, LocalNetBufferSize);
doomcom.datalength = LocalNetBufferSize;
doomcom.remoteplayer = consoleplayer;
LocalNetBufferSize = 0;
NetBufferLength = LocalNetBufferSize;
RemoteClient = consoleplayer;
LocalNetBufferSize = 0u;
return true;
}
if (!netgame)
return false;
doomcom.command = CMD_GET;
I_NetCmd();
if (doomcom.remoteplayer == -1)
I_NetCmd(CMD_GET);
if (RemoteClient == -1)
return false;
// When the host randomly drops this can cause issues in packet server mode, so at
// least attempt to recover gracefully.
if (NetMode == NET_PacketServer && doomcom.remoteplayer == Net_Arbitrator
&& (NetBuffer[0] & NCMD_EXIT) && doomcom.datalength == 1)
{
NetBuffer[1] = NetworkClients[1];
doomcom.datalength = 2;
}
int sizeCheck = GetNetBufferSize();
if (doomcom.datalength != sizeCheck)
if (NetBufferLength != sizeCheck)
{
Printf("Incorrect packet size %d (expected %d)\n", doomcom.datalength, sizeCheck);
Printf("Incorrect packet size %d (expected %d)\n", NetBufferLength, sizeCheck);
return false;
}
@ -560,8 +539,8 @@ static void ClientConnecting(int client)
static void DisconnectClient(int clientNum)
{
NetworkClients -= clientNum;
MutedClients &= ~(1 << clientNum);
I_ClearNode(clientNum);
MutedClients &= ~((uint64_t)1u << clientNum);
I_ClearClient(clientNum);
// Capture the pawn leaving in the next world tick.
players[clientNum].playerstate = PST_GONE;
}
@ -634,21 +613,21 @@ static void CheckLevelStart(int client, int delayTics)
if (client == Net_Arbitrator)
{
LevelStartAck = 0;
LevelStartAck = 0u;
LevelStartStatus = NetMode == NET_PacketServer && consoleplayer == Net_Arbitrator ? LST_HOST : LST_READY;
LevelStartDelay = LevelStartDebug = delayTics;
LastGameUpdate = EnterTic;
return;
}
int mask = 0;
uint64_t mask = 0u;
for (auto pNum : NetworkClients)
{
if (pNum != Net_Arbitrator)
mask |= 1 << pNum;
mask |= (uint64_t)1u << pNum;
}
LevelStartAck |= 1 << client;
LevelStartAck |= (uint64_t)1u << client;
if ((LevelStartAck & mask) == mask && IsMapLoaded())
{
// Beyond this point a player is likely lagging out anyway.
@ -707,10 +686,9 @@ struct FLatencyAck
static void GetPackets()
{
TArray<FLatencyAck> latencyAcks = {};
TArray<int> stuckInLobby = {};
while (HGetPacket())
{
const int clientNum = doomcom.remoteplayer;
const int clientNum = RemoteClient;
auto& clientState = ClientStates[clientNum];
if (NetBuffer[0] & NCMD_EXIT)
@ -721,16 +699,7 @@ static void GetPackets()
if (NetBuffer[0] & NCMD_SETUP)
{
if (NetworkClients.InGame(clientNum))
{
if (consoleplayer == Net_Arbitrator && stuckInLobby.Find(clientNum) >= stuckInLobby.Size())
stuckInLobby.Push(clientNum);
}
else
{
ClientConnecting(clientNum);
}
HandleIncomingConnection();
continue;
}
@ -912,12 +881,6 @@ static void GetPackets()
NetBuffer[1] = ack.Seq;
HSendPacket(ack.Client, 2);
}
for (auto client : stuckInLobby)
{
NetBuffer[0] = NCMD_GAMEREADY;
HSendPacket(client, 1);
}
}
static void SendHeartbeat()
@ -1033,7 +996,7 @@ static int16_t CalculateConsistency(int client, uint32_t seed)
// check, not just the player's x position like BOOM.
static void MakeConsistencies()
{
if (!netgame || demoplayback || (gametic % doomcom.ticdup) || !IsMapLoaded())
if (!netgame || demoplayback || (gametic % TicDup) || !IsMapLoaded())
return;
const uint32_t rngSum = StaticSumSeeds();
@ -1057,7 +1020,7 @@ static bool Net_UpdateStatus()
// Check against the previous tick in case we're recovering from a huge
// system hiccup. If the game has taken too long to update, it's likely
// another client is hanging up the game.
if (LastEnterTic - LastGameUpdate >= MAXSENDTICS * doomcom.ticdup)
if (LastEnterTic - LastGameUpdate >= MAXSENDTICS * TicDup)
{
// Try again in the next MaxDelay tics.
LastGameUpdate = EnterTic;
@ -1066,7 +1029,7 @@ static bool Net_UpdateStatus()
{
// Use a missing packet here to tell the other players to retransmit instead of simply retransmitting our
// own data over instantly. This avoids flooding the network at a time where it's not opportune to do so.
const int curTic = gametic / doomcom.ticdup;
const int curTic = gametic / TicDup;
for (auto client : NetworkClients)
{
if (client == consoleplayer)
@ -1125,7 +1088,7 @@ static bool Net_UpdateStatus()
else if (consoleplayer == Net_Arbitrator)
{
// If we're consistenty ahead of the highest sequence player, slow down.
const int curTic = ClientTic / doomcom.ticdup;
const int curTic = ClientTic / TicDup;
for (auto client : NetworkClients)
{
if (client != Net_Arbitrator && (ClientStates[client].Flags & CF_UPDATED))
@ -1156,7 +1119,7 @@ static bool Net_UpdateStatus()
{
SkipCommandTimer = 0;
if (SkipCommandAmount <= 0)
SkipCommandAmount = lowestDiff * doomcom.ticdup;
SkipCommandAmount = lowestDiff * TicDup;
}
}
else
@ -1219,7 +1182,7 @@ void NetUpdate(int tics)
{
// If we're the host, idly wait until all packets have arrived. There's no point in predicting since we
// know for a fact the game won't be started until everyone is accounted for. (Packet server only)
const int curTic = gametic / doomcom.ticdup;
const int curTic = gametic / TicDup;
int lowestSeq = curTic;
for (auto client : NetworkClients)
{
@ -1241,7 +1204,7 @@ void NetUpdate(int tics)
const bool netGood = Net_UpdateStatus();
const int startTic = ClientTic;
tics = min<int>(tics, MAXSENDTICS * doomcom.ticdup);
tics = min<int>(tics, MAXSENDTICS * TicDup);
for (int i = 0; i < tics; ++i)
{
I_StartTic();
@ -1256,18 +1219,18 @@ void NetUpdate(int tics)
}
G_BuildTiccmd(&LocalCmds[ClientTic++ % LOCALCMDTICS]);
if (doomcom.ticdup == 1)
if (TicDup == 1)
{
Net_NewClientTic();
}
else
{
const int ticDiff = ClientTic % doomcom.ticdup;
const int ticDiff = ClientTic % TicDup;
if (ticDiff)
{
const int startTic = ClientTic - ticDiff;
// Even if we're not sending out inputs, update the local commands so that the doomcom.ticdup
// Even if we're not sending out inputs, update the local commands so that the TicDup
// is correctly played back while predicting as best as possible. This will help prevent
// minor hitches when playing online.
for (int j = ClientTic - 1; j > startTic; --j)
@ -1275,10 +1238,10 @@ void NetUpdate(int tics)
}
else
{
// Gather up the Command across the last doomcom.ticdup number of tics
// Gather up the Command across the last TicDup number of tics
// and average them out. These are propagated back to the local
// command so that they'll be predicted correctly.
const int lastTic = ClientTic - doomcom.ticdup;
const int lastTic = ClientTic - TicDup;
for (int j = ClientTic - 1; j > lastTic; --j)
LocalCmds[(j - 1) % LOCALCMDTICS].buttons |= LocalCmds[j % LOCALCMDTICS].buttons;
@ -1289,7 +1252,7 @@ void NetUpdate(int tics)
int sidemove = 0;
int upmove = 0;
for (int j = 0; j < doomcom.ticdup; ++j)
for (int j = 0; j < TicDup; ++j)
{
const int mod = (lastTic + j) % LOCALCMDTICS;
pitch += LocalCmds[mod].pitch;
@ -1300,14 +1263,14 @@ void NetUpdate(int tics)
upmove += LocalCmds[mod].upmove;
}
pitch /= doomcom.ticdup;
yaw /= doomcom.ticdup;
roll /= doomcom.ticdup;
forwardmove /= doomcom.ticdup;
sidemove /= doomcom.ticdup;
upmove /= doomcom.ticdup;
pitch /= TicDup;
yaw /= TicDup;
roll /= TicDup;
forwardmove /= TicDup;
sidemove /= TicDup;
upmove /= TicDup;
for (int j = 0; j < doomcom.ticdup; ++j)
for (int j = 0; j < TicDup; ++j)
{
const int mod = (lastTic + j) % LOCALCMDTICS;
LocalCmds[mod].pitch = pitch;
@ -1323,7 +1286,7 @@ void NetUpdate(int tics)
}
}
const int newestTic = ClientTic / doomcom.ticdup;
const int newestTic = ClientTic / TicDup;
if (demoplayback)
{
// Don't touch net command data while playing a demo, as it'll already exist.
@ -1333,7 +1296,7 @@ void NetUpdate(int tics)
return;
}
int startSequence = startTic / doomcom.ticdup;
int startSequence = startTic / TicDup;
int endSequence = newestTic;
int quitters = 0;
int quitNums[MAXPLAYERS];
@ -1342,7 +1305,7 @@ void NetUpdate(int tics)
// In packet server mode special handling is used to ensure the host only
// sends out available tics when ready instead of constantly shotgunning
// them out as they're made locally.
startSequence = gametic / doomcom.ticdup;
startSequence = gametic / TicDup;
int lowestSeq = endSequence - 1;
for (auto client : NetworkClients)
{
@ -1359,7 +1322,7 @@ void NetUpdate(int tics)
endSequence = lowestSeq + 1;
}
const bool resendOnly = startSequence == endSequence && (ClientTic % doomcom.ticdup);
const bool resendOnly = startSequence == endSequence && (ClientTic % TicDup);
for (auto client : NetworkClients)
{
// If in packet server mode, we don't want to send information to anyone but the host. On the other
@ -1509,8 +1472,8 @@ void NetUpdate(int tics)
int curTic = sequenceNum + t, lastTic = curTic - 1;
if (playerNums[i] == consoleplayer)
{
int realTic = (curTic * doomcom.ticdup) % LOCALCMDTICS;
int realLastTic = (lastTic * doomcom.ticdup) % LOCALCMDTICS;
int realTic = (curTic * TicDup) % LOCALCMDTICS;
int realLastTic = (lastTic * TicDup) % LOCALCMDTICS;
// Write out the net events before the user commands so inputs can
// be used as a marker for when the given command ends.
auto& stream = NetEvents.Streams[curTic % BACKUPTICS];
@ -1556,291 +1519,78 @@ void NetUpdate(int tics)
GetPackets();
}
// User info packets look like this:
//
// One byte set to NCMD_SETUP or NCMD_USERINFO
// One byte for the relevant player number.
// Three bytes for the sender's game version (major, minor, revision).
// Four bytes for the bit mask indicating which players the sender knows about.
// If NCMD_SETUP, one byte indicating the guest got the game setup info.
// Player's user information.
//
// The guests always send NCMD_SETUP packets, and the host always
// sends NCMD_USERINFO packets.
//
// Game info packets look like this:
//
// One byte set to NCMD_GAMEINFO.
// One byte for doomcom.ticdup setting.
// One byte for NetMode setting.
// String with starting map's name.
// The game's RNG seed.
// Remaining game information.
//
// Ready packets look like this:
//
// One byte set to NCMD_GAMEREADY.
//
// Each machine sends user info packets to the host. The host sends user
// info packets back to the other machines as well as game info packets.
// Negotiation is done when all the guests have reported to the host that
// they know about the other nodes.
// These have to be here since they have game-specific data. Only the data
// from the frontend should be put in these, all backend handling should be
// done in the core files.
bool ExchangeNetGameInfo(void *userdata)
void Net_SetupUserInfo()
{
FNetGameInfo *data = reinterpret_cast<FNetGameInfo*>(userdata);
uint8_t *stream = nullptr;
while (HGetPacket())
{
// For now throw an error until something more complex can be done to handle this case.
if (NetBuffer[0] == NCMD_EXIT)
I_Error("Game unexpectedly ended.");
if (NetBuffer[0] == NCMD_SETUP || NetBuffer[0] == NCMD_USERINFO)
{
int clientNum = NetBuffer[1];
data->DetectedPlayers[clientNum] =
(NetBuffer[5] << 24) | (NetBuffer[6] << 16) | (NetBuffer[7] << 8) | NetBuffer[8];
if (NetBuffer[0] == NCMD_SETUP)
{
// Sent from guest.
data->GotSetup[clientNum] = NetBuffer[9];
stream = &NetBuffer[10];
}
else
{
// Sent from host.
stream = &NetBuffer[9];
}
D_ReadUserInfoStrings(clientNum, &stream, false);
if (!NetworkClients.InGame(clientNum))
{
if (NetBuffer[2] != VER_MAJOR % 255 || NetBuffer[3] != VER_MINOR % 255 || NetBuffer[4] != VER_REVISION % 255)
I_Error("Different " GAMENAME " versions cannot play a net game");
NetworkClients += clientNum;
data->DetectedPlayers[consoleplayer] |= 1 << clientNum;
I_NetMessage("Found %s (%d)", players[clientNum].userinfo.GetName(), clientNum);
}
}
else if (NetBuffer[0] == NCMD_GAMEINFO)
{
data->GotSetup[consoleplayer] = true;
doomcom.ticdup = clamp<int>(NetBuffer[1], 1, MAXTICDUP);
NetMode = static_cast<ENetMode>(NetBuffer[2]);
stream = &NetBuffer[3];
startmap = ReadStringConst(&stream);
rngseed = ReadInt32(&stream);
C_ReadCVars(&stream);
}
else if (NetBuffer[0] == NCMD_GAMEREADY)
{
return true;
}
}
// If everybody already knows everything, it's time to start.
if (consoleplayer == Net_Arbitrator)
{
bool stillWaiting = false;
// Update this dynamically.
uint32_t allPlayers = 0u;
for (int i = 0; i < doomcom.numplayers; ++i)
allPlayers |= 1 << i;
for (int i = 0; i < doomcom.numplayers; ++i)
{
if (!data->GotSetup[i] || (data->DetectedPlayers[i] & allPlayers) != allPlayers)
{
stillWaiting = true;
break;
}
}
if (!stillWaiting)
return true;
}
NetBuffer[2] = VER_MAJOR % 255;
NetBuffer[3] = VER_MINOR % 255;
NetBuffer[4] = VER_REVISION % 255;
NetBuffer[5] = data->DetectedPlayers[consoleplayer] >> 24;
NetBuffer[6] = data->DetectedPlayers[consoleplayer] >> 16;
NetBuffer[7] = data->DetectedPlayers[consoleplayer] >> 8;
NetBuffer[8] = data->DetectedPlayers[consoleplayer];
if (consoleplayer != Net_Arbitrator)
{
// If we're a guest, send our info over to the host.
NetBuffer[0] = NCMD_SETUP;
NetBuffer[1] = consoleplayer;
NetBuffer[9] = data->GotSetup[consoleplayer];
stream = &NetBuffer[10];
// If the host already knows we're here, just send over a heartbeat.
if (!(data->DetectedPlayers[Net_Arbitrator] & (1 << consoleplayer)))
{
auto str = D_GetUserInfoStrings(consoleplayer, true);
const size_t userSize = str.Len() + 1;
memcpy(stream, str.GetChars(), userSize);
stream += userSize;
}
else
{
*stream = 0;
++stream;
}
}
else
{
// If we're the host, send over known player data to guests. This is done instantly
// since the game info will also get sent out after this.
NetBuffer[0] = NCMD_USERINFO;
for (auto client : NetworkClients)
{
if (client == Net_Arbitrator)
continue;
for (auto cl : NetworkClients)
{
if (cl == client)
continue;
// If the host knows about a client that the guest doesn't, send that client's info over to them.
const int clBit = 1 << cl;
if ((data->DetectedPlayers[Net_Arbitrator] & clBit) && !(data->DetectedPlayers[client] & clBit))
{
NetBuffer[1] = cl;
stream = &NetBuffer[9];
auto str = D_GetUserInfoStrings(cl, true);
const size_t userSize = str.Len() + 1;
memcpy(stream, str.GetChars(), userSize);
stream += userSize;
HSendPacket(client, int(stream - NetBuffer));
}
}
}
// If we're the host, send the game info too.
NetBuffer[0] = NCMD_GAMEINFO;
NetBuffer[1] = (uint8_t)doomcom.ticdup;
NetBuffer[2] = NetMode;
stream = &NetBuffer[3];
WriteString(startmap.GetChars(), &stream);
WriteInt32(rngseed, &stream);
C_WriteCVars(&stream, CVAR_SERVERINFO, true);
}
SendSetup(*data, int(stream - NetBuffer));
return false;
D_SetupUserInfo();
}
static bool D_ExchangeNetInfo()
const char* Net_GetClientName(int client, unsigned int charLimit = 0u)
{
// Return right away if it's just a solo net game.
if (doomcom.numplayers == 1)
return true;
autostart = true;
FNetGameInfo info = {};
info.DetectedPlayers[consoleplayer] = 1 << consoleplayer;
info.GotSetup[consoleplayer] = consoleplayer == Net_Arbitrator;
NetworkClients += consoleplayer;
if (consoleplayer == Net_Arbitrator)
I_NetInit("Sending game information", 1);
else
I_NetInit("Waiting for host information", 1);
if (!I_NetLoop(ExchangeNetGameInfo, &info))
return false;
// Let everyone else know the game is ready to start.
if (consoleplayer == Net_Arbitrator)
{
NetBuffer[0] = NCMD_GAMEREADY;
for (auto client : NetworkClients)
{
if (client != Net_Arbitrator)
HSendPacket(client, 1);
}
}
I_NetDone();
return true;
return players[client].userinfo.GetName(charLimit);
}
static void SendSetup(const FNetGameInfo& info, int len)
int Net_SetUserInfo(int client, uint8_t*& stream)
{
if (consoleplayer != Net_Arbitrator)
{
HSendPacket(Net_Arbitrator, len);
}
else
{
for (auto client : NetworkClients)
{
// Only send game info over to clients still needing it.
if (client != Net_Arbitrator && !info.GotSetup[client])
HSendPacket(client, len);
}
}
auto str = D_GetUserInfoStrings(client, true);
const size_t userSize = str.Len() + 1;
memcpy(stream, str.GetChars(), userSize);
return userSize;
}
int Net_ReadUserInfo(int client, uint8_t*& stream)
{
const uint8_t* start = stream;
D_ReadUserInfoStrings(client, &stream, false);
return int(stream - start);
}
int Net_SetGameInfo(uint8_t*& stream)
{
const uint8_t* start = stream;
WriteString(startmap.GetChars(), &stream);
WriteInt32(rngseed, &stream);
C_WriteCVars(&stream, CVAR_SERVERINFO, true);
return int(stream - start);
}
int Net_ReadGameInfo(uint8_t*& stream)
{
const uint8_t* start = stream;
startmap = ReadStringConst(&stream);
rngseed = ReadInt32(&stream);
C_ReadCVars(&stream);
return int(stream - start);
}
// Connects players to each other if needed.
bool D_CheckNetGame()
{
const char* v = Args->CheckValue("-netmode");
int result = I_InitNetwork(); // I_InitNetwork sets doomcom and netgame
if (result == -1)
if (!I_InitNetwork())
return false;
else if (result > 0 && v == nullptr) // Don't override manual netmode setting.
NetMode = NET_PacketServer;
if (doomcom.id != DOOMCOM_ID)
I_FatalError("Invalid doomcom id set for network buffer");
if (GameID != DEFAULT_GAME_ID)
I_FatalError("Invalid id set for network buffer");
if (Args->CheckParm("-extratic"))
net_extratic = true;
players[Net_Arbitrator].settings_controller = true;
consoleplayer = doomcom.consoleplayer;
if (consoleplayer == Net_Arbitrator)
{
if (v != nullptr)
NetMode = atoi(v) ? NET_PacketServer : NET_PeerToPeer;
if (doomcom.numplayers > 1)
{
Printf("Selected " TEXTCOLOR_BLUE "%s" TEXTCOLOR_NORMAL " networking mode. (%s)\n", NetMode == NET_PeerToPeer ? "peer to peer" : "packet server",
v != nullptr ? "forced" : "auto");
}
if (Args->CheckParm("-extratic"))
net_extratic = true;
}
// [RH] Setup user info
D_SetupUserInfo();
if (netgame)
{
GameConfig->ReadNetVars(); // [RH] Read network ServerInfo cvars
if (!D_ExchangeNetInfo())
return false;
}
for (auto client : NetworkClients)
playeringame[client] = true;
if (consoleplayer != Net_Arbitrator && doomcom.numplayers > 1)
Printf("Host selected " TEXTCOLOR_BLUE "%s" TEXTCOLOR_NORMAL " networking mode.\n", NetMode == NET_PeerToPeer ? "peer to peer" : "packet server");
if (MaxClients > 1u)
{
if (consoleplayer == Net_Arbitrator)
Printf("Selected " TEXTCOLOR_BLUE "%s" TEXTCOLOR_NORMAL " networking mode\n", NetMode == NET_PeerToPeer ? "peer to peer" : "packet server");
else
Printf("Host selected " TEXTCOLOR_BLUE "%s" TEXTCOLOR_NORMAL " networking mode\n", NetMode == NET_PeerToPeer ? "peer to peer" : "packet server");
Printf("player %d of %d\n", consoleplayer + 1, doomcom.numplayers);
Printf("Player %d of %d\n", consoleplayer + 1, MaxClients);
}
return true;
}
@ -1918,19 +1668,19 @@ ADD_STAT(network)
}
out.AppendFormat("Max players: %d\tNet mode: %s\tTic dup: %d",
doomcom.numplayers,
MaxClients,
NetMode == NET_PacketServer ? "Packet server" : "Peer to peer",
doomcom.ticdup);
TicDup);
if (net_extratic)
out.AppendFormat("\tExtra tic enabled");
out.AppendFormat("\nWorld tic: %06d (sequence %06d)", gametic, gametic / doomcom.ticdup);
out.AppendFormat("\nWorld tic: %06d (sequence %06d)", gametic, gametic / TicDup);
if (NetMode == NET_PacketServer && consoleplayer != Net_Arbitrator)
out.AppendFormat("\tStart tics delay: %d", LevelStartDebug);
const int delay = max<int>((ClientTic - gametic) / doomcom.ticdup, 0);
const int msDelay = min<int>(delay * doomcom.ticdup * 1000.0 / TICRATE, 999);
const int delay = max<int>((ClientTic - gametic) / TicDup, 0);
const int msDelay = min<int>(delay * TicDup * 1000.0 / TICRATE, 999);
out.AppendFormat("\nLocal\n\tIs arbitrator: %d\tDelay: %02d (%03dms)",
consoleplayer == Net_Arbitrator,
delay, msDelay);
@ -1948,7 +1698,7 @@ ADD_STAT(network)
out.AppendFormat("\tWaiting for arbitrator");
}
int lowestSeq = ClientTic / doomcom.ticdup;
int lowestSeq = ClientTic / TicDup;
for (auto client : NetworkClients)
{
if (client == consoleplayer)
@ -1980,8 +1730,8 @@ ADD_STAT(network)
if (NetMode != NET_PacketServer)
{
const int cDelay = max<int>(state.CurrentSequence - (gametic / doomcom.ticdup), 0);
const int mscDelay = min<int>(cDelay * doomcom.ticdup * 1000.0 / TICRATE, 999);
const int cDelay = max<int>(state.CurrentSequence - (gametic / TicDup), 0);
const int mscDelay = min<int>(cDelay * TicDup * 1000.0 / TICRATE, 999);
out.AppendFormat("\tDelay: %02d (%03dms)", cDelay, mscDelay);
}
@ -1991,7 +1741,7 @@ ADD_STAT(network)
}
if (NetMode != NET_PacketServer || consoleplayer == Net_Arbitrator)
out.AppendFormat("\nAvailable tics: %03d", max<int>(lowestSeq - (gametic / doomcom.ticdup), 0));
out.AppendFormat("\nAvailable tics: %03d", max<int>(lowestSeq - (gametic / TicDup), 0));
return out;
}
@ -2091,7 +1841,7 @@ void TryRunTics()
// If the lowest confirmed tic matches the server gametic or greater, allow the client
// to run some of them.
const int availableTics = (lowestSequence - gametic / doomcom.ticdup) + 1;
const int availableTics = (lowestSequence - gametic / TicDup) + 1;
// If the amount of tics to run is falling behind the amount of available tics,
// speed the playsim up a bit to help catch up.
@ -2314,7 +2064,7 @@ void Net_DoCommand(int cmd, uint8_t **stream, int player)
s = ReadStringConst(stream);
// If chat is disabled, there's nothing else to do here since the stream has been advanced.
if (cl_showchat == CHAT_DISABLED || (MutedClients & (1 << player)))
if (cl_showchat == CHAT_DISABLED || (MutedClients & ((uint64_t)1u << player)))
break;
constexpr int MSG_TEAM = 1;
@ -3195,7 +2945,7 @@ CCMD(mute)
return;
}
MutedClients |= 1 << pNum;
MutedClients |= (uint64_t)1u << pNum;
}
CCMD(muteall)
@ -3209,7 +2959,7 @@ CCMD(muteall)
for (auto client : NetworkClients)
{
if (client != consoleplayer)
MutedClients |= 1 << client;
MutedClients |= (uint64_t)1u << client;
}
}
@ -3224,7 +2974,7 @@ CCMD(listmuted)
bool found = false;
for (auto client : NetworkClients)
{
if (MutedClients & (1 << client))
if (MutedClients & ((uint64_t)1u << client))
{
found = true;
Printf("%s - %d\n", players[client].userinfo.GetName(), client);
@ -3262,7 +3012,7 @@ CCMD(unmute)
return;
}
MutedClients &= ~(1 << pNum);
MutedClients &= ~((uint64_t)1u << pNum);
}
CCMD(unmuteall)
@ -3273,7 +3023,7 @@ CCMD(unmuteall)
return;
}
MutedClients = 0;
MutedClients = 0u;
}
//==========================================================================

99
src/d_net.h
View file

@ -36,34 +36,62 @@
uint64_t I_msTime();
enum EChatType
{
CHAT_DISABLED,
CHAT_TEAM_ONLY,
CHAT_GLOBAL,
};
enum EClientFlags
{
CF_NONE = 0,
CF_QUIT = 1, // If in packet server mode, this client sent an exit command and needs to be disconnected.
CF_MISSING_SEQ = 1 << 1, // If a sequence was missed/out of order, ask this client to send back over their info.
CF_RETRANSMIT_SEQ = 1 << 2, // If set, this client needs command data resent to them.
CF_MISSING_CON = 1 << 3, // If a consistency was missed/out of order, ask this client to send back over their info.
CF_RETRANSMIT_CON = 1 << 4, // If set, this client needs consistency data resent to them.
CF_UPDATED = 1 << 5, // Got an updated packet from this client.
CF_RETRANSMIT = CF_RETRANSMIT_CON | CF_RETRANSMIT_SEQ,
CF_MISSING = CF_MISSING_CON | CF_MISSING_SEQ,
};
class FDynamicBuffer
{
public:
FDynamicBuffer();
~FDynamicBuffer();
void SetData(const uint8_t *data, int len);
uint8_t* GetData(int *len = nullptr);
void SetData(const uint8_t* data, int len);
uint8_t* GetData(int* len = nullptr);
private:
uint8_t* m_Data;
int m_Len, m_BufferLen;
};
enum EClientFlags
{
CF_NONE = 0,
CF_QUIT = 1, // If in packet server mode, this client sent an exit command and needs to be disconnected.
CF_MISSING_SEQ = 1 << 1, // If a sequence was missed/out of order, ask this client to send back over their info.
CF_RETRANSMIT_SEQ = 1 << 2, // If set, this client needs command data resent to them.
CF_MISSING_CON = 1 << 3, // If a consistency was missed/out of order, ask this client to send back over their info.
CF_RETRANSMIT_CON = 1 << 4, // If set, this client needs consistency data resent to them.
CF_UPDATED = 1 << 5, // Got an updated packet from this client.
CF_RETRANSMIT = CF_RETRANSMIT_CON | CF_RETRANSMIT_SEQ,
CF_MISSING = CF_MISSING_CON | CF_MISSING_SEQ,
};
// New packet structure:
//
// One byte for the net command flags.
// Four bytes for the last sequence we got from that client.
// Four bytes for the last consistency we got from that client.
// If NCMD_QUITTERS set, one byte for the number of players followed by one byte for each player's consolenum. Packet server mode only.
// One byte for the number of players.
// One byte for the number of tics.
// If > 0, four bytes for the base sequence being worked from.
// One byte for the number of world tics ran.
// If > 0, four bytes for the base consistency being worked from.
// If in packet server mode and from the host, one byte for how far ahead of the host we are.
// For each player:
// One byte for the player number.
// If in packet server mode and from the host, two bytes for the latency to the host.
// For each consistency:
// One byte for the delta from the base consistency.
// Two bytes for each consistency.
// For each tic:
// One byte for the delta from the base sequence.
// The remaining command and event data for that player.
struct FClientNetState
{
// Networked client data.
@ -98,41 +126,6 @@ struct FClientNetState
int16_t LocalConsistency[BACKUPTICS] = {}; // Local consistency of the client to check against.
};
enum ENetMode : uint8_t
{
NET_PeerToPeer,
NET_PacketServer
};
enum EChatType
{
CHAT_DISABLED,
CHAT_TEAM_ONLY,
CHAT_GLOBAL,
};
// New packet structure:
//
// One byte for the net command flags.
// Four bytes for the last sequence we got from that client.
// Four bytes for the last consistency we got from that client.
// If NCMD_QUITTERS set, one byte for the number of players followed by one byte for each player's consolenum. Packet server mode only.
// One byte for the number of players.
// One byte for the number of tics.
// If > 0, four bytes for the base sequence being worked from.
// One byte for the number of world tics ran.
// If > 0, four bytes for the base consistency being worked from.
// If in packet server mode and from the host, one byte for how far ahead of the host we are.
// For each player:
// One byte for the player number.
// If in packet server mode and from the host, two bytes for the latency to the host.
// For each consistency:
// One byte for the delta from the base consistency.
// Two bytes for each consistency.
// For each tic:
// One byte for the delta from the base sequence.
// The remaining command and event data for that player.
// Create any new ticcmds and broadcast to other players.
void NetUpdate(int tics);
@ -164,13 +157,9 @@ void Net_ClearBuffers();
// Netgame stuff (buffers and pointers, i.e. indices).
// This is the interface to the packet driver, a separate program
// in DOS, but just an abstraction here.
extern doomcom_t doomcom;
extern usercmd_t LocalCmds[LOCALCMDTICS];
extern int ClientTic;
extern FClientNetState ClientStates[MAXPLAYERS];
extern ENetMode NetMode;
class player_t;
class DObject;

2
src/d_protocol.cpp
View file

@ -446,7 +446,7 @@ int ReadUserCmdMessage(uint8_t*& stream, int player, int tic)
void RunPlayerCommands(int player, int tic)
{
// We don't have the full command yet, so don't run it.
if (gametic % doomcom.ticdup)
if (gametic % TicDup)
return;
int len;

4
src/doomdef.h
View file

@ -30,6 +30,7 @@
#include <stdio.h>
#include <string.h>
#include "i_net.h"
//
// Global parameters/defines.
@ -63,9 +64,6 @@ constexpr int TICRATE = 35;
// Global constants that were defines.
enum
{
// The maximum number of players, multiplayer/networking.
MAXPLAYERS = 16,
// Amount of damage done by a telefrag.
TELEFRAG_DAMAGE = 1000000
};

3
src/doomstat.cpp
View file

@ -39,9 +39,6 @@ int SaveVersion;
// Game speed
EGameSpeed GameSpeed = SPEED_Normal;
// [RH] Network arbitrator
int Net_Arbitrator = 0;
int NextSkill = -1;
int SinglePlayerClass[MAXPLAYERS];

2
src/doomstat.h
View file

@ -198,8 +198,6 @@ EXTERN_CVAR (Int, developer)
extern bool ToggleFullscreen;
extern int Net_Arbitrator;
EXTERN_CVAR (Bool, var_friction)

6
src/g_game.cpp
View file

@ -622,7 +622,7 @@ void G_BuildTiccmd (usercmd_t *cmd)
// and not the joystick, since we treat the joystick as
// the analog device it is.
if (buttonMap.ButtonDown(Button_Left) || buttonMap.ButtonDown(Button_Right))
turnheld += doomcom.ticdup;
turnheld += TicDup;
else
turnheld = 0;
@ -1232,7 +1232,7 @@ void G_Ticker ()
}
// get commands, check consistancy, and build new consistancy check
const int curTic = gametic / doomcom.ticdup;
const int curTic = gametic / TicDup;
//Added by MC: For some of that bot stuff. The main bot function.
primaryLevel->BotInfo.Main (primaryLevel);
@ -2545,7 +2545,7 @@ void G_WriteDemoTiccmd (usercmd_t *cmd, int player, int buf)
}
// [RH] Write any special "ticcmds" for this player to the demo
if ((specdata = ClientStates[player].Tics[buf % BACKUPTICS].Data.GetData (&speclen)) && !(gametic % doomcom.ticdup))
if ((specdata = ClientStates[player].Tics[buf % BACKUPTICS].Data.GetData (&speclen)) && !(gametic % TicDup))
{
memcpy (demo_p, specdata, speclen);
demo_p += speclen;

2
src/playsim/p_acs.cpp
View file

@ -540,6 +540,8 @@
extern int Net_Arbitrator;
FRandom pr_acs ("ACS");
// I imagine this much stack space is probably overkill, but it could

2
wadsrc/static/zscript/constants.zs
View file

@ -1,6 +1,6 @@
// for flag changer functions.
const FLAG_NO_CHANGE = -1;
const MAXPLAYERS = 16;
const MAXPLAYERS = 64;
enum EStateUseFlags
{