/// <summary>
/// Updates over the network arrive here - AFTER the Update() runs (not tested for all platforms... thanks unet for the great docs.)
/// The incoming bitstream is read
/// </summary>
/// <param name="msg"></param>
private static void ReceiveUpdate(NetworkMessage msg)
{
UdpBitStream bitstream = new UdpBitStream(msg.reader.ReadBytesNonAlloc(NSTMaster.bitstreamByteArray, msg.reader.Length), msg.reader.Length);
UdpBitStream outstream = new UdpBitStream(NSTMaster.outstreamByteArray);
NSTMaster.ReceiveUpdate(ref bitstream, ref outstream, NetworkServer.active);
BandwidthUsage.ReportMasterBits(ref bitstream, BandwidthLogType.MasterIn);
// Write a clone message and pass it to all the clients if this is the server receiving
if (NetworkServer.active) // && msg.conn == nst.NI.clientAuthorityOwner)
{
writer.StartMessage(msg.msgType);
//writer.WriteUncountedByteArray(bitstream.Data, msg.reader.Length);
writer.WriteUncountedByteArray(outstream.Data, outstream.BytesUsed);
writer.SendPayloadArrayToAllClients(msg.msgType);
}
}
/// <summary>
/// Reads update headers for each NST frame update in the incoming bitstream, and passes the bitstream to that NST to read out its
/// update information.
/// </summary>
/// <param name="mirror">True if this is the server, and this is the incoming bitstream. Tells the server that the outstream
/// needs to be populated for retransmission to all clients. Also false if this is the server running its own outgoing update.</param>
public static void ReceiveUpdate(ref UdpBitStream bitstream, ref UdpBitStream outstream, bool mirror, int senderId)
{
// Create a new bitstream to ensure ptr is at 0. Same data as master though.
bitstream.Ptr = 0;
int frameid = bitstream.ReadInt(6);
if (mirror)
{
outstream.WriteInt(frameid, 6);
}
bool isOfftick = frameid == 60;
// remove this safety once working
//TEST
int safety = 0;
UpdateType updateType;
do
{
safety++;
BandwidthUsage.Start(ref bitstream, BandwidthLogType.UpdateRcv);
//stop looking when header is EOS
bool notEOS = bitstream.ReadBool();
int mirrorUpdateStartPtr = outstream.Ptr;
BandwidthUsage.AddUsage(ref bitstream, "NotEOS");
if (mirror)
{
outstream.WriteBool(notEOS);
}
if (!notEOS)
{
break;
}
// First three bits are the msgtype
//TODO this might only need to be two
updateType = (UpdateType)bitstream.ReadInt(3);
BandwidthUsage.AddUsage(ref bitstream, "UpdateType");
int updateBitstreamPos = outstream.Ptr;
if (mirror)
{
outstream.WriteInt((int)updateType, 3);
}
// Next variable is the NstId - get it to know where to send the rest of the bitstream
uint nstid = bitstream.ReadUInt(HeaderSettings.single.BitsForNstId);
BandwidthUsage.AddUsage(ref bitstream, "NstId");
if (mirror)
{
outstream.WriteUInt(nstid, HeaderSettings.single.BitsForNstId);
}
lastNST = NSTTools.GetNstFromId(nstid);
BandwidthUsage.SetName(lastNST);
int updatelength = bitstream.ReadInt(UPDATELENGTH_BYTE_COUNT_SIZE);
if (mirror)
{
outstream.WriteInt(updatelength, UPDATELENGTH_BYTE_COUNT_SIZE);
}
BandwidthUsage.AddUsage(ref bitstream, "DataLength");
//Note the starting pos in stream
int bodyPtr = bitstream.Ptr;
// The start pos for modifying update lenght for mirror
int mirrorBodyPtr = outstream.Ptr;
// This mising NST handler is NOT FULLY TESTED. Uses the updatelength value to jump ahead in the bitstream if the NST it is
// addressed to doesn't exist for some reason.
if (lastNST == null)
{
//DebugX.LogWarning(!DebugX.logWarnings ? null :
DebugX.Log(
("Message for an NST Object " + nstid + " arrived but that object does not exist. (yet/anymore?) This is normal during startup and shutdown."));
// Forward to the next update start in the incoming stream.
bitstream.Ptr = bodyPtr + (updatelength << 3);
// rewind to the EOS marker and pretend this arrival never occured for the outgoing mirror stream.
outstream.Ptr = mirrorUpdateStartPtr;
continue;
}
// Tell this nst to read its mail. updateType may get modified by server receive for things like teleport.
Frame frame = lastNST.ReadUpdate(ref bitstream, ref outstream, frameid, isOfftick, updateType, updatelength, mirror);
updateType = frame.updateType;
// overwrite the updateType of the server outgoing in case it has changed.
if (mirror)
{
outstream.WriteIntAtPos((int)updateType, 3, updateBitstreamPos);
}
//Advance ptr to next update in stream by force, in case the last update wasn't read for any reason (such as the NST leaving the game)
bitstream.Ptr = bodyPtr + (updatelength << 3);
// write the update byte length for the mirror (not the same value as the incoming due to server side adjustments)
if (mirror)
{
int holdPos = outstream.Ptr;
outstream.Ptr = mirrorBodyPtr - UPDATELENGTH_BYTE_COUNT_SIZE;
// get the bytesused rounded up.
int bytes = ((holdPos - mirrorBodyPtr) >> 3) + (((holdPos - mirrorBodyPtr) % 8 == 0) ? 0 : 1);
outstream.WriteInt(bytes, UPDATELENGTH_BYTE_COUNT_SIZE);
outstream.Ptr = mirrorBodyPtr + (bytes << 3);
}
} while (safety < 100);
/// NST updates are finished - any data to append to the master update can go here
IntegrityCheck.ReadCheck(ref bitstream, ref outstream, "End of All Update Reads", mirror);
MasterRTT.Rcv(ref bitstream, ref outstream, mirror, senderId);
BandwidthUsage.AddUsage(ref bitstream, "RTT checks");
// Very last... thing report the bits that were used.
BandwidthUsage.ReportMasterBits(ref bitstream, BandwidthLogType.MasterIn);
}
/// <summary>
/// Reads update headers for each NST frame update in the incoming bitstream, and passes the bitstream to that NST to read out its
/// update information.
/// </summary>
/// <param name="mirror">True if this is the server, and this is the incoming bitstream. Tells the server that the outstream
/// needs to be populated for retransmission to all clients. Also false if this is the server running its own outgoing update.</param>
public static void ReceiveUpdate(ref UdpBitStream bitstream, ref UdpBitStream outstream, bool mirror)
{
// Create a new bitstream to ensure ptr is at 0. Same data as master though.
bitstream.Ptr = 0;
// remove this safety once working
//TEST
int safety = 0;
UpdateType updateType;
do
{
safety++;
BandwidthUsage.Start(ref bitstream, BandwidthLogType.UpdateRcv);
//stop looking when header is EOS
bool notEOS = bitstream.ReadBool();
int mirrorUpdateStartPtr = outstream.Ptr;
BandwidthUsage.AddUsage(ref bitstream, "NotEOS");
if (mirror)
{
outstream.WriteBool(notEOS);
}
if (!notEOS)
{
break;
}
// First three bits are the msgtype
//TODO this might only need to be two
updateType = (UpdateType)bitstream.ReadInt(3);
BandwidthUsage.AddUsage(ref bitstream, "UpdateType");
int updateBitstreamPos = outstream.Ptr;
if (mirror)
{
outstream.WriteInt((int)updateType, 3);
}
// Next variable is the NstId - get it to know where to send the rest of the bitstream
uint nstid = bitstream.ReadUInt(NSTSettings.single.bitsForNstId);
BandwidthUsage.AddUsage(ref bitstream, "NstId");
if (mirror)
{
outstream.WriteUInt(nstid, NSTSettings.single.bitsForNstId);
}
NetworkSyncTransform nst = NetworkSyncTransform.GetNstFromId(nstid);
BandwidthUsage.SetName(nst);
int updatelength = bitstream.ReadInt(UPDATELENGTH_BYTE_COUNT_SIZE);
if (mirror)
{
outstream.WriteInt(updatelength, UPDATELENGTH_BYTE_COUNT_SIZE);
}
BandwidthUsage.AddUsage(ref bitstream, "DataLength");
//Note the starting pos in stream
int bodyPtr = bitstream.Ptr;
// The start pos for modifying update lenght for mirror
int mirrorBodyPtr = outstream.Ptr;
// This mising NST handler is NOT FULLY TESTED. Uses the updatelength value to jump ahead in the bitstream if the NST it is
// addressed to doesn't exist for some reason.
if (nst == null)
{
DebugX.LogWarning(!DebugX.logWarnings ? "" : ("Message for an NST Object arrived but that object does not exist."));
// Forward to the next update start in the incoming stream.
bitstream.Ptr = bodyPtr + (updatelength << 3);
// rewind to the EOS marker and pretend this arrival never occured for the outgoing mirror stream.
outstream.Ptr = mirrorUpdateStartPtr;
continue;
}
// Tell this nst to read its mail. updateType may get modified by server receive for things like teleport.
updateType = nst.ReceieveGeneric(ref bitstream, ref outstream, updateType, updatelength, mirror);
// overwrite the updateType of the server outgoing in case it has changed.
if (mirror)
{
outstream.WriteIntAtPos((int)updateType, 3, updateBitstreamPos);
}
//Advance ptr to next update in stream by force, in case the last update wasn't read for any reason (such as the NST leaving the game)
bitstream.Ptr = bodyPtr + (updatelength << 3);
// write the update byte length for the mirror (not the same value as the incoming due to server side adjustments)
if (mirror)
{
int holdPos = outstream.Ptr;
outstream.Ptr = mirrorBodyPtr - UPDATELENGTH_BYTE_COUNT_SIZE;
// get the bytesused rounded up.
int bytes = ((holdPos - mirrorBodyPtr) >> 3) + (((holdPos - mirrorBodyPtr) % 8 == 0) ? 0 : 1);
outstream.WriteInt(bytes, UPDATELENGTH_BYTE_COUNT_SIZE);
outstream.Ptr = mirrorBodyPtr + (bytes << 3);
}
} while (safety < 100);
}