void NetworkReadEndLevelPacket (ubyte *dataP)
{
// Special packet for end of level syncing
int nPlayer;
tEndLevelInfo *end = reinterpret_cast<tEndLevelInfo*> (dataP);
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
int i, j;
for (i = 0; i < MAX_PLAYERS; i++)
for (j = 0; j < MAX_PLAYERS; j++)
end->killMatrix [i][j] = INTEL_SHORT (end->killMatrix [i][j]);
end->kills = INTEL_SHORT (end->kills);
end->killed = INTEL_SHORT (end->killed);
#endif
nPlayer = end->nPlayer;
Assert (nPlayer != gameData.multiplayer.nLocalPlayer);
if (nPlayer>=gameData.multiplayer.nPlayers) {
Int3 (); // weird, but it an happen in a coop restore game
return; // if it happens in a coop restore, don't worry about it
}
if ((networkData.nStatus == NETSTAT_PLAYING) && (end->connected != 0))
return; // Only accept disconnect packets if we're not out of the level yet
gameData.multiplayer.players [nPlayer].connected = end->connected;
memcpy (&gameData.multigame.kills.matrix [nPlayer][0], end->killMatrix, MAX_PLAYERS*sizeof (short));
gameData.multiplayer.players [nPlayer].netKillsTotal = end->kills;
gameData.multiplayer.players [nPlayer].netKilledTotal = end->killed;
if ((gameData.multiplayer.players [nPlayer].connected == 1) && (end->seconds_left < gameData.reactor.countdown.nSecsLeft))
gameData.reactor.countdown.nSecsLeft = end->seconds_left;
ResetPlayerTimeout (nPlayer, -1);
}
void ResetAllPlayerTimeouts (void)
{
int i;
for (i = 0; i < gameData.multiplayer.nPlayers; i++)
ResetPlayerTimeout (i, -1);
}
void NetworkSendRejoinSync (int nPlayer)
{
int i, j;
gameData.multiplayer.players [nPlayer].connected = 1; // connect the new guy
ResetPlayerTimeout (nPlayer, -1);
if (gameStates.app.bEndLevelSequence || gameData.reactor.bDestroyed) {
// Endlevel started before we finished sending the goods, we'll
// have to stop and try again after the level.
if (gameStates.multi.nGameType >= IPX_GAME)
NetworkDumpPlayer (
networkData.playerRejoining.player.network.ipx.server,
networkData.playerRejoining.player.network.ipx.node,
DUMP_ENDLEVEL);
networkData.nSyncState = 0;
networkData.nSyncExtras = 0;
return;
}
if (networkData.bPlayerAdded) {
networkData.playerRejoining.nType = PID_ADDPLAYER;
networkData.playerRejoining.player.connected = nPlayer;
NetworkNewPlayer (&networkData.playerRejoining);
for (i = 0; i < gameData.multiplayer.nPlayers; i++) {
if ((i != nPlayer) &&
(i != gameData.multiplayer.nLocalPlayer) &&
(gameData.multiplayer.players [i].connected))
if (gameStates.multi.nGameType >= IPX_GAME) {
SendSequencePacket (
networkData.playerRejoining,
netPlayers.players [i].network.ipx.server,
netPlayers.players [i].network.ipx.node,
gameData.multiplayer.players [i].netAddress);
}
}
}
// Send sync packet to the new guy
NetworkUpdateNetGame ();
// Fill in the kill list
for (j = 0; j < MAX_PLAYERS; j++) {
for (i = 0; i < MAX_PLAYERS; i++)
netGame.kills [j][i] = gameData.multigame.kills.matrix [j][i];
netGame.killed [j] = gameData.multiplayer.players [j].netKilledTotal;
netGame.playerKills [j] = gameData.multiplayer.players [j].netKillsTotal;
netGame.player_score [j] = gameData.multiplayer.players [j].score;
}
netGame.xLevelTime = LOCALPLAYER.timeLevel;
netGame.monitor_vector = NetworkCreateMonitorVector ();
if (gameStates.multi.nGameType >= IPX_GAME) {
SendInternetFullNetGamePacket (
networkData.playerRejoining.player.network.ipx.server,
networkData.playerRejoining.player.network.ipx.node);
SendNetPlayersPacket (
networkData.playerRejoining.player.network.ipx.server,
networkData.playerRejoining.player.network.ipx.node);
}
return;
}
void NetworkSendRejoinSync (int nPlayer, tNetworkSyncData *syncP)
{
int i, j;
gameData.multiplayer.players [nPlayer].connected = 1; // connect the new guy
ResetPlayerTimeout (nPlayer, -1);
if (gameStates.app.bEndLevelSequence || gameData.reactor.bDestroyed) {
// Endlevel started before we finished sending the goods, we'll
// have to stop and try again after the level.
if (gameStates.multi.nGameType >= IPX_GAME)
NetworkDumpPlayer (
syncP->player [1].player.network.ipx.server,
syncP->player [1].player.network.ipx.node,
DUMP_ENDLEVEL);
syncP->nState = 0;
syncP->nExtras = 0;
return;
}
if (networkData.bPlayerAdded) {
syncP->player [1].nType = PID_ADDPLAYER;
syncP->player [1].player.connected = nPlayer;
NetworkNewPlayer (&syncP->player [1]);
for (i = 0; i < gameData.multiplayer.nPlayers; i++) {
if ((i != nPlayer) &&
(i != gameData.multiplayer.nLocalPlayer) &&
gameData.multiplayer.players [i].connected &&
(gameStates.multi.nGameType >= IPX_GAME)) {
SendSequencePacket (
syncP->player [1],
netPlayers.m_info.players [i].network.ipx.server,
netPlayers.m_info.players [i].network.ipx.node,
gameData.multiplayer.players [i].netAddress);
}
}
}
// Send sync packet to the new guy
NetworkUpdateNetGame ();
// Fill in the kill list
for (j = 0; j < MAX_PLAYERS; j++) {
for (i = 0; i < MAX_PLAYERS; i++)
*netGame.Kills (j, i) = gameData.multigame.kills.matrix [j][i];
*netGame.Killed (j) = gameData.multiplayer.players [j].netKilledTotal;
*netGame.PlayerKills (j) = gameData.multiplayer.players [j].netKillsTotal;
*netGame.PlayerScore (j) = gameData.multiplayer.players [j].score;
}
netGame.SetLevelTime (LOCALPLAYER.timeLevel);
netGame.SetMonitorVector (NetworkCreateMonitorVector ());
if (gameStates.multi.nGameType >= IPX_GAME) {
SendInternetFullNetGamePacket (syncP->player [1].player.network.ipx.server, syncP->player [1].player.network.ipx.node);
SendNetPlayersPacket (syncP->player [1].player.network.ipx.server, syncP->player [1].player.network.ipx.node);
MultiSendMonsterball (1, 1);
}
}
int NetworkEndLevel (int *secret)
{
// Do whatever needs to be done between levels
int i;
fix t = TimerGetApproxSeconds ();
*secret=0;
//NetworkFlush ();
networkData.nStatus = NETSTAT_ENDLEVEL; // We are between levels
NetworkListen ();
NetworkSendEndLevelPacket ();
for (i = 0; i < gameData.multiplayer.nPlayers; i++)
ResetPlayerTimeout (i, t);
NetworkSendEndLevelPacket ();
NetworkSendEndLevelPacket ();
networkData.bSyncPackInited = 0;
NetworkUpdateNetGame ();
return 0;
}
void NetworkReadEndLevelShortPacket (ubyte *dataP)
{
// Special packet for end of level syncing
int nPlayer;
tEndLevelInfoShort *end;
end = reinterpret_cast<tEndLevelInfoShort*> (dataP);
nPlayer = end->nPlayer;
Assert (nPlayer != gameData.multiplayer.nLocalPlayer);
if (nPlayer >= gameData.multiplayer.nPlayers) {
Int3 (); // weird, but it can happen in a coop restore game
return; // if it happens in a coop restore, don't worry about it
}
if ((networkData.nStatus == NETSTAT_PLAYING) && (end->connected != 0))
return; // Only accept disconnect packets if we're not out of the level yet
gameData.multiplayer.players [nPlayer].connected = end->connected;
if ((gameData.multiplayer.players [nPlayer].connected == 1) && (end->seconds_left < gameData.reactor.countdown.nSecsLeft))
gameData.reactor.countdown.nSecsLeft = end->seconds_left;
ResetPlayerTimeout (nPlayer, -1);
}
void NetworkAddPlayer (tSequencePacket *player)
{
tNetPlayerInfo *npiP;
if (NetworkFindPlayer (&player->player) > -1)
return;
npiP = netPlayers.players + gameData.multiplayer.nPlayers;
memcpy (&npiP->network, &player->player.network, sizeof (tNetworkInfo));
ClipRank ((char *) &player->player.rank);
memcpy (npiP->callsign, player->player.callsign, CALLSIGN_LEN+1);
npiP->versionMajor = player->player.versionMajor;
npiP->versionMinor = player->player.versionMinor;
npiP->rank = player->player.rank;
npiP->connected = 1;
NetworkCheckForOldVersion ((char) gameData.multiplayer.nPlayers);
gameData.multiplayer.players [gameData.multiplayer.nPlayers].nKillGoalCount = 0;
gameData.multiplayer.players [gameData.multiplayer.nPlayers].connected = 1;
ResetPlayerTimeout (gameData.multiplayer.nPlayers, -1);
gameData.multiplayer.nPlayers++;
netGame.nNumPlayers = gameData.multiplayer.nPlayers;
// Broadcast updated info
NetworkSendGameInfo (NULL);
}
void NetworkDoFrame (int bForce, int bListen)
{
tFrameInfoShort shortSyncPack;
static fix xLastEndlevel = 0;
int i;
if (!(gameData.app.nGameMode & GM_NETWORK))
return;
if ((networkData.nStatus == NETSTAT_PLAYING) && !gameStates.app.bEndLevelSequence) { // Don't send postion during escape sequence...
if (nakedData.nLength) {
Assert (nakedData.nDestPlayer >- 1);
if (gameStates.multi.nGameType >= IPX_GAME)
IPXSendPacketData (reinterpret_cast<ubyte*> (nakedData.buf), nakedData.nLength,
netPlayers.players [nakedData.nDestPlayer].network.ipx.server,
netPlayers.players [nakedData.nDestPlayer].network.ipx.node,
gameData.multiplayer.players [nakedData.nDestPlayer].netAddress);
nakedData.nLength = 0;
nakedData.nDestPlayer = -1;
}
if (networkData.refuse.bWaitForAnswer && TimerGetApproxSeconds ()> (networkData.refuse.xTimeLimit+ (I2X (12))))
networkData.refuse.bWaitForAnswer=0;
networkData.xLastSendTime += gameData.time.xFrame;
networkData.xLastTimeoutCheck += gameData.time.xFrame;
// Send out packet PacksPerSec times per second maximum... unless they fire, then send more often...
if ((networkData.xLastSendTime > I2X (1) / PacketsPerSec ()) ||
(gameData.multigame.laser.bFired) || bForce || networkData.bPacketUrgent) {
if (LOCALPLAYER.connected) {
int nObject = LOCALPLAYER.nObject;
networkData.bPacketUrgent = 0;
if (bListen) {
MultiSendRobotFrame (0);
MultiSendFire (); // Do firing if needed..
}
networkData.xLastSendTime = 0;
if (netGame.bShortPackets) {
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
ubyte send_data [MAX_PACKETSIZE];
#endif
memset (&shortSyncPack, 0, sizeof (shortSyncPack));
CreateShortPos (&shortSyncPack.objPos, OBJECTS+nObject, 0);
shortSyncPack.nType = PID_PDATA;
shortSyncPack.nPlayer = gameData.multiplayer.nLocalPlayer;
shortSyncPack.objRenderType = OBJECTS [nObject].info.renderType;
shortSyncPack.nLevel = gameData.missions.nCurrentLevel;
shortSyncPack.dataSize = networkData.syncPack.dataSize;
memcpy (shortSyncPack.data, networkData.syncPack.data, networkData.syncPack.dataSize);
networkData.syncPack.nPackets = INTEL_INT (gameData.multiplayer.players [0].nPacketsSent++);
shortSyncPack.nPackets = networkData.syncPack.nPackets;
#if !(defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__))
IpxSendGamePacket (
reinterpret_cast<ubyte*> (&shortSyncPack),
sizeof (tFrameInfoShort) - networkData.nMaxXDataSize + networkData.syncPack.dataSize);
#else
SquishShortFrameInfo (shortSyncPack, send_data);
IpxSendGamePacket (
reinterpret_cast<ubyte*> (send_data),
IPX_SHORT_INFO_SIZE-networkData.nMaxXDataSize+networkData.syncPack.dataSize);
#endif
}
else {// If long packets
int send_dataSize;
networkData.syncPack.nType = PID_PDATA;
networkData.syncPack.nPlayer = gameData.multiplayer.nLocalPlayer;
networkData.syncPack.objRenderType = OBJECTS [nObject].info.renderType;
networkData.syncPack.nLevel = gameData.missions.nCurrentLevel;
networkData.syncPack.nObjSeg = OBJECTS [nObject].info.nSegment;
networkData.syncPack.objPos = OBJECTS [nObject].info.position.vPos;
networkData.syncPack.objOrient = OBJECTS [nObject].info.position.mOrient;
networkData.syncPack.physVelocity = OBJECTS [nObject].mType.physInfo.velocity;
networkData.syncPack.physRotVel = OBJECTS [nObject].mType.physInfo.rotVel;
send_dataSize = networkData.syncPack.dataSize; // do this so correct size data is sent
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__) // do the swap stuff
if (gameStates.multi.nGameType >= IPX_GAME) {
networkData.syncPack.nObjSeg = INTEL_SHORT (networkData.syncPack.nObjSeg);
INTEL_VECTOR (networkData.syncPack.objPos);
INTEL_MATRIX (networkData.syncPack.objOrient);
INTEL_VECTOR (networkData.syncPack.physVelocity);
INTEL_VECTOR (networkData.syncPack.physRotVel);
networkData.syncPack.dataSize = INTEL_SHORT (networkData.syncPack.dataSize);
}
#endif
networkData.syncPack.nPackets = INTEL_INT (gameData.multiplayer.players [0].nPacketsSent++);
IpxSendGamePacket (
reinterpret_cast<ubyte*> (&networkData.syncPack),
sizeof (tFrameInfo) - networkData.nMaxXDataSize + send_dataSize);
}
networkData.syncPack.dataSize = 0; // Start data over at 0 length.
networkData.bD2XData = 0;
if (gameData.reactor.bDestroyed) {
if (gameStates.app.bPlayerIsDead)
LOCALPLAYER.connected=3;
if (TimerGetApproxSeconds () > (xLastEndlevel+ (I2X (1)/2))) {
NetworkSendEndLevelPacket ();
xLastEndlevel = TimerGetApproxSeconds ();
}
}
}
}
if (!bListen)
return;
if ((networkData.xLastTimeoutCheck > I2X (1)) && !gameData.reactor.bDestroyed) {
fix t = (fix) SDL_GetTicks ();
// Check for CPlayerData timeouts
for (i = 0; i < gameData.multiplayer.nPlayers; i++) {
if ((i != gameData.multiplayer.nLocalPlayer) &&
((gameData.multiplayer.players [i].connected == 1) || downloadManager.Downloading (i))) {
if ((networkData.nLastPacketTime [i] == 0) || (networkData.nLastPacketTime [i] + downloadManager.GetTimeoutSecs () * 1000 > t)) {
ResetPlayerTimeout (i, t);
continue;
}
#if 1//!DBG
if (gameOpts->multi.bTimeoutPlayers && (t - networkData.nLastPacketTime [i] > 15000))
NetworkTimeoutPlayer (i);
#endif
}
}
networkData.xLastTimeoutCheck = 0;
}
}
if (!bListen) {
networkData.syncPack.dataSize = 0;
return;
}
NetworkListen ();
#if 0
if ((networkData.sync.nPlayer != -1) && !(gameData.app.nFrameCount & 63))
ResendSyncDueToPacketLoss (); // This will resend to network_player_rejoining
#endif
NetworkDoSyncFrame ();
if (NetworkIAmMaster ())
tracker.AddServer ();
}
void NetworkReadPDataPacket (tFrameInfo *pd)
{
int nTheirPlayer;
int theirObjNum;
CObject * theirObjP = NULL;
// tFrameInfo should be aligned...for mac, make the necessary adjustments
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
if (gameStates.multi.nGameType >= IPX_GAME) {
pd->nPackets = INTEL_INT (pd->nPackets);
pd->objPos[X] = INTEL_INT (pd->objPos[X]);
pd->objPos[Y] = INTEL_INT (pd->objPos[Y]);
pd->objPos[Z] = INTEL_INT (pd->objPos[Z]);
pd->objOrient.RVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[X]);
pd->objOrient.RVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[Y]);
pd->objOrient.RVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[Z]);
pd->objOrient.UVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[X]);
pd->objOrient.UVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[Y]);
pd->objOrient.UVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[Z]);
pd->objOrient.FVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[X]);
pd->objOrient.FVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[Y]);
pd->objOrient.FVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[Z]);
pd->physVelocity[X] = (fix)INTEL_INT ((int)pd->physVelocity[X]);
pd->physVelocity[Y] = (fix)INTEL_INT ((int)pd->physVelocity[Y]);
pd->physVelocity[Z] = (fix)INTEL_INT ((int)pd->physVelocity[Z]);
pd->physRotVel[X] = (fix)INTEL_INT ((int)pd->physRotVel[X]);
pd->physRotVel[Y] = (fix)INTEL_INT ((int)pd->physRotVel[Y]);
pd->physRotVel[Z] = (fix)INTEL_INT ((int)pd->physRotVel[Z]);
pd->nObjSeg = INTEL_SHORT (pd->nObjSeg);
pd->dataSize = INTEL_SHORT (pd->dataSize);
}
#endif
nTheirPlayer = pd->nPlayer;
theirObjNum = gameData.multiplayer.players [pd->nPlayer].nObject;
if (nTheirPlayer < 0) {
Int3 (); // This packet is bogus!!
return;
}
if ((networkData.sync [0].nPlayer != -1) && (nTheirPlayer == networkData.sync [0].nPlayer))
networkData.sync [0].nPlayer = -1;
if (!gameData.multigame.bQuitGame && (nTheirPlayer >= gameData.multiplayer.nPlayers)) {
if (networkData.nStatus != NETSTAT_WAITING) {
Int3 (); // We missed an important packet!
NetworkConsistencyError ();
}
return;
}
if (gameStates.app.bEndLevelSequence || (networkData.nStatus == NETSTAT_ENDLEVEL)) {
int old_Endlevel_sequence = gameStates.app.bEndLevelSequence;
gameStates.app.bEndLevelSequence = 1;
if (pd->dataSize > 0)
// pass pd->data to some parser function....
MultiProcessBigData (reinterpret_cast<char*> (pd->data), pd->dataSize);
gameStates.app.bEndLevelSequence = old_Endlevel_sequence;
return;
}
if ((sbyte)pd->nLevel != gameData.missions.nCurrentLevel) {
#if 1
console.printf (CON_DBG, "Got frame packet from CPlayerData %d wrong level %d!\n", pd->nPlayer, pd->nLevel);
#endif
return;
}
theirObjP = OBJECTS + theirObjNum;
//------------- Keep track of missed packets -----------------
gameData.multiplayer.players [nTheirPlayer].nPacketsGot++;
networkData.nTotalPacketsGot++;
ResetPlayerTimeout (nTheirPlayer, -1);
if (pd->nPackets != gameData.multiplayer.players [nTheirPlayer].nPacketsGot) {
networkData.nMissedPackets = pd->nPackets - gameData.multiplayer.players [nTheirPlayer].nPacketsGot;
if ((pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot) > 0)
networkData.nTotalMissedPackets += pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot;
#if 1
if (networkData.nMissedPackets > 0)
console.printf (0,
"Missed %d packets from CPlayerData #%d (%d total)\n",
pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot,
nTheirPlayer,
networkData.nMissedPackets);
else
console.printf (CON_DBG,
"Got %d late packets from CPlayerData #%d (%d total)\n",
gameData.multiplayer.players [nTheirPlayer].nPacketsGot-pd->nPackets,
nTheirPlayer,
networkData.nMissedPackets);
#endif
gameData.multiplayer.players [nTheirPlayer].nPacketsGot = pd->nPackets;
}
//------------ Read the CPlayerData's ship's CObject info ----------------------
theirObjP->info.position.vPos = pd->objPos;
theirObjP->info.position.mOrient = pd->objOrient;
theirObjP->mType.physInfo.velocity = pd->physVelocity;
theirObjP->mType.physInfo.rotVel = pd->physRotVel;
if ((theirObjP->info.renderType != pd->objRenderType) && (pd->objRenderType == RT_POLYOBJ))
MultiMakeGhostPlayer (nTheirPlayer);
OBJECTS [theirObjNum].RelinkToSeg (pd->nObjSeg);
if (theirObjP->info.movementType == MT_PHYSICS)
theirObjP->SetThrustFromVelocity ();
//------------ Welcome them back if reconnecting --------------
if (!gameData.multiplayer.players [nTheirPlayer].connected) {
gameData.multiplayer.players [nTheirPlayer].connected = 1;
if (gameData.demo.nState == ND_STATE_RECORDING)
NDRecordMultiReconnect (nTheirPlayer);
MultiMakeGhostPlayer (nTheirPlayer);
OBJECTS [theirObjNum].CreateAppearanceEffect ();
audio.PlaySound (SOUND_HUD_MESSAGE);
ClipRank (reinterpret_cast<char*> (&netPlayers.players [nTheirPlayer].rank));
if (gameOpts->multi.bNoRankings)
HUDInitMessage ("'%s' %s", gameData.multiplayer.players [nTheirPlayer].callsign, TXT_REJOIN);
else
HUDInitMessage ("%s'%s' %s",
pszRankStrings [netPlayers.players [nTheirPlayer].rank],
gameData.multiplayer.players [nTheirPlayer].callsign, TXT_REJOIN);
MultiSendScore ();
}
//------------ Parse the extra dataP at the end ---------------
if (pd->dataSize > 0)
// pass pd->data to some parser function....
MultiProcessBigData (reinterpret_cast<char*> (pd->data), pd->dataSize);
}
