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

Netcode Overhaul

Browse source 
Rewrote netcode to be more stable and functional. Packet-server mode has been restrategized and will now be the default netmode when playing with 3+ non-LAN players. TryRunTics has been cleaned up with older tick control behavior removed to account for the rewritten renderer. The main thread is now more consistent when playing online to prevent potential slow downs and lock ups. Load barriers are better accounted for to prevent spikes on level transition. Improvements to chat and lobby systems including a force start game button. Added a suite of new host options such as kicking and controlling who can pause the game. Max players increased from 8 to 16 since the new code can now handle it.

Note: Demo functionality is untested. This will be rewritten at a later time alongside improvements to GZDoom's playback features (e.g. freecam mode).
This commit is contained in:
Boondorl 2024-11-24 18:26:06 -05:00 committed by Rachael Alexanderson
parent abfd91e8f1
commit 94be307225
45 changed files with 3328 additions and 2878 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/common/console/c_dispatch.cpp
View file

@ -190,6 +190,22 @@ static const char *KeyConfCommands[] =
// CODE --------------------------------------------------------------------
bool C_IsValidInt(const char* arg, int& value, int base)
{
char* end_read;
value = std::strtol(arg, &end_read, base);
ptrdiff_t chars_read = end_read - arg;
return chars_read == strlen(arg);
}
bool C_IsValidFloat(const char* arg, double& value)
{
char* end_read;
value = std::strtod(arg, &end_read);
ptrdiff_t chars_read = end_read - arg;
return chars_read == strlen(arg);
}
void C_DoCommand (const char *cmd, int keynum)
{
FConsoleCommand *com;

2
src/common/console/c_dispatch.h
View file

@ -74,6 +74,8 @@ void C_ClearDelayedCommands();
// Process a single console command. Does not handle wait.
void C_DoCommand (const char *cmd, int keynum=0);
bool C_IsValidInt(const char* arg, int& value, int base = 10);
bool C_IsValidFloat(const char* arg, double& value);
FExecList *C_ParseExecFile(const char *file, FExecList *source);
void C_SearchForPullins(FExecList *exec, const char *file, class FCommandLine &args);

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

@ -75,6 +75,7 @@
#include "cmdlib.h"
#include "printf.h"
#include "i_interface.h"
#include "c_cvars.h"
#include "i_net.h"
@ -104,18 +105,31 @@ typedef int SOCKET;
typedef int socklen_t;
#endif
constexpr int MaxPlayers = 16; // TODO: This needs to be put in some kind of unified header later
constexpr size_t MaxPasswordSize = 256u;
bool netgame, multiplayer;
int consoleplayer; // i.e. myconnectindex in Build.
doomcom_t doomcom;
CUSTOM_CVAR(String, net_password, "", CVAR_IGNORE)
{
if (strlen(self) + 1 > MaxPasswordSize)
{
self = "";
Printf(TEXTCOLOR_RED "Password cannot be greater than 255 characters\n");
}
}
FClientStack NetworkClients;
//
// NETWORKING
//
static u_short DOOMPORT = (IPPORT_USERRESERVED + 29);
static SOCKET mysocket = INVALID_SOCKET;
static sockaddr_in sendaddress[MAXNETNODES];
static uint8_t sendplayer[MAXNETNODES];
static sockaddr_in sendaddress[MaxPlayers];
#ifdef __WIN32__
const char *neterror (void);
@ -134,12 +148,20 @@ enum
PRE_ALLHEREACK, // Sent from guest to host to acknowledge PRE_ALLHEREACK receipt
PRE_GO, // Sent from host to guest to continue game startup
PRE_IN_PROGRESS, // Sent from host to guest if the game has already started
PRE_WRONG_PASSWORD, // Sent from host to guest if their provided password was wrong
};
// Set PreGamePacket.fake to this so that the game rejects any pregame packets
// after it starts. This translates to NCMD_SETUP|NCMD_MULTI.
#define PRE_FAKE 0x30
struct PreGameConnectPacket
{
uint8_t Fake;
uint8_t Message;
char Password[MaxPasswordSize];
};
struct PreGamePacket
{
uint8_t Fake;
@ -154,17 +176,16 @@ struct PreGamePacket
{
uint32_t address;
uint16_t port;
uint8_t player;
uint8_t pad;
} machines[MAXNETNODES];
uint16_t pad;
} machines[MaxPlayers];
};
uint8_t TransmitBuffer[TRANSMIT_SIZE];
FString GetPlayerName(int num)
{
if (sysCallbacks.GetPlayerName) return sysCallbacks.GetPlayerName(sendplayer[num]);
else return FStringf("Player %d", sendplayer[num] + 1);
if (sysCallbacks.GetPlayerName) return sysCallbacks.GetPlayerName(num);
else return FStringf("Player %d", num + 1);
}
//
@ -200,22 +221,34 @@ void BindToLocalPort (SOCKET s, u_short port)
I_FatalError ("BindToPort: %s", neterror ());
}
void I_ClearNode(int node)
{
memset(&sendaddress[node], 0, sizeof(sendaddress[node]));
}
static bool I_ShouldStartNetGame()
{
if (doomcom.consoleplayer != 0)
return false;
return StartWindow->ShouldStartNet();
}
int FindNode (const sockaddr_in *address)
{
int i;
int i = 0;
// find remote node number
for (i = 0; i<doomcom.numnodes; i++)
for (; i < doomcom.numplayers; ++i)
{
if (address->sin_addr.s_addr == sendaddress[i].sin_addr.s_addr
&& address->sin_port == sendaddress[i].sin_port)
{
break;
if (i == doomcom.numnodes)
{
// packet is not from one of the players (new game broadcast?)
i = -1;
}
}
return i;
return (i == doomcom.numplayers) ? -1 : i;
}
//
@ -249,8 +282,8 @@ void PacketSend (void)
{
// Printf("send %lu/%d\n", size, doomcom.datalength);
c = sendto(mysocket, (char *)TransmitBuffer, size,
0, (sockaddr *)&sendaddress[doomcom.remotenode],
sizeof(sendaddress[doomcom.remotenode]));
0, (sockaddr *)&sendaddress[doomcom.remoteplayer],
sizeof(sendaddress[doomcom.remoteplayer]));
}
else
{
@ -262,8 +295,8 @@ void PacketSend (void)
{
// Printf("send %d\n", doomcom.datalength);
c = sendto(mysocket, (char *)doomcom.data, doomcom.datalength,
0, (sockaddr *)&sendaddress[doomcom.remotenode],
sizeof(sendaddress[doomcom.remotenode]));
0, (sockaddr *)&sendaddress[doomcom.remoteplayer],
sizeof(sendaddress[doomcom.remoteplayer]));
}
}
// if (c == -1)
@ -315,7 +348,7 @@ void PacketGet (void)
}
else
{
doomcom.remotenode = -1; // no packet
doomcom.remoteplayer = -1; // no packet
return;
}
}
@ -331,7 +364,7 @@ void PacketGet (void)
{
Printf("Net decompression failed (zlib error %s)\n", M_ZLibError(err).GetChars());
// Pretend no packet
doomcom.remotenode = -1;
doomcom.remoteplayer = -1;
return;
}
c = msgsize + 1;
@ -350,11 +383,11 @@ void PacketGet (void)
uint8_t msg[] = { PRE_FAKE, PRE_IN_PROGRESS };
PreSend(msg, 2, &fromaddress);
}
doomcom.remotenode = -1;
doomcom.remoteplayer = -1;
return;
}
doomcom.remotenode = node;
doomcom.remoteplayer = node;
doomcom.datalength = (short)c;
}
@ -373,22 +406,6 @@ sockaddr_in *PreGet (void *buffer, int bufferlen, bool noabort)
int err = WSAGetLastError();
if (err == WSAEWOULDBLOCK || (noabort && err == WSAECONNRESET))
return NULL; // no packet
if (doomcom.consoleplayer == 0)
{
int node = FindNode(&fromaddress);
I_NetMessage("Got unexpected disconnect.");
doomcom.numnodes--;
for (; node < doomcom.numnodes; ++node)
sendaddress[node] = sendaddress[node + 1];
// Let remaining guests know that somebody left.
SendConAck(doomcom.numnodes, doomcom.numplayers);
}
else
{
I_NetError("The host disbanded the game unexpectedly");
}
}
return &fromaddress;
}
@ -439,7 +456,7 @@ void BuildAddress (sockaddr_in *address, const char *name)
if (!isnamed)
{
address->sin_addr.s_addr = inet_addr (target.GetChars());
Printf ("Node number %d, address %s\n", doomcom.numnodes, target.GetChars());
Printf ("Node number %d, address %s\n", doomcom.numplayers, target.GetChars());
}
else
{
@ -448,7 +465,7 @@ void BuildAddress (sockaddr_in *address, const char *name)
I_FatalError ("gethostbyname: couldn't find %s\n%s", target.GetChars(), neterror());
address->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
Printf ("Node number %d, hostname %s\n",
doomcom.numnodes, hostentry->h_name);
doomcom.numplayers, hostentry->h_name);
}
}
@ -489,17 +506,17 @@ void StartNetwork (bool autoPort)
#endif
}
void SendAbort (void)
void SendAbort (int connected)
{
uint8_t dis[2] = { PRE_FAKE, PRE_DISCONNECT };
int i, j;
if (doomcom.numnodes > 1)
if (connected > 1)
{
if (consoleplayer == 0)
if (doomcom.consoleplayer == 0)
{
// The host needs to let everyone know
for (i = 1; i < doomcom.numnodes; ++i)
for (i = 1; i < connected; ++i)
{
for (j = 4; j > 0; --j)
{
@ -512,7 +529,7 @@ void SendAbort (void)
// Guests only need to let the host know.
for (i = 4; i > 0; --i)
{
PreSend (dis, 2, &sendaddress[1]);
PreSend (dis, 2, &sendaddress[0]);
}
}
}
@ -526,17 +543,17 @@ void SendConAck (int num_connected, int num_needed)
packet.Message = PRE_CONACK;
packet.NumNodes = num_needed;
packet.NumPresent = num_connected;
for (int node = 1; node < doomcom.numnodes; ++node)
for (int node = 1; node < num_connected; ++node)
{
PreSend (&packet, 4, &sendaddress[node]);
}
I_NetProgress (doomcom.numnodes);
I_NetProgress (num_connected);
}
bool Host_CheckForConnects (void *userdata)
{
PreGamePacket packet;
int numplayers = (int)(intptr_t)userdata;
PreGameConnectPacket packet;
int* connectedPlayers = (int*)userdata;
sockaddr_in *from;
int node;
@ -550,7 +567,7 @@ bool Host_CheckForConnects (void *userdata)
{
case PRE_CONNECT:
node = FindNode (from);
if (doomcom.numnodes == numplayers)
if (doomcom.numplayers == *connectedPlayers)
{
if (node == -1)
{
@ -566,13 +583,21 @@ bool Host_CheckForConnects (void *userdata)
{
if (node == -1)
{
node = doomcom.numnodes++;
if (strlen(net_password) > 0 && strcmp(net_password, packet.Password))
{
packet.Message = PRE_WRONG_PASSWORD;
PreSend(&packet, 2, from);
break;
}
node = *connectedPlayers;
++*connectedPlayers;
sendaddress[node] = *from;
I_NetMessage ("Got connect from node %d.", node);
}
// Let the new guest (and everyone else) know we got their message.
SendConAck (doomcom.numnodes, numplayers);
SendConAck (*connectedPlayers, doomcom.numplayers);
}
break;
@ -580,27 +605,25 @@ bool Host_CheckForConnects (void *userdata)
node = FindNode (from);
if (node >= 0)
{
I_ClearNode(node);
I_NetMessage ("Got disconnect from node %d.", node);
doomcom.numnodes--;
while (node < doomcom.numnodes)
--*connectedPlayers;
while (node < *connectedPlayers)
{
sendaddress[node] = sendaddress[node+1];
node++;
++node;
}
// Let remaining guests know that somebody left.
SendConAck (doomcom.numnodes, numplayers);
SendConAck (*connectedPlayers, doomcom.numplayers);
}
break;
case PRE_KEEPALIVE:
break;
}
}
if (doomcom.numnodes < numplayers)
if (*connectedPlayers < doomcom.numplayers && !I_ShouldStartNetGame())
{
// Send message to everyone as a keepalive
SendConAck(doomcom.numnodes, numplayers);
SendConAck(*connectedPlayers, doomcom.numplayers);
return false;
}
@ -614,53 +637,53 @@ bool Host_CheckForConnects (void *userdata)
node = FindNode (from);
if (node >= 0)
{
doomcom.numnodes--;
while (node < doomcom.numnodes)
I_ClearNode(node);
--*connectedPlayers;
while (node < *connectedPlayers)
{
sendaddress[node] = sendaddress[node+1];
node++;
++node;
}
// Let remaining guests know that somebody left.
SendConAck (doomcom.numnodes, numplayers);
SendConAck (*connectedPlayers, doomcom.numplayers);
}
break;
}
}
return doomcom.numnodes >= numplayers;
// TODO: This will need a much better solution later.
if (I_ShouldStartNetGame())
doomcom.numplayers = *connectedPlayers;
return *connectedPlayers >= doomcom.numplayers;
}
bool Host_SendAllHere (void *userdata)
{
int *gotack = (int *)userdata; // ackcount is at gotack[MAXNETNODES]
int* gotack = (int*)userdata;
const int mask = (1 << doomcom.numplayers) - 1;
PreGamePacket packet;
int node;
sockaddr_in *from;
// Send out address information to all guests. Guests that have already
// acknowledged receipt effectively get just a heartbeat packet.
// Send out address information to all guests. This is will be the final order
// of the send addresses so each guest will need to rearrange their own in order
// to keep node -> player numbers synchronized.
packet.Fake = PRE_FAKE;
packet.Message = PRE_ALLHERE;
for (node = 1; node < doomcom.numnodes; node++)
for (node = 1; node < doomcom.numplayers; node++)
{
int machine, spot = 0;
packet.ConsoleNum = node;
if (!gotack[node])
if (!((*gotack) & (1 << node)))
{
for (spot = 0, machine = 1; machine < doomcom.numnodes; machine++)
for (spot = 0; spot < doomcom.numplayers; spot++)
{
if (node != machine)
{
packet.machines[spot].address = sendaddress[machine].sin_addr.s_addr;
packet.machines[spot].port = sendaddress[machine].sin_port;
packet.machines[spot].player = node;
spot++; // fixes problem of new address replacing existing address in
// array; it's supposed to increment the index before getting
// and storing in the packet the next address.
}
packet.machines[spot].address = sendaddress[spot].sin_addr.s_addr;
packet.machines[spot].port = sendaddress[spot].sin_port;
}
packet.NumNodes = doomcom.numnodes - 2;
packet.NumNodes = doomcom.numplayers;
}
else
{
@ -672,23 +695,36 @@ bool Host_SendAllHere (void *userdata)
// Check for replies.
while ( (from = PreGet (&packet, sizeof(packet), false)) )
{
if (packet.Fake == PRE_FAKE && packet.Message == PRE_ALLHEREACK)
if (packet.Fake != PRE_FAKE)
continue;
if (packet.Message == PRE_ALLHEREACK)
{
node = FindNode (from);
if (node >= 0)
*gotack |= 1 << node;
}
else if (packet.Message == PRE_CONNECT)
{
// If someone is still trying to connect, let them know it's either too
// late or that they need to move on to the next stage.
node = FindNode(from);
if (node == -1)
{
if (!gotack[node])
{
gotack[node] = true;
gotack[MAXNETNODES]++;
}
packet.Message = PRE_ALLFULL;
PreSend(&packet, 2, from);
}
else
{
packet.Message = PRE_CONACK;
packet.NumNodes = packet.NumPresent = doomcom.numplayers;
PreSend(&packet, 4, from);
}
PreSend (&packet, 2, from);
}
}
// If everybody has replied, then this loop can end.
return gotack[MAXNETNODES] == doomcom.numnodes - 1;
return ((*gotack) & mask) == mask;
}
bool HostGame (int i)
@ -696,24 +732,24 @@ bool HostGame (int i)
PreGamePacket packet;
int numplayers;
int node;
int gotack[MAXNETNODES+1];
if ((i == Args->NumArgs() - 1) || !(numplayers = atoi (Args->GetArg(i+1))))
{ // No player count specified, assume 2
numplayers = 2;
}
if (numplayers > MAXNETNODES)
if (numplayers > MaxPlayers)
{
I_FatalError("You cannot host a game with %d players. The limit is currently %d.", numplayers, MAXNETNODES);
I_FatalError("You cannot host a game with %d players. The limit is currently %d.", numplayers, MaxPlayers);
}
if (numplayers == 1)
{ // Special case: Only 1 player, so don't bother starting the network
NetworkClients += 0;
netgame = false;
multiplayer = true;
doomcom.id = DOOMCOM_ID;
doomcom.numplayers = doomcom.numnodes = 1;
doomcom.numplayers = 1;
doomcom.consoleplayer = 0;
return true;
}
@ -723,27 +759,41 @@ bool HostGame (int i)
// [JC] - this computer is starting the game, therefore it should
// be the Net Arbitrator.
doomcom.consoleplayer = 0;
Printf ("Console player number: %d\n", doomcom.consoleplayer);
doomcom.numnodes = 1;
doomcom.numplayers = numplayers;
I_NetInit ("Hosting game", numplayers);
// Wait for numplayers-1 different connections
if (!I_NetLoop (Host_CheckForConnects, (void *)(intptr_t)numplayers))
// Wait for the lobby to be full.
int connectedPlayers = 1;
if (!I_NetLoop (Host_CheckForConnects, (void *)&connectedPlayers))
{
SendAbort();
SendAbort(connectedPlayers);
throw CExitEvent(0);
return false;
}
// If the player force started with only themselves in the lobby, start the game
// immediately.
if (doomcom.numplayers <= 1)
{
NetworkClients += 0;
netgame = false;
multiplayer = true;
doomcom.id = DOOMCOM_ID;
doomcom.numplayers = 1;
I_NetDone();
return true;
}
// Now inform everyone of all machines involved in the game
memset (gotack, 0, sizeof(gotack));
int gotack = 1;
I_NetMessage ("Sending all here.");
I_NetInit ("Done waiting", 1);
if (!I_NetLoop (Host_SendAllHere, (void *)gotack))
if (!I_NetLoop (Host_SendAllHere, (void *)&gotack))
{
SendAbort();
SendAbort(doomcom.numplayers);
throw CExitEvent(0);
return false;
}
@ -751,7 +801,7 @@ bool HostGame (int i)
I_NetMessage ("Go");
packet.Fake = PRE_FAKE;
packet.Message = PRE_GO;
for (node = 1; node < doomcom.numnodes; node++)
for (node = 1; node < doomcom.numplayers; node++)
{
// If we send the packets eight times to each guest,
// hopefully at least one of them will get through.
@ -761,16 +811,10 @@ bool HostGame (int i)
}
}
I_NetMessage ("Total players: %d", doomcom.numnodes);
I_NetMessage ("Total players: %d", doomcom.numplayers);
doomcom.id = DOOMCOM_ID;
doomcom.numplayers = doomcom.numnodes;
// On the host, each player's number is the same as its node number
for (i = 0; i < doomcom.numnodes; ++i)
{
sendplayer[i] = i;
}
return true;
}
@ -782,16 +826,18 @@ bool Guest_ContactHost (void *userdata)
{
sockaddr_in *from;
PreGamePacket packet;
PreGameConnectPacket sendPacket;
// Let the host know we are here.
packet.Fake = PRE_FAKE;
packet.Message = PRE_CONNECT;
PreSend (&packet, 2, &sendaddress[1]);
sendPacket.Fake = PRE_FAKE;
sendPacket.Message = PRE_CONNECT;
memcpy(sendPacket.Password, net_password, strlen(net_password) + 1);
PreSend (&sendPacket, sizeof(sendPacket), &sendaddress[0]);
// Listen for a reply.
while ( (from = PreGet (&packet, sizeof(packet), true)) )
{
if (packet.Fake == PRE_FAKE && FindNode(from) == 1)
if (packet.Fake == PRE_FAKE && !FindNode(from))
{
if (packet.Message == PRE_CONACK)
{
@ -812,6 +858,10 @@ bool Guest_ContactHost (void *userdata)
{
I_NetError("The game was already started.");
}
else if (packet.Message == PRE_WRONG_PASSWORD)
{
I_NetError("Invalid password.");
}
}
}
@ -828,7 +878,7 @@ bool Guest_WaitForOthers (void *userdata)
while ( (from = PreGet (&packet, sizeof(packet), false)) )
{
if (packet.Fake != PRE_FAKE || FindNode(from) != 1)
if (packet.Fake != PRE_FAKE || FindNode(from))
{
continue;
}
@ -839,31 +889,35 @@ bool Guest_WaitForOthers (void *userdata)
break;
case PRE_ALLHERE:
if (doomcom.numnodes == 2)
if (doomcom.consoleplayer == -1)
{
int node;
doomcom.numnodes = packet.NumNodes + 2;
sendplayer[0] = packet.ConsoleNum; // My player number
doomcom.numplayers = packet.NumNodes;
doomcom.consoleplayer = packet.ConsoleNum;
// Don't use the address sent from the host for our own machine.
sendaddress[doomcom.consoleplayer] = sendaddress[1];
I_NetMessage ("Console player number: %d", doomcom.consoleplayer);
for (node = 0; node < packet.NumNodes; node++)
for (int node = 1; node < doomcom.numplayers; ++node)
{
sendaddress[node+2].sin_addr.s_addr = packet.machines[node].address;
sendaddress[node+2].sin_port = packet.machines[node].port;
sendplayer[node+2] = packet.machines[node].player;
if (node == doomcom.consoleplayer)
continue;
sendaddress[node].sin_addr.s_addr = packet.machines[node].address;
sendaddress[node].sin_port = packet.machines[node].port;
// [JC] - fixes problem of games not starting due to
// no address family being assigned to nodes stored in
// sendaddress[] from the All Here packet.
sendaddress[node+2].sin_family = AF_INET;
sendaddress[node].sin_family = AF_INET;
}
I_NetMessage("Received All Here, sending ACK.");
}
I_NetMessage ("Received All Here, sending ACK.");
packet.Fake = PRE_FAKE;
packet.Message = PRE_ALLHEREACK;
PreSend (&packet, 2, &sendaddress[1]);
PreSend (&packet, 2, &sendaddress[0]);
break;
case PRE_GO:
@ -876,10 +930,6 @@ bool Guest_WaitForOthers (void *userdata)
}
}
packet.Fake = PRE_FAKE;
packet.Message = PRE_KEEPALIVE;
PreSend(&packet, 2, &sendaddress[1]);
return false;
}
@ -892,33 +942,32 @@ bool JoinGame (int i)
StartNetwork (true);
// Host is always node 1
BuildAddress (&sendaddress[1], Args->GetArg(i+1));
sendplayer[1] = 0;
doomcom.numnodes = 2;
// Host is always node 0
BuildAddress (&sendaddress[0], Args->GetArg(i+1));
doomcom.numplayers = 2;
doomcom.consoleplayer = -1;
// Let host know we are here
I_NetInit ("Contacting host", 0);
if (!I_NetLoop (Guest_ContactHost, NULL))
if (!I_NetLoop (Guest_ContactHost, nullptr))
{
SendAbort();
SendAbort(2);
throw CExitEvent(0);
return false;
}
// Wait for everyone else to connect
if (!I_NetLoop (Guest_WaitForOthers, 0))
if (!I_NetLoop (Guest_WaitForOthers, nullptr))
{
SendAbort();
SendAbort(2);
throw CExitEvent(0);
return false;
}
I_NetMessage ("Total players: %d", doomcom.numnodes);
I_NetMessage ("Total players: %d", doomcom.numplayers);
doomcom.id = DOOMCOM_ID;
doomcom.numplayers = doomcom.numnodes;
return true;
}
@ -954,19 +1003,20 @@ static int PrivateNetOf(in_addr in)
static bool NodesOnSameNetwork()
{
int net1;
if (doomcom.consoleplayer != 0)
return false;
net1 = PrivateNetOf(sendaddress[1].sin_addr);
const int firstClient = PrivateNetOf(sendaddress[1].sin_addr);
// Printf("net1 = %08x\n", net1);
if (net1 == 0)
if (firstClient == 0)
{
return false;
}
for (int i = 2; i < doomcom.numnodes; ++i)
for (int i = 2; i < doomcom.numplayers; ++i)
{
int net = PrivateNetOf(sendaddress[i].sin_addr);
const int net = PrivateNetOf(sendaddress[i].sin_addr);
// Printf("Net[%d] = %08x\n", i, net);
if (net != net1)
if (net != firstClient)
{
return false;
}
@ -1004,6 +1054,8 @@ int I_InitNetwork (void)
Printf ("using alternate port %i\n", DOOMPORT);
}
net_password = Args->CheckValue("-password");
// parse network game options,
// player 1: -host <numplayers>
// player x: -join <player 1's address>
@ -1018,19 +1070,22 @@ int I_InitNetwork (void)
else
{
// single player game
NetworkClients += 0;
netgame = false;
multiplayer = false;
doomcom.id = DOOMCOM_ID;
doomcom.numplayers = doomcom.numnodes = 1;
doomcom.ticdup = 1;
doomcom.numplayers = 1;
doomcom.consoleplayer = 0;
return false;
}
if (doomcom.numnodes < 3)
if (doomcom.numplayers < 3)
{ // Packet server mode with only two players is effectively the same as
// peer-to-peer but with some slightly larger packets.
return false;
}
return doomcom.numnodes > 3 || !NodesOnSameNetwork();
return !NodesOnSameNetwork();
}
@ -1070,7 +1125,7 @@ void I_NetMessage(const char* text, ...)
void I_NetError(const char* error)
{
doomcom.numnodes = 0;
doomcom.numplayers = 0;
StartWindow->NetClose();
I_FatalError("%s", error);
}

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

@ -5,6 +5,7 @@
// 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);
@ -15,74 +16,70 @@ void I_NetDone();
enum ENetConstants
{
MAXNETNODES = 8, // max computers in a game
DOOMCOM_ID = 0x12345678,
BACKUPTICS = 36, // number of tics to remember
MAXTICDUP = 5,
LOCALCMDTICS =(BACKUPTICS*MAXTICDUP),
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),
MAX_MSGLEN = 14000,
CMD_SEND = 1,
CMD_GET = 2,
};
// [RH]
// New generic packet structure:
//
// Header:
// One byte with following flags.
// One byte with starttic
// One byte with master's maketic (master -> slave only!)
// If NCMD_RETRANSMIT set, one byte with retransmitfrom
// If NCMD_XTICS set, one byte with number of tics (minus 3, so theoretically up to 258 tics in one packet)
// If NCMD_QUITTERS, one byte with number of players followed by one byte with each player's consolenum
// If NCMD_MULTI, one byte with number of players followed by one byte with each player's consolenum
// - The first player's consolenum is not included in this list, because it always matches the sender
//
// For each tic:
// Two bytes with consistancy check, followed by tic data
//
// Setup packets are different, and are described just before D_ArbitrateNetStart().
enum ENCMD
{
NCMD_EXIT = 0x80,
NCMD_RETRANSMIT = 0x40,
NCMD_SETUP = 0x20,
NCMD_MULTI = 0x10, // multiple players in this packet
NCMD_QUITTERS = 0x08, // one or more players just quit (packet server only)
NCMD_COMPRESSED = 0x04, // remainder of packet is compressed
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.
NCMD_XTICS = 0x03, // packet contains >2 tics
NCMD_2TICS = 0x02, // packet contains 2 tics
NCMD_1TICS = 0x01, // packet contains 1 tic
NCMD_0TICS = 0x00, // packet contains 0 tics
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
};
struct FClientStack : public TArray<int>
{
inline bool InGame(int i) const { return Find(i) < Size(); }
void operator+=(const int i)
{
if (!InGame(i))
SortedInsert(i);
}
void operator-=(const int i)
{
Delete(Find(i));
}
};
extern FClientStack NetworkClients;
//
// Network packet data.
//
struct doomcom_t
{
uint32_t id; // should be DOOMCOM_ID
int16_t intnum; // DOOM executes an int to execute commands
// communication between DOOM and the driver
int16_t command; // CMD_SEND or CMD_GET
int16_t remotenode; // dest for send, set by get (-1 = no packet).
int16_t datalength; // bytes in data to be sent
// info common to all nodes
int16_t numnodes; // console is always node 0.
int16_t ticdup; // 1 = no duplication, 2-5 = dup for slow nets
// info specific to this node
int16_t consoleplayer;
// 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;
// packet data to be sent
uint8_t data[MAX_MSGLEN];
// 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;

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

@ -56,6 +56,7 @@ public:
virtual void NetProgress(int count) {}
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) {}
@ -76,6 +77,7 @@ public:
void NetMessage(const char* format, ...); // cover for printf
void NetDone();
void NetClose();
bool ShouldStartNet() override;
bool NetLoop(bool (*timer_callback)(void*), void* userdata);
protected:
int NetMaxPos, NetCurPos;

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

@ -67,6 +67,7 @@ public:
void NetProgress(int count);
void NetDone();
void NetClose();
bool ShouldStartNet();
private:
NSWindow* m_window;

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

@ -536,3 +536,8 @@ void FConsoleWindow::NetClose()
{
// TODO: Implement this
}
bool FConsoleWindow::ShouldStartNet()
{
return false;
}

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

@ -115,6 +115,11 @@ void FBasicStartupScreen::NetClose()
FConsoleWindow::GetInstance().NetClose();
}
bool FBasicStartupScreen::ShouldStartNet()
{
return FConsoleWindow::GetInstance().ShouldStartNet();
}
bool FBasicStartupScreen::NetLoop(bool (*timerCallback)(void*), void* const userData)
{
while (true)

1
src/common/platform/posix/i_system.h
View file

@ -13,7 +13,6 @@
#include "tarray.h"
#include "zstring.h"
struct ticcmd_t;
struct WadStuff;
#ifndef SHARE_DIR

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

@ -58,6 +58,7 @@ class FTTYStartupScreen : public FStartupScreen
void NetProgress(int count);
void NetDone();
void NetClose();
bool ShouldStartNet();
bool NetLoop(bool (*timer_callback)(void *), void *userdata);
protected:
bool DidNetInit;
@ -243,6 +244,11 @@ void FTTYStartupScreen::NetClose()
// TODO: Implement this
}
bool FTTYStartupScreen::ShouldStartNet()
{
return false;
}
//===========================================================================
//
// FTTYStartupScreen :: NetLoop

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

@ -133,6 +133,11 @@ void MainWindow::CloseNetStartPane()
NetStartWindow::NetClose();
}
bool MainWindow::ShouldStartNetGame()
{
return NetStartWindow::ShouldStartNetGame();
}
void MainWindow::SetNetStartProgress(int pos)
{
NetStartWindow::SetNetStartProgress(pos);

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

@ -30,6 +30,7 @@ public:
bool RunMessageLoop(bool (*timer_callback)(void*), void* userdata);
void HideNetStartPane();
void CloseNetStartPane();
bool ShouldStartNetGame();
void SetWindowTitle(const char* caption);

1
src/common/platform/win32/i_system.h
View file

@ -8,7 +8,6 @@
#include "zstring.h"
#include "utf8.h"
struct ticcmd_t;
struct WadStuff;
// [RH] Detects the OS the game is running under.

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

@ -206,3 +206,8 @@ void FBasicStartupScreen::NetClose()
{
mainwindow.CloseNetStartPane();
}
bool FBasicStartupScreen::ShouldStartNet()
{
return mainwindow.ShouldStartNetGame();
}

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

@ -54,13 +54,6 @@ bool NetStartWindow::RunMessageLoop(bool (*newtimer_callback)(void*), void* newu
if (Instance->CallbackException)
std::rethrow_exception(Instance->CallbackException);
// Even though the comment in FBasicStartupScreen::NetLoop says we should return false, the old code actually throws an exception!
// This effectively also means the function always returns true...
if (!Instance->exitreason)
{
throw CExitEvent(0);
}
return Instance->exitreason;
}
@ -70,6 +63,14 @@ void NetStartWindow::NetClose()
Instance->OnClose();
}
bool NetStartWindow::ShouldStartNetGame()
{
if (Instance != nullptr)
return Instance->shouldstart;
return false;
}
NetStartWindow::NetStartWindow() : Widget(nullptr, WidgetType::Window)
{
SetWindowBackground(Colorf::fromRgba8(51, 51, 51));
@ -81,13 +82,16 @@ NetStartWindow::NetStartWindow() : Widget(nullptr, WidgetType::Window)
MessageLabel = new TextLabel(this);
ProgressLabel = new TextLabel(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 Network Game");
AbortButton->SetText("Abort");
ForceStartButton->SetText("Start Game");
CallbackTimer = new Timer(this);
CallbackTimer->FuncExpired = [=]() { OnCallbackTimerExpired(); };
@ -117,6 +121,11 @@ void NetStartWindow::OnClose()
DisplayWindow::ExitLoop();
}
void NetStartWindow::ForceStart()
{
shouldstart = true;
}
void NetStartWindow::OnGeometryChanged()
{
double w = GetWidth();
@ -132,7 +141,8 @@ void NetStartWindow::OnGeometryChanged()
y += labelheight;
y = GetHeight() - 15.0 - AbortButton->GetPreferredHeight();
AbortButton->SetFrameGeometry((w - 200.0) * 0.5, y, 200.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());
}
void NetStartWindow::OnCallbackTimerExpired()

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

@ -15,6 +15,7 @@ public:
static void SetNetStartProgress(int pos);
static bool RunMessageLoop(bool (*timer_callback)(void*), void* userdata);
static void NetClose();
static bool ShouldStartNetGame();
private:
NetStartWindow();
@ -25,6 +26,7 @@ private:
protected:
void OnClose() override;
void OnGeometryChanged() override;
virtual void ForceStart();
private:
void OnCallbackTimerExpired();
@ -32,6 +34,7 @@ private:
TextLabel* MessageLabel = nullptr;
TextLabel* ProgressLabel = nullptr;
PushButton* AbortButton = nullptr;
PushButton* ForceStartButton = nullptr;
Timer* CallbackTimer = nullptr;
@ -41,6 +44,7 @@ private:
void* userdata = nullptr;
bool exitreason = false;
bool shouldstart = false;
std::exception_ptr CallbackException;

159
src/ct_chat.cpp
View file

@ -55,6 +55,7 @@ enum
EXTERN_CVAR (Bool, sb_cooperative_enable)
EXTERN_CVAR (Bool, sb_deathmatch_enable)
EXTERN_CVAR (Bool, sb_teamdeathmatch_enable)
EXTERN_CVAR (Int, cl_showchat)
int active_con_scaletext();
@ -73,8 +74,16 @@ static void CT_BackSpace ();
static void ShoveChatStr (const char *str, uint8_t who);
static bool DoSubstitution (FString &out, const char *in);
static TArray<uint8_t> ChatQueue;
constexpr int MessageLimit = 2; // Clamp the amount of messages you can send in a brief period
constexpr uint64_t MessageThrottleTime = 1000u; // Time in ms that spam messages will be tracked.
constexpr uint64_t SpamCoolDown = 3000u;
static TArray<uint8_t> ChatQueue;
static uint64_t ChatThrottle = 0u;
static int ChatSpamCount = 0;
static uint64_t ChatCoolDown = 0u; // Spam limiter
CVAR (Int, net_chatslowmode, 0, CVAR_SERVERINFO | CVAR_NOSAVE)
CVAR (String, chatmacro1, "I'm ready to kick butt!", CVAR_ARCHIVE)
CVAR (String, chatmacro2, "I'm OK.", CVAR_ARCHIVE)
CVAR (String, chatmacro3, "I'm not looking too good!", CVAR_ARCHIVE)
@ -265,7 +274,7 @@ void CT_Drawer (void)
}
}
FStringf prompt("%s ", GStrings.GetString("TXT_SAY"));
FStringf prompt("%s ", chatmodeon == 2 && deathmatch && teamplay ? GStrings.GetString("TXT_SAYTEAM") : GStrings.GetString("TXT_SAY"));
int x, scalex, y, promptwidth;
y = (viewactive || gamestate != GS_LEVEL) ? -displayfont->GetHeight()-2 : -displayfont->GetHeight() - 22;
@ -365,6 +374,24 @@ static void ShoveChatStr (const char *str, uint8_t who)
if (str == NULL || str[0] == '\0')
return;
if (netgame)
{
const uint64_t time = I_msTime();
if (time >= ChatThrottle)
{
ChatSpamCount = 0;
}
else if (++ChatSpamCount >= MessageLimit)
{
ChatSpamCount = 0;
ChatCoolDown = time + SpamCoolDown;
}
ChatThrottle = time + MessageThrottleTime;
if (net_chatslowmode > 0)
ChatCoolDown = max<uint64_t>(time + net_chatslowmode * 1000, ChatCoolDown);
}
FString substBuff;
if (str[0] == '/' &&
@ -508,13 +535,40 @@ static bool DoSubstitution (FString &out, const char *in)
CCMD (messagemode)
{
if (menuactive == MENU_Off)
if (menuactive != MENU_Off)
return;
const uint64_t time = I_msTime();
if (ChatCoolDown > time)
{
buttonMap.ResetButtonStates();
chatmodeon = 1;
C_HideConsole ();
CT_ClearChatMessage ();
Printf("You must wait %d more seconds before being able to chat again\n", int((ChatCoolDown - time) * 0.001));
return;
}
if (multiplayer && deathmatch)
{
if (cl_showchat < CHAT_GLOBAL)
{
Printf("Global chat is currently disabled\n");
return;
}
chatmodeon = 1;
}
else
{
if (cl_showchat < CHAT_TEAM_ONLY)
{
Printf("Team chat is currently disabled\n");
return;
}
chatmodeon = 2;
}
buttonMap.ResetButtonStates();
C_HideConsole ();
CT_ClearChatMessage ();
}
CCMD (say)
@ -522,22 +576,75 @@ CCMD (say)
if (argv.argc() == 1)
{
Printf ("Usage: say <message>\n");
return;
}
const uint64_t time = I_msTime();
if (ChatCoolDown > time)
{
Printf("You must wait %d more seconds before being able to chat again\n", int((ChatCoolDown - time) * 0.001));
return;
}
// If not in a DM lobby, route it to team chat instead (helps improve chat
// filtering).
if (multiplayer && deathmatch)
{
if (cl_showchat < CHAT_GLOBAL)
{
Printf("Global chat is currently disabled\n");
}
else
{
ShoveChatStr(argv[1], 0);
}
}
else if (cl_showchat < CHAT_TEAM_ONLY)
{
Printf("Team chat is currently disabled\n");
}
else
{
ShoveChatStr (argv[1], 0);
ShoveChatStr(argv[1], 1);
}
}
CCMD (messagemode2)
{
if (menuactive == MENU_Off)
if (menuactive != MENU_Off)
return;
const uint64_t time = I_msTime();
if (ChatCoolDown > time)
{
buttonMap.ResetButtonStates();
chatmodeon = 2;
C_HideConsole ();
CT_ClearChatMessage ();
Printf("You must wait %d more seconds before being able to chat again\n", int((ChatCoolDown - time) * 0.001));
return;
}
if (multiplayer && deathmatch && !teamplay)
{
if (cl_showchat < CHAT_GLOBAL)
{
Printf("Global chat is currently disabled\n");
return;
}
chatmodeon = 1;
}
else
{
if (cl_showchat < CHAT_TEAM_ONLY)
{
Printf("Team chat is currently disabled\n");
return;
}
chatmodeon = 2;
}
buttonMap.ResetButtonStates();
C_HideConsole();
CT_ClearChatMessage();
}
CCMD (say_team)
@ -545,6 +652,32 @@ CCMD (say_team)
if (argv.argc() == 1)
{
Printf ("Usage: say_team <message>\n");
return;
}
const uint64_t time = I_msTime();
if (ChatCoolDown > time)
{
Printf("You must wait %d more seconds before being able to chat again\n", int((ChatCoolDown - time) * 0.001));
return;
}
// If in a DM lobby, route it to global chat instead (helps
// improve chat filtering).
if (multiplayer && deathmatch && !teamplay)
{
if (cl_showchat < CHAT_GLOBAL)
{
Printf("Global chat is currently disabled\n");
}
else
{
ShoveChatStr(argv[1], 0);
}
}
else if (cl_showchat < CHAT_TEAM_ONLY)
{
Printf("Team chat is currently disabled\n");
}
else
{

1
src/d_event.h
View file

@ -99,6 +99,7 @@ enum gameaction_t : int
ga_intro,
ga_intermission,
ga_titleloop,
ga_mapwarp,
};
extern gameaction_t gameaction;

35
src/d_main.cpp
View file

@ -167,7 +167,7 @@ void CloseWidgetResources();
bool D_CheckNetGame ();
void D_ProcessEvents ();
void G_BuildTiccmd (ticcmd_t* cmd);
void G_BuildTiccmd (usercmd_t* cmd);
void D_DoAdvanceDemo ();
void D_LoadWadSettings ();
void ParseGLDefs();
@ -874,7 +874,6 @@ static void DrawRateStuff()
static void DrawOverlays()
{
NetUpdate ();
C_DrawConsole ();
M_Drawer ();
DrawRateStuff();
@ -904,6 +903,8 @@ void D_Display ()
int wipe_type;
sector_t *viewsec;
GC::CheckGC();
if (nodrawers || screen == NULL)
return; // for comparative timing / profiling
@ -960,7 +961,7 @@ void D_Display ()
}
// [RH] Allow temporarily disabling wipes
if (NoWipe || !CanWipe())
if (netgame || NoWipe || !CanWipe())
{
if (NoWipe > 0) NoWipe--;
wipestart = nullptr;
@ -1153,7 +1154,6 @@ void D_Display ()
}
else
{
NetUpdate(); // send out any new accumulation
PerformWipe(wipestart, screen->WipeEndScreen(), wipe_type, false, DrawOverlays);
}
cycles.Unclock();
@ -1177,7 +1177,6 @@ void D_ErrorCleanup ()
Net_ClearBuffers ();
G_NewInit ();
M_ClearMenus ();
singletics = false;
playeringame[0] = 1;
players[0].playerstate = PST_LIVE;
gameaction = ga_fullconsole;
@ -1224,28 +1223,7 @@ void D_DoomLoop ()
}
I_SetFrameTime();
// process one or more tics
if (singletics)
{
I_StartTic ();
D_ProcessEvents ();
G_BuildTiccmd (&netcmds[consoleplayer][maketic%BACKUPTICS]);
if (advancedemo)
D_DoAdvanceDemo ();
C_Ticker ();
M_Ticker ();
G_Ticker ();
// [RH] Use the consoleplayer's camera to update sounds
S_UpdateSounds (players[consoleplayer].camera); // move positional sounds
gametic++;
maketic++;
GC::CheckGC ();
Net_NewMakeTic ();
}
else
{
TryRunTics (); // will run at least one tic
}
TryRunTics (); // will run at least one tic
// Update display, next frame, with current state.
I_StartTic ();
D_ProcessEvents();
@ -3466,7 +3444,7 @@ static int D_InitGame(const FIWADInfo* iwad_info, std::vector<std::string>& allw
// [RH] Run any saved commands from the command line or autoexec.cfg now.
gamestate = GS_FULLCONSOLE;
Net_NewMakeTic ();
Net_Initialize();
C_RunDelayedCommands();
gamestate = GS_STARTUP;
@ -3558,6 +3536,7 @@ static int D_InitGame(const FIWADInfo* iwad_info, std::vector<std::string>& allw
AddCommandString(StoredWarp.GetChars());
StoredWarp = "";
}
gameaction = ga_mapwarp;
}
else
{

3980
src/d_net.cpp
View file

File diff suppressed because it is too large Load diff

172
src/d_net.h
View file

@ -32,25 +32,109 @@
#include "doomdef.h"
#include "d_protocol.h"
#include "i_net.h"
#include <queue>
uint64_t I_msTime();
class FDynamicBuffer
{
public:
FDynamicBuffer ();
~FDynamicBuffer ();
FDynamicBuffer();
~FDynamicBuffer();
void SetData (const uint8_t *data, int len);
uint8_t *GetData (int *len = NULL);
void SetData(const uint8_t *data, int len);
uint8_t* GetData(int *len = nullptr);
private:
uint8_t *m_Data;
uint8_t* m_Data;
int m_Len, m_BufferLen;
};
extern FDynamicBuffer NetSpecs[MAXPLAYERS][BACKUPTICS];
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,
};
struct FClientNetState
{
// Networked client data.
struct FNetTic {
FDynamicBuffer Data;
usercmd_t Command;
} Tics[BACKUPTICS] = {};
// Local information about client.
uint8_t CurrentLatency = 0u; // Current latency id the client is on. If the one the client sends back is > this, update RecvTime and mark a new SentTime.
bool bNewLatency = true; // If the sequence was bumped, the next latency packet sent out should record the send time.
uint16_t AverageLatency = 0u; // Calculate the average latency every second or so, that way it doesn't give huge variance in the scoreboard.
uint64_t SentTime[MAXSENDTICS] = {}; // Timestamp for when we sent out the packet to this client.
uint64_t RecvTime[MAXSENDTICS] = {}; // Timestamp for when the client acknowledged our last packet. If in packet server mode, this is the server's delta.
int Flags = 0; // State of this client.
uint8_t ResendID = 0u; // Make sure that if the retransmit happened on a wait barrier, it can be properly resent back over.
int ResendSequenceFrom = -1; // If >= 0, send from this sequence up to the most recent one, capped to MAXSENDTICS.
int SequenceAck = -1; // The last sequence the client reported from us.
int CurrentSequence = -1; // The last sequence we've gotten from this client.
// Every packet includes consistencies for tics that client ran. When
// a world tic is ran, the local client will store all the consistencies
// of the clients in their LocalConsistency. Then the consistencies will
// be checked against retroactively as they come in.
int ResendConsistencyFrom = -1; // If >= 0, send from this consistency up to the most recent one, capped to MAXSENDTICS.
int ConsistencyAck = -1; // Last consistency the client reported from us.
int LastVerifiedConsistency = -1; // Last consistency we checked from this client. If < CurrentNetConsistency, run through them.
int CurrentNetConsistency = -1; // Last consistency we got from this client.
int16_t NetConsistency[BACKUPTICS] = {}; // Consistencies we got from this client.
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 (void);
void NetUpdate(int tics);
// Broadcasts special packets to other players
// to notify of game exit
@ -59,74 +143,36 @@ void D_QuitNetGame (void);
//? how many ticks to run?
void TryRunTics (void);
//Use for checking to see if the netgame has stalled
void Net_CheckLastReceived(int);
// [RH] Functions for making and using special "ticcmds"
void Net_NewMakeTic ();
void Net_WriteInt8 (uint8_t);
void Net_WriteInt16 (int16_t);
void Net_WriteInt32 (int32_t);
void Net_NewClientTic();
void Net_Initialize();
void Net_WriteInt8(uint8_t);
void Net_WriteInt16(int16_t);
void Net_WriteInt32(int32_t);
void Net_WriteInt64(int64_t);
void Net_WriteFloat (float);
void Net_WriteFloat(float);
void Net_WriteDouble(double);
void Net_WriteString (const char *);
void Net_WriteBytes (const uint8_t *, int len);
void Net_WriteString(const char *);
void Net_WriteBytes(const uint8_t *, int len);
void Net_DoCommand (int type, uint8_t **stream, int player);
void Net_SkipCommand (int type, uint8_t **stream);
void Net_ClearBuffers ();
void Net_DoCommand(int cmd, uint8_t **stream, int player);
void Net_SkipCommand(int cmd, uint8_t **stream);
void Net_ResetCommands(bool midTic);
void Net_SetWaiting();
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 struct ticcmd_t localcmds[LOCALCMDTICS];
extern int maketic;
extern int nettics[MAXNETNODES];
extern int netdelay[MAXNETNODES][BACKUPTICS];
extern int nodeforplayer[MAXPLAYERS];
extern ticcmd_t netcmds[MAXPLAYERS][BACKUPTICS];
extern int ticdup;
extern doomcom_t doomcom;
extern usercmd_t LocalCmds[LOCALCMDTICS];
extern int ClientTic;
extern FClientNetState ClientStates[MAXPLAYERS];
extern ENetMode NetMode;
class player_t;
class DObject;
// [RH]
// New generic packet structure:
//
// Header:
// One byte with following flags.
// One byte with starttic
// One byte with master's maketic (master -> slave only!)
// If NCMD_RETRANSMIT set, one byte with retransmitfrom
// If NCMD_XTICS set, one byte with number of tics (minus 3, so theoretically up to 258 tics in one packet)
// If NCMD_QUITTERS, one byte with number of players followed by one byte with each player's consolenum
// If NCMD_MULTI, one byte with number of players followed by one byte with each player's consolenum
// - The first player's consolenum is not included in this list, because it always matches the sender
//
// For each tic:
// Two bytes with consistancy check, followed by tic data
//
// Setup packets are different, and are described just before D_ArbitrateNetStart().
#define NCMD_EXIT 0x80
#define NCMD_RETRANSMIT 0x40
#define NCMD_SETUP 0x20
#define NCMD_MULTI 0x10 // multiple players in this packet
#define NCMD_QUITTERS 0x08 // one or more players just quit (packet server only)
#define NCMD_COMPRESSED 0x04 // remainder of packet is compressed
#define NCMD_XTICS 0x03 // packet contains >2 tics
#define NCMD_2TICS 0x02 // packet contains 2 tics
#define NCMD_1TICS 0x01 // packet contains 1 tic
#define NCMD_0TICS 0x00 // packet contains 0 tics
#endif

577
src/d_protocol.cpp
View file

@ -32,44 +32,42 @@
**
*/
#include "d_protocol.h"
#include "d_net.h"
#include "doomstat.h"
#include "cmdlib.h"
#include "serializer.h"
char *ReadString (uint8_t **stream)
char* ReadString(uint8_t **stream)
{
char *string = *((char **)stream);
*stream += strlen (string) + 1;
return copystring (string);
*stream += strlen(string) + 1;
return copystring(string);
}
const char *ReadStringConst(uint8_t **stream)
const char* ReadStringConst(uint8_t **stream)
{
const char *string = *((const char **)stream);
*stream += strlen (string) + 1;
*stream += strlen(string) + 1;
return string;
}
uint8_t ReadInt8 (uint8_t **stream)
uint8_t ReadInt8(uint8_t **stream)
{
uint8_t v = **stream;
*stream += 1;
return v;
}
int16_t ReadInt16 (uint8_t **stream)
int16_t ReadInt16(uint8_t **stream)
{
int16_t v = (((*stream)[0]) << 8) | (((*stream)[1]));
*stream += 2;
return v;
}
int32_t ReadInt32 (uint8_t **stream)
int32_t ReadInt32(uint8_t **stream)
{
int32_t v = (((*stream)[0]) << 24) | (((*stream)[1]) << 16) | (((*stream)[2]) << 8) | (((*stream)[3]));
*stream += 4;
@ -84,7 +82,7 @@ int64_t ReadInt64(uint8_t** stream)
return v;
}
float ReadFloat (uint8_t **stream)
float ReadFloat(uint8_t **stream)
{
union
{
@ -106,7 +104,7 @@ double ReadDouble(uint8_t** stream)
return fakeint.f;
}
void WriteString (const char *string, uint8_t **stream)
void WriteString(const char *string, uint8_t **stream)
{
char *p = *((char **)stream);
@ -118,21 +116,20 @@ void WriteString (const char *string, uint8_t **stream)
*stream = (uint8_t *)p;
}
void WriteInt8 (uint8_t v, uint8_t **stream)
void WriteInt8(uint8_t v, uint8_t **stream)
{
**stream = v;
*stream += 1;
}
void WriteInt16 (int16_t v, uint8_t **stream)
void WriteInt16(int16_t v, uint8_t **stream)
{
(*stream)[0] = v >> 8;
(*stream)[1] = v & 255;
*stream += 2;
}
void WriteInt32 (int32_t v, uint8_t **stream)
void WriteInt32(int32_t v, uint8_t **stream)
{
(*stream)[0] = v >> 24;
(*stream)[1] = (v >> 16) & 255;
@ -154,7 +151,7 @@ void WriteInt64(int64_t v, uint8_t** stream)
*stream += 8;
}
void WriteFloat (float v, uint8_t **stream)
void WriteFloat(float v, uint8_t **stream)
{
union
{
@ -176,171 +173,7 @@ void WriteDouble(double v, uint8_t** stream)
WriteInt64(fakeint.i, stream);
}
// Returns the number of bytes read
int UnpackUserCmd (usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream)
{
uint8_t *start = *stream;
uint8_t flags;
if (basis != NULL)
{
if (basis != ucmd)
{
memcpy (ucmd, basis, sizeof(usercmd_t));
}
}
else
{
memset (ucmd, 0, sizeof(usercmd_t));
}
flags = ReadInt8 (stream);
if (flags)
{
// We can support up to 29 buttons, using from 0 to 4 bytes to store them.
if (flags & UCMDF_BUTTONS)
{
uint32_t buttons = ucmd->buttons;
uint8_t in = ReadInt8(stream);
buttons = (buttons & ~0x7F) | (in & 0x7F);
if (in & 0x80)
{
in = ReadInt8(stream);
buttons = (buttons & ~(0x7F << 7)) | ((in & 0x7F) << 7);
if (in & 0x80)
{
in = ReadInt8(stream);
buttons = (buttons & ~(0x7F << 14)) | ((in & 0x7F) << 14);
if (in & 0x80)
{
in = ReadInt8(stream);
buttons = (buttons & ~(0xFF << 21)) | (in << 21);
}
}
}
ucmd->buttons = buttons;
}
if (flags & UCMDF_PITCH)
ucmd->pitch = ReadInt16 (stream);
if (flags & UCMDF_YAW)
ucmd->yaw = ReadInt16 (stream);
if (flags & UCMDF_FORWARDMOVE)
ucmd->forwardmove = ReadInt16 (stream);
if (flags & UCMDF_SIDEMOVE)
ucmd->sidemove = ReadInt16 (stream);
if (flags & UCMDF_UPMOVE)
ucmd->upmove = ReadInt16 (stream);
if (flags & UCMDF_ROLL)
ucmd->roll = ReadInt16 (stream);
}
return int(*stream - start);
}
// Returns the number of bytes written
int PackUserCmd (const usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream)
{
uint8_t flags = 0;
uint8_t *temp = *stream;
uint8_t *start = *stream;
usercmd_t blank;
uint32_t buttons_changed;
if (basis == NULL)
{
memset (&blank, 0, sizeof(blank));
basis = &blank;
}
WriteInt8 (0, stream); // Make room for the packing bits
buttons_changed = ucmd->buttons ^ basis->buttons;
if (buttons_changed != 0)
{
uint8_t bytes[4] = { uint8_t(ucmd->buttons & 0x7F),
uint8_t((ucmd->buttons >> 7) & 0x7F),
uint8_t((ucmd->buttons >> 14) & 0x7F),
uint8_t((ucmd->buttons >> 21) & 0xFF) };
flags |= UCMDF_BUTTONS;
if (buttons_changed & 0xFFFFFF80)
{
bytes[0] |= 0x80;
if (buttons_changed & 0xFFFFC000)
{
bytes[1] |= 0x80;
if (buttons_changed & 0xFFE00000)
{
bytes[2] |= 0x80;
}
}
}
WriteInt8 (bytes[0], stream);
if (bytes[0] & 0x80)
{
WriteInt8 (bytes[1], stream);
if (bytes[1] & 0x80)
{
WriteInt8 (bytes[2], stream);
if (bytes[2] & 0x80)
{
WriteInt8 (bytes[3], stream);
}
}
}
}
if (ucmd->pitch != basis->pitch)
{
flags |= UCMDF_PITCH;
WriteInt16 (ucmd->pitch, stream);
}
if (ucmd->yaw != basis->yaw)
{
flags |= UCMDF_YAW;
WriteInt16 (ucmd->yaw, stream);
}
if (ucmd->forwardmove != basis->forwardmove)
{
flags |= UCMDF_FORWARDMOVE;
WriteInt16 (ucmd->forwardmove, stream);
}
if (ucmd->sidemove != basis->sidemove)
{
flags |= UCMDF_SIDEMOVE;
WriteInt16 (ucmd->sidemove, stream);
}
if (ucmd->upmove != basis->upmove)
{
flags |= UCMDF_UPMOVE;
WriteInt16 (ucmd->upmove, stream);
}
if (ucmd->roll != basis->roll)
{
flags |= UCMDF_ROLL;
WriteInt16 (ucmd->roll, stream);
}
// Write the packing bits
WriteInt8 (flags, &temp);
return int(*stream - start);
}
FSerializer &Serialize(FSerializer &arc, const char *key, ticcmd_t &cmd, ticcmd_t *def)
{
if (arc.BeginObject(key))
{
arc("consistency", cmd.consistancy)
("ucmd", cmd.ucmd)
.EndObject();
}
return arc;
}
FSerializer &Serialize(FSerializer &arc, const char *key, usercmd_t &cmd, usercmd_t *def)
FSerializer& Serialize(FSerializer& arc, const char* key, usercmd_t& cmd, usercmd_t* def)
{
// This used packed data with the old serializer but that's totally counterproductive when
// having a text format that is human-readable. So this compression has been undone here.
@ -360,192 +193,308 @@ FSerializer &Serialize(FSerializer &arc, const char *key, usercmd_t &cmd, usercm
return arc;
}
int WriteUserCmdMessage (usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream)
// Returns the number of bytes read
int UnpackUserCmd(usercmd_t& cmd, const usercmd_t* basis, uint8_t*& stream)
{
if (basis == NULL)
const uint8_t* start = stream;
if (basis != nullptr)
{
if (ucmd->buttons != 0 ||
ucmd->pitch != 0 ||
ucmd->yaw != 0 ||
ucmd->forwardmove != 0 ||
ucmd->sidemove != 0 ||
ucmd->upmove != 0 ||
ucmd->roll != 0)
{
WriteInt8 (DEM_USERCMD, stream);
return PackUserCmd (ucmd, basis, stream) + 1;
}
if (basis != &cmd)
memcpy(&cmd, basis, sizeof(usercmd_t));
}
else
if (ucmd->buttons != basis->buttons ||
ucmd->pitch != basis->pitch ||
ucmd->yaw != basis->yaw ||
ucmd->forwardmove != basis->forwardmove ||
ucmd->sidemove != basis->sidemove ||
ucmd->upmove != basis->upmove ||
ucmd->roll != basis->roll)
{
WriteInt8 (DEM_USERCMD, stream);
return PackUserCmd (ucmd, basis, stream) + 1;
memset(&cmd, 0, sizeof(usercmd_t));
}
WriteInt8 (DEM_EMPTYUSERCMD, stream);
uint8_t flags = ReadInt8(&stream);
if (flags)
{
// We can support up to 29 buttons using 1 to 4 bytes to store them. The most
// significant bit of each button byte is a flag to indicate whether or not more buttons
// should be read in excluding the last one which supports all 8 bits.
if (flags & UCMDF_BUTTONS)
{
uint8_t in = ReadInt8(&stream);
uint32_t buttons = (cmd.buttons & ~0x7F) | (in & 0x7F);
if (in & MoreButtons)
{
in = ReadInt8(&stream);
buttons = (buttons & ~(0x7F << 7)) | ((in & 0x7F) << 7);
if (in & MoreButtons)
{
in = ReadInt8(&stream);
buttons = (buttons & ~(0x7F << 14)) | ((in & 0x7F) << 14);
if (in & MoreButtons)
{
in = ReadInt8(&stream);
buttons = (buttons & ~(0xFF << 21)) | (in << 21);
}
}
}
cmd.buttons = buttons;
}
if (flags & UCMDF_PITCH)
cmd.pitch = ReadInt16(&stream);
if (flags & UCMDF_YAW)
cmd.yaw = ReadInt16(&stream);
if (flags & UCMDF_FORWARDMOVE)
cmd.forwardmove = ReadInt16(&stream);
if (flags & UCMDF_SIDEMOVE)
cmd.sidemove = ReadInt16(&stream);
if (flags & UCMDF_UPMOVE)
cmd.upmove = ReadInt16(&stream);
if (flags & UCMDF_ROLL)
cmd.roll = ReadInt16(&stream);
}
return int(stream - start);
}
int PackUserCmd(const usercmd_t& cmd, const usercmd_t* basis, uint8_t*& stream)
{
uint8_t flags = 0;
uint8_t* start = stream;
usercmd_t blank;
if (basis == nullptr)
{
memset(&blank, 0, sizeof(blank));
basis = &blank;
}
++stream; // Make room for the flags.
uint32_t buttons_changed = cmd.buttons ^ basis->buttons;
if (buttons_changed != 0)
{
uint8_t bytes[4] = { uint8_t(cmd.buttons & 0x7F),
uint8_t((cmd.buttons >> 7) & 0x7F),
uint8_t((cmd.buttons >> 14) & 0x7F),
uint8_t((cmd.buttons >> 21) & 0xFF) };
flags |= UCMDF_BUTTONS;
if (buttons_changed & 0xFFFFFF80)
{
bytes[0] |= MoreButtons;
if (buttons_changed & 0xFFFFC000)
{
bytes[1] |= MoreButtons;
if (buttons_changed & 0xFFE00000)
bytes[2] |= MoreButtons;
}
}
WriteInt8(bytes[0], &stream);
if (bytes[0] & MoreButtons)
{
WriteInt8(bytes[1], &stream);
if (bytes[1] & MoreButtons)
{
WriteInt8(bytes[2], &stream);
if (bytes[2] & MoreButtons)
WriteInt8(bytes[3], &stream);
}
}
}
if (cmd.pitch != basis->pitch)
{
flags |= UCMDF_PITCH;
WriteInt16(cmd.pitch, &stream);
}
if (cmd.yaw != basis->yaw)
{
flags |= UCMDF_YAW;
WriteInt16 (cmd.yaw, &stream);
}
if (cmd.forwardmove != basis->forwardmove)
{
flags |= UCMDF_FORWARDMOVE;
WriteInt16 (cmd.forwardmove, &stream);
}
if (cmd.sidemove != basis->sidemove)
{
flags |= UCMDF_SIDEMOVE;
WriteInt16(cmd.sidemove, &stream);
}
if (cmd.upmove != basis->upmove)
{
flags |= UCMDF_UPMOVE;
WriteInt16(cmd.upmove, &stream);
}
if (cmd.roll != basis->roll)
{
flags |= UCMDF_ROLL;
WriteInt16(cmd.roll, &stream);
}
// Write the packing bits
WriteInt8(flags, &start);
return int(stream - start);
}
int WriteUserCmdMessage(const usercmd_t& cmd, const usercmd_t* basis, uint8_t*& stream)
{
if (basis == nullptr)
{
if (cmd.buttons
|| cmd.pitch || cmd.yaw || cmd.roll
|| cmd.forwardmove || cmd.sidemove || cmd.upmove)
{
WriteInt8(DEM_USERCMD, &stream);
return PackUserCmd(cmd, basis, stream) + 1;
}
}
else if (cmd.buttons != basis->buttons
|| cmd.yaw != basis->yaw || cmd.pitch != basis->pitch || cmd.roll != basis->roll
|| cmd.forwardmove != basis->forwardmove || cmd.sidemove != basis->sidemove || cmd.upmove != basis->upmove)
{
WriteInt8(DEM_USERCMD, &stream);
return PackUserCmd(cmd, basis, stream) + 1;
}
WriteInt8(DEM_EMPTYUSERCMD, &stream);
return 1;
}
int SkipTicCmd (uint8_t **stream, int count)
// Reads through the user command without actually setting any of its info. Used to get the size
// of the command when getting the length of the stream.
int SkipUserCmdMessage(uint8_t*& stream)
{
int i, skip;
uint8_t *flow = *stream;
const uint8_t* start = stream;
for (i = count; i > 0; i--)
while (true)
{
bool moreticdata = true;
flow += 2; // Skip consistancy marker
while (moreticdata)
const uint8_t type = *stream++;
if (type == DEM_USERCMD)
{
uint8_t type = *flow++;
if (type == DEM_USERCMD)
int skip = 1;
if (*stream & UCMDF_PITCH)
skip += 2;
if (*stream & UCMDF_YAW)
skip += 2;
if (*stream & UCMDF_FORWARDMOVE)
skip += 2;
if (*stream & UCMDF_SIDEMOVE)
skip += 2;
if (*stream & UCMDF_UPMOVE)
skip += 2;
if (*stream & UCMDF_ROLL)
skip += 2;
if (*stream & UCMDF_BUTTONS)
{
moreticdata = false;
skip = 1;
if (*flow & UCMDF_PITCH) skip += 2;
if (*flow & UCMDF_YAW) skip += 2;
if (*flow & UCMDF_FORWARDMOVE) skip += 2;
if (*flow & UCMDF_SIDEMOVE) skip += 2;
if (*flow & UCMDF_UPMOVE) skip += 2;
if (*flow & UCMDF_ROLL) skip += 2;
if (*flow & UCMDF_BUTTONS)
if (*++stream & MoreButtons)
{
if (*++flow & 0x80)
if (*++stream & MoreButtons)
{
if (*++flow & 0x80)
{
if (*++flow & 0x80)
{
++flow;
}
}
if (*++stream & MoreButtons)
++stream;
}
}
flow += skip;
}
else if (type == DEM_EMPTYUSERCMD)
{
moreticdata = false;
}
else
{
Net_SkipCommand (type, &flow);
}
stream += skip;
break;
}
}
skip = int(flow - *stream);
*stream = flow;
return skip;
}
extern short consistancy[MAXPLAYERS][BACKUPTICS];
void ReadTicCmd (uint8_t **stream, int player, int tic)
{
int type;
uint8_t *start;
ticcmd_t *tcmd;
int ticmod = tic % BACKUPTICS;
tcmd = &netcmds[player][ticmod];
tcmd->consistancy = ReadInt16 (stream);
start = *stream;
while ((type = ReadInt8 (stream)) != DEM_USERCMD && type != DEM_EMPTYUSERCMD)
Net_SkipCommand (type, stream);
NetSpecs[player][ticmod].SetData (start, int(*stream - start - 1));
if (type == DEM_USERCMD)
{
UnpackUserCmd (&tcmd->ucmd,
tic ? &netcmds[player][(tic-1)%BACKUPTICS].ucmd : NULL, stream);
}
else
{
if (tic)
else if (type == DEM_EMPTYUSERCMD)
{
memcpy (&tcmd->ucmd, &netcmds[player][(tic-1)%BACKUPTICS].ucmd, sizeof(tcmd->ucmd));
break;
}
else
{
memset (&tcmd->ucmd, 0, sizeof(tcmd->ucmd));
Net_SkipCommand(type, &stream);
}
}
if (player==consoleplayer&&tic>BACKUPTICS)
assert(consistancy[player][ticmod] == tcmd->consistancy);
return int(stream - start);
}
void RunNetSpecs (int player, int buf)
int ReadUserCmdMessage(uint8_t*& stream, int player, int tic)
{
uint8_t *stream;
int len;
const int ticMod = tic % BACKUPTICS;
if (gametic % ticdup == 0)
auto& curTic = ClientStates[player].Tics[ticMod];
usercmd_t& ticCmd = curTic.Command;
const uint8_t* start = stream;
// Skip until we reach the player command. Event data will get read off once the
// tick is actually executed.
int type;
while ((type = ReadInt8(&stream)) != DEM_USERCMD && type != DEM_EMPTYUSERCMD)
Net_SkipCommand(type, &stream);
// Subtract a byte to account for the fact the stream head is now sitting on the
// user command.
curTic.Data.SetData(start, int(stream - start - 1));
if (type == DEM_USERCMD)
{
stream = NetSpecs[player][buf].GetData (&len);
if (stream)
{
uint8_t *end = stream + len;
while (stream < end)
{
int type = ReadInt8 (&stream);
Net_DoCommand (type, &stream, player);
}
if (!demorecording)
NetSpecs[player][buf].SetData (NULL, 0);
}
UnpackUserCmd(ticCmd,
tic > 0 ? &ClientStates[player].Tics[(tic - 1) % BACKUPTICS].Command : nullptr, stream);
}
else
{
if (tic > 0)
memcpy(&ticCmd, &ClientStates[player].Tics[(tic - 1) % BACKUPTICS].Command, sizeof(ticCmd));
else
memset(&ticCmd, 0, sizeof(ticCmd));
}
return int(stream - start);
}
void RunPlayerCommands(int player, int tic)
{
// We don't have the full command yet, so don't run it.
if (gametic % doomcom.ticdup)
return;
int len;
auto& data = ClientStates[player].Tics[tic % BACKUPTICS].Data;
uint8_t* stream = data.GetData(&len);
if (stream != nullptr)
{
uint8_t* end = stream + len;
while (stream < end)
Net_DoCommand(ReadInt8(&stream), &stream, player);
if (!demorecording)
data.SetData(nullptr, 0);
}
}
uint8_t *lenspot;
// Demo related functionality
uint8_t* streamPos = nullptr;
// Write the header of an IFF chunk and leave space
// for the length field.
void StartChunk (int id, uint8_t **stream)
void StartChunk(int id, uint8_t **stream)
{
WriteInt32 (id, stream);
lenspot = *stream;
WriteInt32(id, stream);
streamPos = *stream;
*stream += 4;
}
// Write the length field for the chunk and insert
// pad byte if the chunk is odd-sized.
void FinishChunk (uint8_t **stream)
void FinishChunk(uint8_t **stream)
{
int len;
if (!lenspot)
if (streamPos == nullptr)
return;
len = int(*stream - lenspot - 4);
WriteInt32 (len, &lenspot);
int len = int(*stream - streamPos - 4);
WriteInt32(len, &streamPos);
if (len & 1)
WriteInt8 (0, stream);
WriteInt8(0, stream);
lenspot = NULL;
streamPos = nullptr;
}
// Skip past an unknown chunk. *stream should be
// pointing to the chunk's length field.
void SkipChunk (uint8_t **stream)
void SkipChunk(uint8_t **stream)
{
int len;
len = ReadInt32 (stream);
int len = ReadInt32(stream);
*stream += len + (len & 1);
}

25
src/d_protocol.h
View file

@ -50,6 +50,7 @@
#define NETD_ID BIGE_ID('N','E','T','D')
#define WEAP_ID BIGE_ID('W','E','A','P')
constexpr int MoreButtons = 0x80;
struct zdemoheader_s {
uint8_t demovermajor;
@ -165,6 +166,7 @@ enum EDemoCommand
DEM_ENDSCREENJOB,
DEM_ZSC_CMD, // 74 String: Command, Word: Byte size of command
DEM_CHANGESKILL, // 75 Int: Skill
DEM_KICK, // 76 Byte: Player number
};
// The following are implemented by cht_DoCheat in m_cheat.cpp
@ -230,23 +232,14 @@ void StartChunk (int id, uint8_t **stream);
void FinishChunk (uint8_t **stream);
void SkipChunk (uint8_t **stream);
int UnpackUserCmd (usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream);
int PackUserCmd (const usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream);
int WriteUserCmdMessage (usercmd_t *ucmd, const usercmd_t *basis, uint8_t **stream);
// Returns the number of bytes written to the stream
int UnpackUserCmd(usercmd_t& ucmd, const usercmd_t* basis, uint8_t*& stream);
int PackUserCmd(const usercmd_t& ucmd, const usercmd_t* basis, uint8_t*& stream);
int WriteUserCmdMessage(const usercmd_t& ucmd, const usercmd_t *basis, uint8_t*& stream);
// The data sampled per tick (single player)
// and transmitted to other peers (multiplayer).
// Mainly movements/button commands per game tick,
// plus a checksum for internal state consistency.
struct ticcmd_t
{
usercmd_t ucmd;
int16_t consistancy; // checks for net game
};
int SkipTicCmd (uint8_t **stream, int count);
void ReadTicCmd (uint8_t **stream, int player, int tic);
void RunNetSpecs (int player, int buf);
int SkipUserCmdMessage(uint8_t*& stream);
int ReadUserCmdMessage(uint8_t*& stream, int player, int tic);
void RunPlayerCommands(int player, int tic);
uint8_t ReadInt8 (uint8_t **stream);
int16_t ReadInt16 (uint8_t **stream);

2
src/doomdef.h
View file

@ -64,7 +64,7 @@ constexpr int TICRATE = 35;
enum
{
// The maximum number of players, multiplayer/networking.
MAXPLAYERS = 8,
MAXPLAYERS = 16,
// Amount of damage done by a telefrag.
TELEFRAG_DAMAGE = 1000000

242
src/g_game.cpp
View file

@ -100,8 +100,8 @@ extern int startpos, laststartpos;
bool WriteZip(const char* filename, const FileSys::FCompressedBuffer* content, size_t contentcount);
bool G_CheckDemoStatus (void);
void G_ReadDemoTiccmd (ticcmd_t *cmd, int player);
void G_WriteDemoTiccmd (ticcmd_t *cmd, int player, int buf);
void G_ReadDemoTiccmd (usercmd_t *cmd, int player);
void G_WriteDemoTiccmd (usercmd_t *cmd, int player, int buf);
void G_PlayerReborn (int player);
void G_DoNewGame (void);
@ -110,6 +110,7 @@ void G_DoPlayDemo (void);
void G_DoCompleted (void);
void G_DoVictory (void);
void G_DoWorldDone (void);
void G_DoMapWarp();
void G_DoSaveGame (bool okForQuicksave, bool forceQuicksave, FString filename, const char *description);
void G_DoAutoSave ();
void G_DoQuickSave ();
@ -126,6 +127,7 @@ CVAR (Bool, cl_waitforsave, true, CVAR_ARCHIVE | CVAR_GLOBALCONFIG);
CVAR (Bool, enablescriptscreenshot, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG);
CVAR (Bool, cl_restartondeath, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG);
EXTERN_CVAR (Float, con_midtime);
EXTERN_CVAR(Bool, net_disablepause)
//==========================================================================
//
@ -185,8 +187,6 @@ uint8_t* zdembodyend; // end of ZDEM BODY chunk
bool singledemo; // quit after playing a demo from cmdline
bool precache = true; // if true, load all graphics at start
short consistancy[MAXPLAYERS][BACKUPTICS];
#define MAXPLMOVE (forwardmove[1])
@ -353,6 +353,12 @@ CCMD (land)
CCMD (pause)
{
if (netgame && !players[consoleplayer].settings_controller && net_disablepause)
{
Printf("Only settings controllers can currently (un)pause the game\n");
return;
}
sendpause = true;
}
@ -580,9 +586,9 @@ FBaseCVar* G_GetUserCVar(int playernum, const char* cvarname)
return cvar;
}
static ticcmd_t emptycmd;
static usercmd_t emptycmd;
ticcmd_t* G_BaseTiccmd()
usercmd_t* G_BaseTiccmd()
{
return &emptycmd;
}
@ -594,7 +600,7 @@ ticcmd_t* G_BaseTiccmd()
// or reads it from the demo buffer.
// If recording a demo, write it out
//
void G_BuildTiccmd (ticcmd_t *cmd)
void G_BuildTiccmd (usercmd_t *cmd)
{
int strafe;
int speed;
@ -602,13 +608,11 @@ void G_BuildTiccmd (ticcmd_t *cmd)
int side;
int fly;
ticcmd_t *base;
usercmd_t *base;
base = G_BaseTiccmd ();
*cmd = *base;
cmd->consistancy = consistancy[consoleplayer][(maketic/ticdup)%BACKUPTICS];
strafe = buttonMap.ButtonDown(Button_Strafe);
speed = buttonMap.ButtonDown(Button_Speed) ^ (int)cl_run;
@ -618,7 +622,7 @@ void G_BuildTiccmd (ticcmd_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 += ticdup;
turnheld += doomcom.ticdup;
else
turnheld = 0;
@ -682,33 +686,33 @@ void G_BuildTiccmd (ticcmd_t *cmd)
side -= sidemove[speed];
// buttons
if (buttonMap.ButtonDown(Button_Attack)) cmd->ucmd.buttons |= BT_ATTACK;
if (buttonMap.ButtonDown(Button_AltAttack)) cmd->ucmd.buttons |= BT_ALTATTACK;
if (buttonMap.ButtonDown(Button_Use)) cmd->ucmd.buttons |= BT_USE;
if (buttonMap.ButtonDown(Button_Jump)) cmd->ucmd.buttons |= BT_JUMP;
if (buttonMap.ButtonDown(Button_Crouch)) cmd->ucmd.buttons |= BT_CROUCH;
if (buttonMap.ButtonDown(Button_Zoom)) cmd->ucmd.buttons |= BT_ZOOM;
if (buttonMap.ButtonDown(Button_Reload)) cmd->ucmd.buttons |= BT_RELOAD;
if (buttonMap.ButtonDown(Button_Attack)) cmd->buttons |= BT_ATTACK;
if (buttonMap.ButtonDown(Button_AltAttack)) cmd->buttons |= BT_ALTATTACK;
if (buttonMap.ButtonDown(Button_Use)) cmd->buttons |= BT_USE;
if (buttonMap.ButtonDown(Button_Jump)) cmd->buttons |= BT_JUMP;
if (buttonMap.ButtonDown(Button_Crouch)) cmd->buttons |= BT_CROUCH;
if (buttonMap.ButtonDown(Button_Zoom)) cmd->buttons |= BT_ZOOM;
if (buttonMap.ButtonDown(Button_Reload)) cmd->buttons |= BT_RELOAD;
if (buttonMap.ButtonDown(Button_User1)) cmd->ucmd.buttons |= BT_USER1;
if (buttonMap.ButtonDown(Button_User2)) cmd->ucmd.buttons |= BT_USER2;
if (buttonMap.ButtonDown(Button_User3)) cmd->ucmd.buttons |= BT_USER3;
if (buttonMap.ButtonDown(Button_User4)) cmd->ucmd.buttons |= BT_USER4;
if (buttonMap.ButtonDown(Button_User1)) cmd->buttons |= BT_USER1;
if (buttonMap.ButtonDown(Button_User2)) cmd->buttons |= BT_USER2;
if (buttonMap.ButtonDown(Button_User3)) cmd->buttons |= BT_USER3;
if (buttonMap.ButtonDown(Button_User4)) cmd->buttons |= BT_USER4;
if (buttonMap.ButtonDown(Button_Speed)) cmd->ucmd.buttons |= BT_SPEED;
if (buttonMap.ButtonDown(Button_Strafe)) cmd->ucmd.buttons |= BT_STRAFE;
if (buttonMap.ButtonDown(Button_MoveRight)) cmd->ucmd.buttons |= BT_MOVERIGHT;
if (buttonMap.ButtonDown(Button_MoveLeft)) cmd->ucmd.buttons |= BT_MOVELEFT;
if (buttonMap.ButtonDown(Button_LookDown)) cmd->ucmd.buttons |= BT_LOOKDOWN;
if (buttonMap.ButtonDown(Button_LookUp)) cmd->ucmd.buttons |= BT_LOOKUP;
if (buttonMap.ButtonDown(Button_Back)) cmd->ucmd.buttons |= BT_BACK;
if (buttonMap.ButtonDown(Button_Forward)) cmd->ucmd.buttons |= BT_FORWARD;
if (buttonMap.ButtonDown(Button_Right)) cmd->ucmd.buttons |= BT_RIGHT;
if (buttonMap.ButtonDown(Button_Left)) cmd->ucmd.buttons |= BT_LEFT;
if (buttonMap.ButtonDown(Button_MoveDown)) cmd->ucmd.buttons |= BT_MOVEDOWN;
if (buttonMap.ButtonDown(Button_MoveUp)) cmd->ucmd.buttons |= BT_MOVEUP;
if (buttonMap.ButtonDown(Button_ShowScores)) cmd->ucmd.buttons |= BT_SHOWSCORES;
if (speed) cmd->ucmd.buttons |= BT_RUN;
if (buttonMap.ButtonDown(Button_Speed)) cmd->buttons |= BT_SPEED;
if (buttonMap.ButtonDown(Button_Strafe)) cmd->buttons |= BT_STRAFE;
if (buttonMap.ButtonDown(Button_MoveRight)) cmd->buttons |= BT_MOVERIGHT;
if (buttonMap.ButtonDown(Button_MoveLeft)) cmd->buttons |= BT_MOVELEFT;
if (buttonMap.ButtonDown(Button_LookDown)) cmd->buttons |= BT_LOOKDOWN;
if (buttonMap.ButtonDown(Button_LookUp)) cmd->buttons |= BT_LOOKUP;
if (buttonMap.ButtonDown(Button_Back)) cmd->buttons |= BT_BACK;
if (buttonMap.ButtonDown(Button_Forward)) cmd->buttons |= BT_FORWARD;
if (buttonMap.ButtonDown(Button_Right)) cmd->buttons |= BT_RIGHT;
if (buttonMap.ButtonDown(Button_Left)) cmd->buttons |= BT_LEFT;
if (buttonMap.ButtonDown(Button_MoveDown)) cmd->buttons |= BT_MOVEDOWN;
if (buttonMap.ButtonDown(Button_MoveUp)) cmd->buttons |= BT_MOVEUP;
if (buttonMap.ButtonDown(Button_ShowScores)) cmd->buttons |= BT_SHOWSCORES;
if (speed) cmd->buttons |= BT_RUN;
// Handle joysticks/game controllers.
float joyaxes[NUM_JOYAXIS];
@ -746,7 +750,7 @@ void G_BuildTiccmd (ticcmd_t *cmd)
forward += xs_CRoundToInt(mousey * m_forward);
}
cmd->ucmd.pitch = LocalViewPitch >> 16;
cmd->pitch = LocalViewPitch >> 16;
if (SendLand)
{
@ -769,10 +773,10 @@ void G_BuildTiccmd (ticcmd_t *cmd)
else if (side < -MAXPLMOVE)
side = -MAXPLMOVE;
cmd->ucmd.forwardmove += forward;
cmd->ucmd.sidemove += side;
cmd->ucmd.yaw = LocalViewAngle >> 16;
cmd->ucmd.upmove = fly;
cmd->forwardmove += forward;
cmd->sidemove += side;
cmd->yaw = LocalViewAngle >> 16;
cmd->upmove = fly;
LocalViewAngle = 0;
LocalViewPitch = 0;
@ -780,7 +784,7 @@ void G_BuildTiccmd (ticcmd_t *cmd)
if (sendturn180)
{
sendturn180 = false;
cmd->ucmd.buttons |= BT_TURN180;
cmd->buttons |= BT_TURN180;
}
if (sendpause)
{
@ -814,8 +818,8 @@ void G_BuildTiccmd (ticcmd_t *cmd)
SendItemDrop = NULL;
}
cmd->ucmd.forwardmove <<= 8;
cmd->ucmd.sidemove <<= 8;
cmd->forwardmove <<= 8;
cmd->sidemove <<= 8;
}
static int LookAdjust(int look)
@ -1111,53 +1115,25 @@ static void G_FullConsole()
}
//==========================================================================
//
// FRandom :: StaticSumSeeds
//
// This function produces a uint32_t that can be used to check the consistancy
// of network games between different machines. Only a select few RNGs are
// used for the sum, because not all RNGs are important to network sync.
//
//==========================================================================
extern FRandom pr_spawnmobj;
extern FRandom pr_acs;
extern FRandom pr_chase;
extern FRandom pr_damagemobj;
static uint32_t StaticSumSeeds()
{
return
pr_spawnmobj.Seed() +
pr_acs.Seed() +
pr_chase.Seed() +
pr_damagemobj.Seed();
}
//
// G_Ticker
// Make ticcmd_ts for the players.
//
void G_Ticker ()
{
int i;
gamestate_t oldgamestate;
// do player reborns if needed
for (i = 0; i < MAXPLAYERS; i++)
// TODO: These should really be moved to queues.
for (int i = 0; i < MAXPLAYERS; ++i)
{
if (playeringame[i])
{
if (players[i].playerstate == PST_GONE)
{
G_DoPlayerPop(i);
}
if (players[i].playerstate == PST_REBORN || players[i].playerstate == PST_ENTER)
{
primaryLevel->DoReborn(i);
}
}
if (!playeringame[i])
continue;
if (players[i].playerstate == PST_GONE)
G_DoPlayerPop(i);
else if (players[i].playerstate == PST_REBORN || players[i].playerstate == PST_ENTER)
primaryLevel->DoReborn(i, false);
}
if (ToggleFullscreen)
@ -1207,6 +1183,9 @@ void G_Ticker ()
case ga_playdemo:
G_DoPlayDemo ();
break;
case ga_mapwarp:
G_DoMapWarp();
break;
case ga_completed:
G_DoCompleted ();
break;
@ -1253,68 +1232,34 @@ void G_Ticker ()
}
// get commands, check consistancy, and build new consistancy check
int buf = (gametic/ticdup)%BACKUPTICS;
// [RH] Include some random seeds and player stuff in the consistancy
// check, not just the player's x position like BOOM.
uint32_t rngsum = StaticSumSeeds ();
const int curTic = gametic / doomcom.ticdup;
//Added by MC: For some of that bot stuff. The main bot function.
primaryLevel->BotInfo.Main (primaryLevel);
for (i = 0; i < MAXPLAYERS; i++)
for (auto client : NetworkClients)
{
if (playeringame[i])
usercmd_t *cmd = &players[client].cmd;
usercmd_t* nextCmd = &ClientStates[client].Tics[curTic % BACKUPTICS].Command;
RunPlayerCommands(client, curTic);
if (demorecording)
G_WriteDemoTiccmd(nextCmd, client, curTic);
players[client].oldbuttons = cmd->buttons;
// If the user alt-tabbed away, paused gets set to -1. In this case,
// we do not want to read more demo commands until paused is no
// longer negative.
if (demoplayback)
G_ReadDemoTiccmd(cmd, client);
else
memcpy(cmd, nextCmd, sizeof(usercmd_t));
// check for turbo cheats
if (multiplayer && turbo > 100.f && cmd->forwardmove > TURBOTHRESHOLD &&
!(gametic & 31) && ((gametic >> 5) & (MAXPLAYERS-1)) == client)
{
ticcmd_t *cmd = &players[i].cmd;
ticcmd_t *newcmd = &netcmds[i][buf];
if ((gametic % ticdup) == 0)
{
RunNetSpecs (i, buf);
}
if (demorecording)
{
G_WriteDemoTiccmd (newcmd, i, buf);
}
players[i].oldbuttons = cmd->ucmd.buttons;
// If the user alt-tabbed away, paused gets set to -1. In this case,
// we do not want to read more demo commands until paused is no
// longer negative.
if (demoplayback)
{
G_ReadDemoTiccmd (cmd, i);
}
else
{
memcpy(cmd, newcmd, sizeof(ticcmd_t));
}
// check for turbo cheats
if (multiplayer && turbo > 100.f && cmd->ucmd.forwardmove > TURBOTHRESHOLD &&
!(gametic&31) && ((gametic>>5)&(MAXPLAYERS-1)) == i )
{
Printf ("%s is turbo!\n", players[i].userinfo.GetName());
}
if (netgame && players[i].Bot == NULL && !demoplayback && (gametic%ticdup) == 0)
{
//players[i].inconsistant = 0;
if (gametic > BACKUPTICS*ticdup && consistancy[i][buf] != cmd->consistancy)
{
players[i].inconsistant = gametic - BACKUPTICS*ticdup;
}
if (players[i].mo)
{
uint32_t sum = rngsum + int((players[i].mo->X() + players[i].mo->Y() + players[i].mo->Z())*257) + players[i].mo->Angles.Yaw.BAMs() + players[i].mo->Angles.Pitch.BAMs();
sum ^= players[i].health;
consistancy[i][buf] = sum;
}
else
{
consistancy[i][buf] = rngsum;
}
}
Printf("%s is turbo!\n", players[client].userinfo.GetName());
}
}
@ -2026,6 +1971,7 @@ void FinishLoadingCVars();
void G_DoLoadGame ()
{
Net_ResetCommands(true);
SetupLoadingCVars();
bool hidecon;
@ -2182,6 +2128,7 @@ void G_DoLoadGame ()
NextSkill = -1;
arc("nextskill", NextSkill);
Net_SetWaiting();
if (level.info != nullptr)
level.info->Snapshot.Clean();
@ -2526,7 +2473,7 @@ void G_DoSaveGame (bool okForQuicksave, bool forceQuicksave, FString filename, c
// DEMO RECORDING
//
void G_ReadDemoTiccmd (ticcmd_t *cmd, int player)
void G_ReadDemoTiccmd (usercmd_t *cmd, int player)
{
int id = DEM_BAD;
@ -2549,7 +2496,7 @@ void G_ReadDemoTiccmd (ticcmd_t *cmd, int player)
break;
case DEM_USERCMD:
UnpackUserCmd (&cmd->ucmd, &cmd->ucmd, &demo_p);
UnpackUserCmd (*cmd, cmd, demo_p);
break;
case DEM_EMPTYUSERCMD:
@ -2580,9 +2527,9 @@ CCMD (stop)
stoprecording = true;
}
extern uint8_t *lenspot;
extern uint8_t *streamPos;
void G_WriteDemoTiccmd (ticcmd_t *cmd, int player, int buf)
void G_WriteDemoTiccmd (usercmd_t *cmd, int player, int buf)
{
uint8_t *specdata;
int speclen;
@ -2598,28 +2545,29 @@ void G_WriteDemoTiccmd (ticcmd_t *cmd, int player, int buf)
}
// [RH] Write any special "ticcmds" for this player to the demo
if ((specdata = NetSpecs[player][buf].GetData (&speclen)) && gametic % ticdup == 0)
if ((specdata = ClientStates[player].Tics[buf % BACKUPTICS].Data.GetData (&speclen)) && !(gametic % doomcom.ticdup))
{
memcpy (demo_p, specdata, speclen);
demo_p += speclen;
NetSpecs[player][buf].SetData (NULL, 0);
ClientStates[player].Tics[buf % BACKUPTICS].Data.SetData(nullptr, 0);
}
// [RH] Now write out a "normal" ticcmd.
WriteUserCmdMessage (&cmd->ucmd, &players[player].cmd.ucmd, &demo_p);
WriteUserCmdMessage (*cmd, &players[player].cmd, demo_p);
// [RH] Bigger safety margin
if (demo_p > demobuffer + maxdemosize - 64)
{
ptrdiff_t pos = demo_p - demobuffer;
ptrdiff_t spot = lenspot - demobuffer;
ptrdiff_t spot = streamPos - demobuffer;
ptrdiff_t comp = democompspot - demobuffer;
ptrdiff_t body = demobodyspot - demobuffer;
// [RH] Allocate more space for the demo
maxdemosize += 0x20000;
demobuffer = (uint8_t *)M_Realloc (demobuffer, maxdemosize);
demo_p = demobuffer + pos;
lenspot = demobuffer + spot;
streamPos = demobuffer + spot;
democompspot = demobuffer + comp;
demobodyspot = demobuffer + body;
}
@ -3001,7 +2949,6 @@ void G_TimeDemo (const char* name)
nodrawers = !!Args->CheckParm ("-nodraw");
noblit = !!Args->CheckParm ("-noblit");
timingdemo = true;
singletics = true;
defdemoname = name;
gameaction = (gameaction == ga_loadgame) ? ga_loadgameplaydemo : ga_playdemo;
@ -3041,7 +2988,6 @@ bool G_CheckDemoStatus (void)
demoplayback = false;
netgame = false;
multiplayer = false;
singletics = false;
for (int i = 1; i < MAXPLAYERS; i++)
playeringame[i] = 0;
consoleplayer = 0;

18
src/g_level.cpp
View file

@ -1560,13 +1560,28 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, WorldDone)
return 0;
}
//==========================================================================
//
// Started the game loaded into a map from the console. Run at least one tic
// so it can properly render out in net games.
//
//==========================================================================
void G_DoMapWarp()
{
gameaction = ga_nothing;
Net_ResetCommands(true);
Net_SetWaiting();
}
//==========================================================================
//
//
//==========================================================================
void G_DoWorldDone (void)
{
{
Net_ResetCommands(true);
gamestate = GS_LEVEL;
if (nextlevel.IsEmpty())
{
@ -1578,6 +1593,7 @@ void G_DoWorldDone (void)
G_DoLoadLevel (nextlevel, startpos, true, false);
gameaction = ga_nothing;
viewactive = true;
Net_SetWaiting();
}
//==========================================================================

4
src/g_statusbar/sbar.h
View file

@ -413,6 +413,10 @@ public:
return SBarTop;
}
void DoDrawAutomapHUD(int crdefault, int highlight);
void ClearInterpolation()
{
PrevCrosshairSize = CrosshairSize;
}
//protected:
void DrawPowerups ();

25
src/g_statusbar/shared_sbar.cpp
View file

@ -1234,19 +1234,28 @@ void DBaseStatusBar::DrawTopStuff (EHudState state)
}
void DBaseStatusBar::DrawConsistancy () const
void DBaseStatusBar::DrawConsistancy() const
{
if (!netgame)
return;
bool desync = false;
FString text = "Out of sync with:";
for (int i = 0; i < MAXPLAYERS; i++)
for (auto client : NetworkClients)
{
if (playeringame[i] && players[i].inconsistant)
if (players[client].inconsistant)
{
desync = true;
text.AppendFormat(" %s (%d)", players[i].userinfo.GetName(10u), i + 1);
// Fell out of sync with the host in packet server mode. Which specific user it is doesn't really matter.
if (NetMode == NET_PacketServer && consoleplayer != Net_Arbitrator)
{
text.AppendFormat(" %s (%d)", players[Net_Arbitrator].userinfo.GetName(10u), Net_Arbitrator + 1);
break;
}
else
{
text.AppendFormat(" %s (%d)", players[client].userinfo.GetName(10u), client + 1);
}
}
}
@ -1265,19 +1274,19 @@ void DBaseStatusBar::DrawConsistancy () const
}
}
void DBaseStatusBar::DrawWaiting () const
void DBaseStatusBar::DrawWaiting() const
{
if (!netgame)
return;
FString text = "Waiting for:";
bool isWaiting = false;
for (int i = 0; i < MAXPLAYERS; i++)
for (auto client : NetworkClients)
{
if (playeringame[i] && players[i].waiting)
if (players[client].waiting)
{
isWaiting = true;
text.AppendFormat(" %s (%d)", players[i].userinfo.GetName(10u), i + 1);
text.AppendFormat(" %s (%d)", players[client].userinfo.GetName(10u), client + 1);
}
}

209
src/hu_scores.cpp
View file

@ -146,10 +146,17 @@ static int FontScale;
//
//==========================================================================
void HU_DrawScores (player_t *player)
void HU_DrawScores(player_t* player)
{
displayFont = NewSmallFont;
FontScale = max(screen->GetHeight() / 400, 1);
FontScale = max<int>(screen->GetHeight() / 400, 1);
int numPlayers = 0;
for (int i = 0; i < MAXPLAYERS; ++i)
numPlayers += playeringame[i];
if (numPlayers > 8)
FontScale = static_cast<int>(ceil(FontScale * 0.75));
if (deathmatch)
{
@ -158,39 +165,34 @@ void HU_DrawScores (player_t *player)
if (!sb_teamdeathmatch_enable)
return;
}
else
else if (!sb_deathmatch_enable)
{
if (!sb_deathmatch_enable)
return;
return;
}
}
else
else if (!multiplayer || !sb_cooperative_enable)
{
if (!sb_cooperative_enable || !multiplayer)
return;
return;
}
int i, j;
player_t *sortedplayers[MAXPLAYERS];
player_t* sortedPlayers[MAXPLAYERS];
if (player->camera && player->camera->player)
player = player->camera->player;
sortedplayers[MAXPLAYERS-1] = player;
for (i = 0, j = 0; j < MAXPLAYERS - 1; i++, j++)
sortedPlayers[MAXPLAYERS - 1] = player;
for (int i = 0, j = 0; j < MAXPLAYERS - 1; ++i, ++j)
{
if (&players[i] == player)
i++;
sortedplayers[j] = &players[i];
++i;
sortedPlayers[j] = &players[i];
}
if (teamplay && deathmatch)
qsort (sortedplayers, MAXPLAYERS, sizeof(player_t *), compareteams);
qsort(sortedPlayers, MAXPLAYERS, sizeof(player_t*), compareteams);
else
qsort (sortedplayers, MAXPLAYERS, sizeof(player_t *), comparepoints);
HU_DoDrawScores (player, sortedplayers);
qsort(sortedPlayers, MAXPLAYERS, sizeof(player_t*), comparepoints);
HU_DoDrawScores(player, sortedPlayers);
}
//==========================================================================
@ -201,39 +203,37 @@ void HU_DrawScores (player_t *player)
//
//==========================================================================
void HU_GetPlayerWidths(int &maxnamewidth, int &maxscorewidth, int &maxiconheight)
void HU_GetPlayerWidths(int& maxNameWidth, int& maxScoreWidth, int& maxIconHeight)
{
displayFont = NewSmallFont;
maxnamewidth = displayFont->StringWidth("Name");
maxscorewidth = 0;
maxiconheight = 0;
constexpr char NameLabel[] = "Name";
for (int i = 0; i < MAXPLAYERS; i++)
displayFont = NewSmallFont;
maxNameWidth = displayFont->StringWidth(NameLabel);
maxScoreWidth = 0;
maxIconHeight = 0;
for (int i = 0; i < MAXPLAYERS; ++i)
{
if (playeringame[i])
if (!playeringame[i])
continue;
int width = displayFont->StringWidth(players[i].userinfo.GetName(16));
if (width > maxNameWidth)
maxNameWidth = width;
auto icon = FSetTextureID(players[i].mo->IntVar(NAME_ScoreIcon));
if (icon.isValid())
{
int width = displayFont->StringWidth(players[i].userinfo.GetName());
if (width > maxnamewidth)
{
maxnamewidth = width;
}
auto icon = FSetTextureID(players[i].mo->IntVar(NAME_ScoreIcon));
if (icon.isValid())
{
auto pic = TexMan.GetGameTexture(icon);
width = int(pic->GetDisplayWidth() - pic->GetDisplayLeftOffset() + 2.5);
if (width > maxscorewidth)
{
maxscorewidth = width;
}
// The icon's top offset does not count toward its height, because
// zdoom.pk3's standard Hexen class icons are designed that way.
int height = int(pic->GetDisplayHeight() - pic->GetDisplayTopOffset() + 0.5);
if (height > maxiconheight)
{
maxiconheight = height;
}
}
auto pic = TexMan.GetGameTexture(icon);
width = int(pic->GetDisplayWidth() - pic->GetDisplayLeftOffset() + 2.5);
if (width > maxScoreWidth)
maxScoreWidth = width;
// The icon's top offset does not count toward its height, because
// zdoom.pk3's standard Hexen class icons are designed that way.
int height = int(pic->GetDisplayHeight() - pic->GetDisplayTopOffset() + 0.5);
if (height > maxIconHeight)
maxIconHeight = height;
}
}
}
@ -249,16 +249,9 @@ static void HU_DrawFontScaled(double x, double y, int color, const char *text)
DrawText(twod, displayFont, color, x / FontScale, y / FontScale, text, DTA_VirtualWidth, twod->GetWidth() / FontScale, DTA_VirtualHeight, twod->GetHeight() / FontScale, TAG_END);
}
static void HU_DoDrawScores (player_t *player, player_t *sortedplayers[MAXPLAYERS])
static void HU_DoDrawScores(player_t* player, player_t* sortedPlayers[MAXPLAYERS])
{
int color;
int height, lineheight;
unsigned int i;
int maxnamewidth, maxscorewidth, maxiconheight;
int numTeams = 0;
int x, y, ypadding, bottom;
int col2, col3, col4, col5;
int color = sb_cooperative_headingcolor;
if (deathmatch)
{
if (teamplay)
@ -266,86 +259,77 @@ static void HU_DoDrawScores (player_t *player, player_t *sortedplayers[MAXPLAYER
else
color = sb_deathmatch_headingcolor;
}
else
{
color = sb_cooperative_headingcolor;
}
HU_GetPlayerWidths(maxnamewidth, maxscorewidth, maxiconheight);
height = displayFont->GetHeight() * FontScale;
lineheight = max(height, maxiconheight * CleanYfac);
ypadding = (lineheight - height + 1) / 2;
int maxNameWidth, maxScoreWidth, maxIconHeight;
HU_GetPlayerWidths(maxNameWidth, maxScoreWidth, maxIconHeight);
int height = displayFont->GetHeight() * FontScale;
int lineHeight = max<int>(height, maxIconHeight * CleanYfac);
int yPadding = (lineHeight - height + 1) / 2;
bottom = StatusBar->GetTopOfStatusbar();
y = max(48*CleanYfac, (bottom - MAXPLAYERS * (height + CleanYfac + 1)) / 2);
int bottom = StatusBar->GetTopOfStatusbar();
int y = max<int>(48 * CleanYfac, (bottom - MAXPLAYERS * (height + CleanYfac + 1)) / 2);
HU_DrawTimeRemaining (bottom - height);
HU_DrawTimeRemaining(bottom - height);
if (teamplay && deathmatch)
{
y -= (BigFont->GetHeight() + 8) * CleanYfac;
for (i = 0; i < Teams.Size (); i++)
for (size_t i = 0u; i < Teams.Size(); ++i)
{
Teams[i].m_iPlayerCount = 0;
Teams[i].m_iScore = 0;
}
for (i = 0; i < MAXPLAYERS; ++i)
int numTeams = 0;
for (int i = 0; i < MAXPLAYERS; ++i)
{
if (playeringame[sortedplayers[i]-players] && FTeam::IsValid (sortedplayers[i]->userinfo.GetTeam()))
if (playeringame[sortedPlayers[i]-players] && FTeam::IsValid(sortedPlayers[i]->userinfo.GetTeam()))
{
if (Teams[sortedplayers[i]->userinfo.GetTeam()].m_iPlayerCount++ == 0)
{
numTeams++;
}
if (Teams[sortedPlayers[i]->userinfo.GetTeam()].m_iPlayerCount++ == 0)
++numTeams;
Teams[sortedplayers[i]->userinfo.GetTeam()].m_iScore += sortedplayers[i]->fragcount;
Teams[sortedPlayers[i]->userinfo.GetTeam()].m_iScore += sortedPlayers[i]->fragcount;
}
}
int scorexwidth = twod->GetWidth() / max(8, numTeams);
int numscores = 0;
int scorex;
for (i = 0; i < Teams.Size(); ++i)
int scoreXWidth = twod->GetWidth() / max<int>(8, numTeams);
int numScores = 0;
for (size_t i = 0u; i < Teams.Size(); ++i)
{
if (Teams[i].m_iPlayerCount)
{
numscores++;
}
++numScores;
}
scorex = (twod->GetWidth() - scorexwidth * (numscores - 1)) / 2;
for (i = 0; i < Teams.Size(); ++i)
int scoreX = (twod->GetWidth() - scoreXWidth * (numScores - 1)) / 2;
for (size_t i = 0u; i < Teams.Size(); ++i)
{
if (Teams[i].m_iPlayerCount)
{
char score[80];
mysnprintf (score, countof(score), "%d", Teams[i].m_iScore);
if (!Teams[i].m_iPlayerCount)
continue;
DrawText(twod, BigFont, Teams[i].GetTextColor(),
scorex - BigFont->StringWidth(score)*CleanXfac/2, y, score,
DTA_CleanNoMove, true, TAG_DONE);
char score[80];
mysnprintf(score, countof(score), "%d", Teams[i].m_iScore);
scorex += scorexwidth;
}
DrawText(twod, BigFont, Teams[i].GetTextColor(),
scoreX - BigFont->StringWidth(score)*CleanXfac/2, y, score,
DTA_CleanNoMove, true, TAG_DONE);
scoreX += scoreXWidth;
}
y += (BigFont->GetHeight() + 8) * CleanYfac;
}
const char *text_color = GStrings.GetString("SCORE_COLOR"),
const char* text_color = GStrings.GetString("SCORE_COLOR"),
*text_frags = GStrings.GetString(deathmatch ? "SCORE_FRAGS" : "SCORE_KILLS"),
*text_name = GStrings.GetString("SCORE_NAME"),
*text_delay = GStrings.GetString("SCORE_DELAY");
col2 = (displayFont->StringWidth(text_color) + 16) * FontScale;
col3 = col2 + (displayFont->StringWidth(text_frags) + 16) * FontScale;
col4 = col3 + maxscorewidth * FontScale;
col5 = col4 + (maxnamewidth + 16) * FontScale;
x = (twod->GetWidth() >> 1) - (((displayFont->StringWidth(text_delay) * FontScale) + col5) >> 1);
int col2 = (displayFont->StringWidth(text_color) + 16) * FontScale;
int col3 = col2 + (displayFont->StringWidth(text_frags) + 16) * FontScale;
int col4 = col3 + maxScoreWidth * FontScale;
int col5 = col4 + (maxNameWidth + 16) * FontScale;
int x = (twod->GetWidth() >> 1) - (((displayFont->StringWidth(text_delay) * FontScale) + col5) >> 1);
//HU_DrawFontScaled(x, y, color, text_color);
HU_DrawFontScaled(x + col2, y, color, text_frags);
@ -355,13 +339,13 @@ static void HU_DoDrawScores (player_t *player, player_t *sortedplayers[MAXPLAYER
y += height + 6 * CleanYfac;
bottom -= height;
for (i = 0; i < MAXPLAYERS && y <= bottom; i++)
for (int i = 0; i < MAXPLAYERS && y <= bottom; ++i)
{
if (playeringame[sortedplayers[i] - players])
{
HU_DrawPlayer(sortedplayers[i], player == sortedplayers[i], x, col2, col3, col4, col5, maxnamewidth, y, ypadding, lineheight);
y += lineheight + CleanYfac;
}
if (!playeringame[sortedPlayers[i] - players])
continue;
HU_DrawPlayer(sortedPlayers[i], player == sortedPlayers[i], x, col2, col3, col4, col5, maxNameWidth, y, yPadding, lineHeight);
y += lineHeight + CleanYfac;
}
}
@ -437,14 +421,7 @@ static void HU_DrawPlayer (player_t *player, bool highlight, int col1, int col2,
HU_DrawFontScaled(col4, y + ypadding, color, player->userinfo.GetName());
int avgdelay = 0;
for (int i = 0; i < BACKUPTICS; i++)
{
avgdelay += netdelay[nodeforplayer[(int)(player - players)]][i];
}
avgdelay /= BACKUPTICS;
mysnprintf(str, countof(str), "%d", (avgdelay * ticdup) * (1000 / TICRATE));
mysnprintf(str, countof(str), "%u", ClientStates[player - players].AverageLatency);
HU_DrawFontScaled(col5, y + ypadding, color, str);

4
src/hu_stuff.h
View file

@ -42,8 +42,8 @@ void CT_Drawer (void);
// [RH] Draw deathmatch scores
void HU_DrawScores (player_t *me);
void HU_GetPlayerWidths(int &maxnamewidth, int &maxscorewidth, int &maxiconheight);
void HU_DrawScores(player_t* me);
void HU_GetPlayerWidths(int& maxNameWidth, int& maxScoreWidth, int& maxIconHeight);
void HU_DrawColorBar(int x, int y, int height, int playernum);
int HU_GetRowColor(player_t *player, bool hightlight);

35
src/p_tick.cpp
View file

@ -72,6 +72,41 @@ bool P_CheckTickerPaused ()
return false;
}
void P_ClearLevelInterpolation()
{
for (auto Level : AllLevels())
{
Level->interpolator.UpdateInterpolations();
auto it = Level->GetThinkerIterator<AActor>();
AActor* ac;
while ((ac = it.Next()))
{
ac->ClearInterpolation();
ac->ClearFOVInterpolation();
}
}
for (int i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
{
DPSprite* pspr = players[i].psprites;
while (pspr)
{
pspr->ResetInterpolation();
pspr = pspr->Next;
}
}
}
R_ClearInterpolationPath();
if (StatusBar != nullptr)
StatusBar->ClearInterpolation();
}
//
// P_Ticker
//

18
src/playsim/bots/b_bot.h
View file

@ -130,12 +130,12 @@ public:
void FinishTravel ();
bool IsLeader (player_t *player);
void SetBodyAt (FLevelLocals *Level, const DVector3 &pos, int hostnum);
double FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd);
double FakeFire (AActor *source, AActor *dest, usercmd_t *cmd);
bool SafeCheckPosition (AActor *actor, double x, double y, FCheckPosition &tm);
void BotTick(AActor *mo);
//(b_move.cpp)
bool CleanAhead (AActor *thing, double x, double y, ticcmd_t *cmd);
bool CleanAhead (AActor *thing, double x, double y, usercmd_t *cmd);
bool IsDangerous (sector_t *sec);
TArray<FString> getspawned; //Array of bots (their names) which should be spawned when starting a game.
@ -216,21 +216,21 @@ public:
private:
//(b_think.cpp)
void Think ();
void ThinkForMove (ticcmd_t *cmd);
void ThinkForMove (usercmd_t *cmd);
void Set_enemy ();
//(b_func.cpp)
bool Reachable (AActor *target);
void Dofire (ticcmd_t *cmd);
void Dofire (usercmd_t *cmd);
AActor *Choose_Mate ();
AActor *Find_enemy ();
DAngle FireRox (AActor *enemy, ticcmd_t *cmd);
DAngle FireRox (AActor *enemy, usercmd_t *cmd);
//(b_move.cpp)
void Roam (ticcmd_t *cmd);
bool Move (ticcmd_t *cmd);
bool TryWalk (ticcmd_t *cmd);
void NewChaseDir (ticcmd_t *cmd);
void Roam (usercmd_t *cmd);
bool Move (usercmd_t *cmd);
bool TryWalk (usercmd_t *cmd);
void NewChaseDir (usercmd_t *cmd);
void TurnToAng ();
void Pitch (AActor *target);
};

8
src/playsim/bots/b_func.cpp
View file

@ -164,7 +164,7 @@ bool DBot::Check_LOS (AActor *to, DAngle vangle)
//-------------------------------------
//The bot will check if it's time to fire
//and do so if that is the case.
void DBot::Dofire (ticcmd_t *cmd)
void DBot::Dofire (usercmd_t *cmd)
{
bool no_fire; //used to prevent bot from pumping rockets into nearby walls.
int aiming_penalty=0; //For shooting at shading target, if screen is red, MAKEME: When screen red.
@ -276,7 +276,7 @@ void DBot::Dofire (ticcmd_t *cmd)
}
if (!no_fire) //If going to fire weapon
{
cmd->ucmd.buttons |= BT_ATTACK;
cmd->buttons |= BT_ATTACK;
}
//Prevents bot from jerking, when firing automatic things with low skill.
}
@ -503,7 +503,7 @@ void FCajunMaster::SetBodyAt (FLevelLocals *Level, const DVector3 &pos, int host
//Emulates missile travel. Returns distance travelled.
double FCajunMaster::FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd)
double FCajunMaster::FakeFire (AActor *source, AActor *dest, usercmd_t *cmd)
{
AActor *th = Spawn (source->Level, "CajunTrace", source->PosPlusZ(4*8.), NO_REPLACE);
@ -525,7 +525,7 @@ double FCajunMaster::FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd)
return dist;
}
DAngle DBot::FireRox (AActor *enemy, ticcmd_t *cmd)
DAngle DBot::FireRox (AActor *enemy, usercmd_t *cmd)
{
double dist;
AActor *actor;

18
src/playsim/bots/b_move.cpp
View file

@ -63,7 +63,7 @@ extern dirtype_t diags[4];
//Called while the bot moves after its dest mobj
//which can be a weapon/enemy/item whatever.
void DBot::Roam (ticcmd_t *cmd)
void DBot::Roam (usercmd_t *cmd)
{
if (Reachable(dest))
@ -89,7 +89,7 @@ void DBot::Roam (ticcmd_t *cmd)
}
}
bool DBot::Move (ticcmd_t *cmd)
bool DBot::Move (usercmd_t *cmd)
{
double tryx, tryy;
bool try_ok;
@ -136,20 +136,20 @@ bool DBot::Move (ticcmd_t *cmd)
}
if (good && ((pr_botopendoor() >= 203) ^ (good & 1)))
{
cmd->ucmd.buttons |= BT_USE;
cmd->ucmd.forwardmove = FORWARDRUN;
cmd->buttons |= BT_USE;
cmd->forwardmove = FORWARDRUN;
return true;
}
else
return false;
}
else //Move forward.
cmd->ucmd.forwardmove = FORWARDRUN;
cmd->forwardmove = FORWARDRUN;
return true;
}
bool DBot::TryWalk (ticcmd_t *cmd)
bool DBot::TryWalk (usercmd_t *cmd)
{
if (!Move (cmd))
return false;
@ -158,7 +158,7 @@ bool DBot::TryWalk (ticcmd_t *cmd)
return true;
}
void DBot::NewChaseDir (ticcmd_t *cmd)
void DBot::NewChaseDir (usercmd_t *cmd)
{
dirtype_t d[3];
@ -290,7 +290,7 @@ void DBot::NewChaseDir (ticcmd_t *cmd)
// This is also a traverse function for
// bots pre-rocket fire (preventing suicide)
//
bool FCajunMaster::CleanAhead (AActor *thing, double x, double y, ticcmd_t *cmd)
bool FCajunMaster::CleanAhead (AActor *thing, double x, double y, usercmd_t *cmd)
{
FCheckPosition tm;
@ -310,7 +310,7 @@ bool FCajunMaster::CleanAhead (AActor *thing, double x, double y, ticcmd_t *cmd)
//Jumpable
if(tm.floorz > (thing->Sector->floorplane.ZatPoint(x, y)+thing->MaxStepHeight))
cmd->ucmd.buttons |= BT_JUMP;
cmd->buttons |= BT_JUMP;
if ( !(thing->flags & MF_TELEPORT) &&

37
src/playsim/bots/b_think.cpp
View file

@ -58,7 +58,7 @@ static FRandom pr_botmove ("BotMove");
//so this is what the bot does.
void DBot::Think ()
{
ticcmd_t *cmd = &netcmds[player - players][((gametic + 1)/ticdup)%BACKUPTICS];
usercmd_t *cmd = &player->cmd;
memset (cmd, 0, sizeof(*cmd));
@ -78,13 +78,12 @@ void DBot::Think ()
ThinkForMove (cmd);
TurnToAng ();
cmd->ucmd.yaw = (short)((actor->Angles.Yaw - oldyaw).Degrees() * (65536 / 360.f)) / ticdup;
cmd->ucmd.pitch = (short)((oldpitch - actor->Angles.Pitch).Degrees() * (65536 / 360.f));
if (cmd->ucmd.pitch == -32768)
cmd->ucmd.pitch = -32767;
cmd->ucmd.pitch /= ticdup;
actor->Angles.Yaw = oldyaw + DAngle::fromDeg(cmd->ucmd.yaw * ticdup * (360 / 65536.f));
actor->Angles.Pitch = oldpitch - DAngle::fromDeg(cmd->ucmd.pitch * ticdup * (360 / 65536.f));
cmd->yaw = (short)((actor->Angles.Yaw - oldyaw).Degrees() * (65536 / 360.f));
cmd->pitch = (short)((oldpitch - actor->Angles.Pitch).Degrees() * (65536 / 360.f));
if (cmd->pitch == -32768)
cmd->pitch = -32767;
actor->Angles.Yaw = oldyaw + DAngle::fromDeg(cmd->yaw * (360 / 65536.f));
actor->Angles.Pitch = oldpitch - DAngle::fromDeg(cmd->pitch * (360 / 65536.f));
}
if (t_active) t_active--;
@ -101,14 +100,14 @@ void DBot::Think ()
}
else if (player->mo->health <= 0)
{ // Time to respawn
cmd->ucmd.buttons |= BT_USE;
cmd->buttons |= BT_USE;
}
}
#define THINKDISTSQ (50000.*50000./(65536.*65536.))
//how the bot moves.
//MAIN movement function.
void DBot::ThinkForMove (ticcmd_t *cmd)
void DBot::ThinkForMove (usercmd_t *cmd)
{
double dist;
bool stuck;
@ -136,8 +135,8 @@ void DBot::ThinkForMove (ticcmd_t *cmd)
{
Pitch (missile);
Angle = player->mo->AngleTo(missile);
cmd->ucmd.sidemove = sleft ? -SIDERUN : SIDERUN;
cmd->ucmd.forwardmove = -FORWARDRUN; //Back IS best.
cmd->sidemove = sleft ? -SIDERUN : SIDERUN;
cmd->forwardmove = -FORWARDRUN; //Back IS best.
if ((player->mo->Pos() - old).LengthSquared() < THINKDISTSQ
&& t_strafe<=0)
@ -208,22 +207,22 @@ void DBot::ThinkForMove (ticcmd_t *cmd)
GetBotInfo(player->ReadyWeapon).MoveCombatDist)
{
// If a monster, use lower speed (just for cooler apperance while strafing down doomed monster)
cmd->ucmd.forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? FORWARDWALK : FORWARDRUN;
cmd->forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? FORWARDWALK : FORWARDRUN;
}
else if (!stuck) //Too close, so move away.
{
// If a monster, use lower speed (just for cooler apperance while strafing down doomed monster)
cmd->ucmd.forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? -FORWARDWALK : -FORWARDRUN;
cmd->forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? -FORWARDWALK : -FORWARDRUN;
}
//Strafing.
if (enemy->flags3 & MF3_ISMONSTER) //It's just a monster so take it down cool.
{
cmd->ucmd.sidemove = sleft ? -SIDEWALK : SIDEWALK;
cmd->sidemove = sleft ? -SIDEWALK : SIDEWALK;
}
else
{
cmd->ucmd.sidemove = sleft ? -SIDERUN : SIDERUN;
cmd->sidemove = sleft ? -SIDERUN : SIDERUN;
}
Dofire (cmd); //Order bot to fire current weapon
}
@ -246,11 +245,11 @@ void DBot::ThinkForMove (ticcmd_t *cmd)
matedist = player->mo->Distance2D(mate);
if (matedist > (FRIEND_DIST*2))
cmd->ucmd.forwardmove = FORWARDRUN;
cmd->forwardmove = FORWARDRUN;
else if (matedist > FRIEND_DIST)
cmd->ucmd.forwardmove = FORWARDWALK; //Walk, when starting to get close.
cmd->forwardmove = FORWARDWALK; //Walk, when starting to get close.
else if (matedist < FRIEND_DIST-(FRIEND_DIST/3)) //Got too close, so move away.
cmd->ucmd.forwardmove = -FORWARDWALK;
cmd->forwardmove = -FORWARDWALK;
}
else //Roam after something.
{

2
src/playsim/d_player.h
View file

@ -321,7 +321,7 @@ public:
AActor *mo = nullptr;
uint8_t playerstate = 0;
ticcmd_t cmd = {};
usercmd_t cmd = {};
usercmd_t original_cmd = {};
uint32_t original_oldbuttons = 0;

10
src/playsim/p_mobj.cpp
View file

@ -2572,7 +2572,7 @@ static double P_XYMovement (AActor *mo, DVector2 scroll)
{ // slide against wall
if (BlockingLine != NULL &&
mo->player && mo->waterlevel && mo->waterlevel < 3 &&
(mo->player->cmd.ucmd.forwardmove | mo->player->cmd.ucmd.sidemove) &&
(mo->player->cmd.forwardmove | mo->player->cmd.sidemove) &&
mo->BlockingLine->sidedef[1] != NULL)
{
double spd = mo->FloatVar(NAME_WaterClimbSpeed);
@ -2811,7 +2811,7 @@ static double P_XYMovement (AActor *mo, DVector2 scroll)
// moving corresponding player:
if (fabs(mo->Vel.X) < STOPSPEED && fabs(mo->Vel.Y) < STOPSPEED
&& (!player || (player->mo != mo)
|| !(player->cmd.ucmd.forwardmove | player->cmd.ucmd.sidemove)))
|| !(player->cmd.forwardmove | player->cmd.sidemove)))
{
// if in a walking frame, stop moving
// killough 10/98:
@ -3273,7 +3273,7 @@ void AActor::FallAndSink(double grav, double oldfloorz)
double startvelz = Vel.Z;
if (waterlevel == 0 || (player &&
!(player->cmd.ucmd.forwardmove | player->cmd.ucmd.sidemove)))
!(player->cmd.forwardmove | player->cmd.sidemove)))
{
// [RH] Double gravity only if running off a ledge. Coming down from
// an upward thrust (e.g. a jump) should not double it.
@ -6101,7 +6101,7 @@ AActor *FLevelLocals::SpawnPlayer (FPlayerStart *mthing, int playernum, int flag
p->cheats = CF_CHASECAM;
// setup gun psprite
if (!(flags & SPF_TEMPPLAYER))
if (!(flags & SPF_TEMPPLAYER) || oldactor == nullptr)
{ // This can also start a script so don't do it for the dummy player.
P_SetupPsprites (p, !!(flags & SPF_WEAPONFULLYUP));
}
@ -6156,7 +6156,7 @@ AActor *FLevelLocals::SpawnPlayer (FPlayerStart *mthing, int playernum, int flag
}
// [BC] Do script stuff
if (!(flags & SPF_TEMPPLAYER))
if (!(flags & SPF_TEMPPLAYER) || oldactor == nullptr)
{
if (state == PST_ENTER || (state == PST_LIVE && !savegamerestore))
{

2
src/playsim/p_pspr.cpp
View file

@ -715,7 +715,7 @@ static void P_CheckWeaponButtons (player_t *player)
for (size_t i = 0; i < countof(ButtonChecks); ++i)
{
if ((player->WeaponState & ButtonChecks[i].StateFlag) &&
(player->cmd.ucmd.buttons & ButtonChecks[i].ButtonFlag))
(player->cmd.buttons & ButtonChecks[i].ButtonFlag))
{
FState *state = weapon->FindState(ButtonChecks[i].StateName);
// [XA] don't change state if still null, so if the modder

14
src/playsim/p_things.cpp
View file

@ -561,13 +561,13 @@ int P_Thing_CheckInputNum(player_t *p, int inputnum)
case INPUT_UPMOVE: renum = p->original_cmd.upmove; break;
case MODINPUT_OLDBUTTONS: renum = p->oldbuttons; break;
case MODINPUT_BUTTONS: renum = p->cmd.ucmd.buttons; break;
case MODINPUT_PITCH: renum = p->cmd.ucmd.pitch; break;
case MODINPUT_YAW: renum = p->cmd.ucmd.yaw; break;
case MODINPUT_ROLL: renum = p->cmd.ucmd.roll; break;
case MODINPUT_FORWARDMOVE: renum = p->cmd.ucmd.forwardmove; break;
case MODINPUT_SIDEMOVE: renum = p->cmd.ucmd.sidemove; break;
case MODINPUT_UPMOVE: renum = p->cmd.ucmd.upmove; break;
case MODINPUT_BUTTONS: renum = p->cmd.buttons; break;
case MODINPUT_PITCH: renum = p->cmd.pitch; break;
case MODINPUT_YAW: renum = p->cmd.yaw; break;
case MODINPUT_ROLL: renum = p->cmd.roll; break;
case MODINPUT_FORWARDMOVE: renum = p->cmd.forwardmove; break;
case MODINPUT_SIDEMOVE: renum = p->cmd.sidemove; break;
case MODINPUT_UPMOVE: renum = p->cmd.upmove; break;
default: renum = 0; break;
}

34
src/playsim/p_user.cpp
View file

@ -95,6 +95,8 @@
#include "s_music.h"
#include "d_main.h"
extern int paused;
static FRandom pr_skullpop ("SkullPop");
// [SP] Allows respawn in single player
@ -1236,7 +1238,7 @@ DEFINE_ACTION_FUNCTION(APlayerPawn, CheckEnvironment)
void P_CheckUse(player_t *player)
{
// check for use
if (player->cmd.ucmd.buttons & BT_USE)
if (player->cmd.buttons & BT_USE)
{
if (!player->usedown)
{
@ -1269,7 +1271,7 @@ DEFINE_ACTION_FUNCTION(APlayerPawn, CheckUse)
void P_PlayerThink (player_t *player)
{
ticcmd_t *cmd = &player->cmd;
usercmd_t *cmd = &player->cmd;
if (player->mo == NULL)
{
@ -1309,14 +1311,14 @@ void P_PlayerThink (player_t *player)
{
fprintf (debugfile, "tic %d for pl %d: (%f, %f, %f, %f) b:%02x p:%d y:%d f:%d s:%d u:%d\n",
gametic, (int)(player-players), player->mo->X(), player->mo->Y(), player->mo->Z(),
player->mo->Angles.Yaw.Degrees(), player->cmd.ucmd.buttons,
player->cmd.ucmd.pitch, player->cmd.ucmd.yaw, player->cmd.ucmd.forwardmove,
player->cmd.ucmd.sidemove, player->cmd.ucmd.upmove);
player->mo->Angles.Yaw.Degrees(), player->cmd.buttons,
player->cmd.pitch, player->cmd.yaw, player->cmd.forwardmove,
player->cmd.sidemove, player->cmd.upmove);
}
// Make unmodified copies for ACS's GetPlayerInput.
player->original_oldbuttons = player->original_cmd.buttons;
player->original_cmd = cmd->ucmd;
player->original_cmd = *cmd;
// Don't interpolate the view for more than one tic
player->cheats &= ~CF_INTERPVIEW;
player->cheats &= ~CF_INTERPVIEWANGLES;
@ -1453,8 +1455,7 @@ void P_PredictPlayer (player_t *player)
{
int maxtic;
if (singletics ||
demoplayback ||
if (demoplayback ||
player->mo == NULL ||
player != player->mo->Level->GetConsolePlayer() ||
player->playerstate != PST_LIVE ||
@ -1465,7 +1466,7 @@ void P_PredictPlayer (player_t *player)
return;
}
maxtic = maketic;
maxtic = ClientTic;
if (gametic == maxtic)
{
@ -1557,8 +1558,11 @@ void P_PredictPlayer (player_t *player)
}
}
player->oldbuttons = player->cmd.ucmd.buttons;
player->cmd = localcmds[i % LOCALCMDTICS];
player->oldbuttons = player->cmd.buttons;
player->cmd = LocalCmds[i % LOCALCMDTICS];
if (paused)
continue;
player->mo->ClearInterpolation();
player->mo->ClearFOVInterpolation();
P_PlayerThink(player);
@ -1591,6 +1595,10 @@ void P_PredictPlayer (player_t *player)
player->viewz = snapPos.Z + zOfs;
}
}
else if (paused)
{
r_NoInterpolate = true;
}
// This is intentionally done after rubberbanding starts since it'll automatically smooth itself towards
// the right spot until it reaches it.
@ -1900,11 +1908,11 @@ DEFINE_FIELD_X(PlayerInfo, player_t, ConversationNPC)
DEFINE_FIELD_X(PlayerInfo, player_t, ConversationPC)
DEFINE_FIELD_X(PlayerInfo, player_t, ConversationNPCAngle)
DEFINE_FIELD_X(PlayerInfo, player_t, ConversationFaceTalker)
DEFINE_FIELD_NAMED_X(PlayerInfo, player_t, cmd.ucmd, cmd)
DEFINE_FIELD_NAMED_X(PlayerInfo, player_t, cmd, cmd)
DEFINE_FIELD_X(PlayerInfo, player_t, original_cmd)
DEFINE_FIELD_X(PlayerInfo, player_t, userinfo)
DEFINE_FIELD_X(PlayerInfo, player_t, weapons)
DEFINE_FIELD_NAMED_X(PlayerInfo, player_t, cmd.ucmd.buttons, buttons)
DEFINE_FIELD_NAMED_X(PlayerInfo, player_t, cmd.buttons, buttons)
DEFINE_FIELD_X(PlayerInfo, player_t, SoundClass)
DEFINE_FIELD_X(UserCmd, usercmd_t, buttons)

2
src/serializer_doom.h
View file

@ -8,7 +8,6 @@ struct sector_t;
struct line_t;
struct side_t;
struct vertex_t;
struct ticcmd_t;
struct usercmd_t;
class PClassActor;
struct FStrifeDialogueNode;
@ -40,7 +39,6 @@ FSerializer &SerializeArgs(FSerializer &arc, const char *key, int *args, int *de
FSerializer &SerializeTerrain(FSerializer &arc, const char *key, int &terrain, int *def = nullptr);
FSerializer& Serialize(FSerializer& arc, const char* key, char& value, char* defval);
FSerializer &Serialize(FSerializer &arc, const char *key, ticcmd_t &sid, ticcmd_t *def);
FSerializer &Serialize(FSerializer &arc, const char *key, usercmd_t &cmd, usercmd_t *def);
FSerializer &Serialize(FSerializer &arc, const char *key, FInterpolator &rs, FInterpolator *def);
FSerializer& Serialize(FSerializer& arc, const char* key, struct FStandaloneAnimation& value, struct FStandaloneAnimation* defval);

5
src/version.h
View file

@ -57,11 +57,6 @@ const char *GetVersionString();
#define ENG_MINOR 15
#define ENG_REVISION 1
// Version identifier for network games.
// Bump it every time you do a release unless you're certain you
// didn't change anything that will affect sync.
#define NETGAMEVERSION 235
// Version stored in the ini's [LastRun] section.
// Bump it if you made some configuration change that you want to
// be able to migrate in FGameConfigFile::DoGlobalSetup().

18
wadsrc/static/menudef.txt
View file

@ -654,6 +654,8 @@ OptionMenu "OtherControlsMenu" protected
StaticText ""
Control "$CNTRLMNU_CHASECAM" , "chase"
Control "$CNTRLMNU_COOPSPY" , "spynext"
Control "$CNTRLMNU_COOPSPYPREV" , "spyprev"
Control "$CNTRLMNU_COOPSPYCANCEL" , "spycancel"
StaticText ""
Control "$CNTRLMNU_SCREENSHOT" , "screenshot"
@ -2378,21 +2380,25 @@ OptionMenu NetworkOptions protected
{
Title "$NETMNU_TITLE"
StaticText "$NETMNU_LOCALOPTIONS", 1
Option "$NETMNU_CHATTYPE", "cl_showchat", "ChatTypes"
Option "$NETMNU_NOBOLDCHAT", "cl_noboldchat", "OnOff"
Option "$NETMNU_NOCHATSND", "cl_nochatsound", "OnOff"
Option "$NETMNU_LINESPECIALPREDICTION", "cl_predict_specials", "OnOff"
Slider "$NETMNU_PREDICTIONLERPSCALE", "cl_rubberband_scale", 0.0, 1.0, 0.05, 2
Slider "$NETMNU_LERPTHRESHOLD", "cl_rubberband_threshold", 0.0, 256.0, 8.0
StaticText " "
StaticText "$NETMNU_HOSTOPTIONS", 1
Option "$NETMNU_EXTRATICS", "net_extratic", "ExtraTicMode"
Option "$NETMNU_TICBALANCE", "net_ticbalance", "OnOff"
Option "$NETMNU_EXTRATICS", "net_extratic", "OnOff"
Option "$NETMNU_DISABLEPAUSE", "net_disablepause", "OnOff"
NumberField "$NETMNU_CHATSLOMO", "net_chatslowmode", 0, 300, 5
}
OptionValue ExtraTicMode
OptionValue "ChatTypes"
{
0, "$OPTVAL_NONE"
1, "1"
2, "$OPTVAL_ALLUNACKNOWLEDGED"
0, "$OPTVAL_DISABLECHAT"
1, "$OPTVAL_TEAMONLYCHAT"
2, "$OPTVAL_GLOBALCHAT"
}
OptionValue "LookupOrder"

8
wadsrc/static/zscript/actors/player/player.zs
View file

@ -18,6 +18,7 @@ class PlayerPawn : Actor
// 16 pixels of bob
const MAXBOB = 16.;
int BobTimer; // Use a local timer for this so it can be predicted correctly.
int crouchsprite;
int MaxHealth;
int BonusHealth;
@ -633,7 +634,7 @@ class PlayerPawn : Actor
{
if (player.health > 0)
{
angle = Level.maptime / (120 * TICRATE / 35.) * 360.;
angle = BobTimer / (120 * TICRATE / 35.) * 360.;
bob = player.GetStillBob() * sin(angle);
}
else
@ -643,7 +644,7 @@ class PlayerPawn : Actor
}
else
{
angle = Level.maptime / (ViewBobSpeed * TICRATE / 35.) * 360.;
angle = BobTimer / (ViewBobSpeed * TICRATE / 35.) * 360.;
bob = player.bob * sin(angle) * (waterlevel > 1 ? 0.25f : 0.5f);
}
@ -1667,6 +1668,7 @@ class PlayerPawn : Actor
PlayerFlags |= PF_VOODOO_ZOMBIE;
}
++BobTimer;
CheckFOV();
if (player.inventorytics)
@ -2545,7 +2547,7 @@ class PlayerPawn : Actor
for (int i = 0; i < 2; i++)
{
// Bob the weapon based on movement speed. ([SP] And user's bob speed setting)
double angle = (BobSpeed * player.GetWBobSpeed() * 35 / TICRATE*(Level.maptime - 1 + i)) * (360. / 8192.);
double angle = (BobSpeed * player.GetWBobSpeed() * 35 / TICRATE*(BobTimer - 1 + i)) * (360. / 8192.);
// [RH] Smooth transitions between bobbing and not-bobbing frames.
// This also fixes the bug where you can "stick" a weapon off-center by

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

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