/// <summary> /// Clients receive reports about health as part of their incoming streams. The server will have added them to its outgoing/mirror streams. /// </summary> public void NSTBitstreamIncomingFirst(Frame frame, Frame currFrame, ref UdpBitStream bitstream, bool isServer) { bool iAmActingAuthority = na.IAmActingAuthority; // If this is the server and has authority, it will receieve its own outgoings... account for that. // TODO: Cache this down the line with callbacks from the net engine to notify of ownership changes bool noIncomingExpected = MasterNetAdapter.ServerIsActive && iAmActingAuthority && (NetLibrarySettings.single.defaultAuthority == DefaultAuthority.ServerAuthority || MasterNetAdapter.NET_MODEL == NetworkModel.ServerClient) && !na.IsMine; // if we are authority, any incoming messages from others will not include a health. Only the authority should write health. if (noIncomingExpected) { return; } if (UpdateDue(frame.frameid)) { for (int i = 0; i < vitalsCount; ++i) { Vital v = vitals[i]; int incval = bitstream.ReadInt(v.bitsForStat); if (!iAmActingAuthority) { v.Value = incval; } } if (!iAmActingAuthority) { UpdateMonitors(); } } }
public void Unpack(byte[] data) { var stream = new UdpBitStream(data, data.Length); id = stream.ReadInt(); //position = stream.ReadVector3(); }
public override bool Unpack(ref UdpBitStream stream, ref object o) { // read length and create array, then read bytes into array byte[] bytes = new byte[stream.ReadInt()]; stream.ReadByteArray(bytes); // convert bytes to string o = Encoding.UTF8.GetString(bytes); return(true); }
/// <summary> /// Read the current scene ID from the bitstream. Return -1 for Scene not being in the build list, or if includeSceneIndexInUpdate is disabled. /// </summary> /// <param name="bitstream"></param> /// <param name="outstream"></param> /// <param name="asServer"></param> /// <returns></returns> public static int Deserialize(ref UdpBitStream bitstream, ref UdpBitStream outstream, bool asServer) { if (includeSceneIndexInUpdates) { int buildindex = bitstream.ReadInt(bitsForSceneIndex); if (asServer) { outstream.Write(buildindex, bitsForSceneIndex); } return(buildindex); } else { return(-1); } }
public static void Rcv(ref UdpBitStream bitstream, ref UdpBitStream outstream, bool mirror, int clientId) { bool isPing = bitstream.ReadBool(); // if this is a ping from a client, a time delta should follow (mirror means this is the server, and this pass is the server pass) if (isPing && mirror && clientId != MasterNetAdapter.MasterClientId) { float clientHeldTime = .001f * bitstream.ReadInt(10); float rtt = (Time.time - svrPingInitiateTime) - clientHeldTime; if (RTT.ContainsKey(clientId)) { RTT[clientId] = RTT[clientId] * OLD_SAMP_WEIGHT + rtt * NEW_SAMP_WEIGHT; } else { RTT.Add(clientId, rtt); } //Debug.Log( DebugX.Log(!DebugX.logInfo ? null : "MasterRTT ping result " + clientId + " <b>" + RTT[clientId] + " </b> plus " + clientHeldTime + " of client waiting for next outgoing tick."); } // this is a dumb client and it just got a ping from server else if (isPing && !MasterNetAdapter.ServerIsActive) { clientNeedsToRespondToPing = true; clntPingArriveTime = Time.time; } // We don't mirror out pings. The conversation is strictly Server > Player > Server if (mirror) { outstream.WriteBool(false); } }
/// <summary> /// Clients receive reports about health as part of their incoming streams. The server will have added them to its outgoing/mirror streams. /// </summary> /// <param name="waitingForTeleportConfirm"></param> public void NSTBitstreamIncomingFirst(Frame frame, Frame currFrame, ref UdpBitStream bitstream, bool isServer, bool waitingForTeleportConfirm) { // if this isn't a client, it should not be receiving this. if (MasterNetAdapter.ServerIsActive && !na.HasAuthority) { return; } if (UpdateDue(frame.frameid)) { for (int i = 0; i < vitals.Count; i++) { int incval = bitstream.ReadInt(vitals[i].bitsForStat); // Update the value if this isn't the server if (!MasterNetAdapter.ServerIsActive) { vitals[i].Value = incval; } } } UpdateMonitors(); }
/// <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. This is conditional to the editor only 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, 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 == FRAME_COUNT; int sceneIndex = NSTSceneManager.Deserialize(ref bitstream, ref outstream, mirror); bool sceneOutOfSync = HeaderSettings.single.includeSceneIndex && sceneIndex != NSTSceneManager.CurrentSceneIndex; if (sceneOutOfSync) { Debug.LogWarning(frameid + " Out of sync " + sceneIndex + " " + NSTSceneManager.CurrentSceneIndex); } // 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; XDebug.LogWarning(!XDebug.logWarnings ? null : ("Incoming Update for nstid: " + nstid + " was from a different scene. Ignoring update to avoid data corruption due to different compression settings."), sceneOutOfSync); XDebug.Log(!XDebug.logInfo ? null : //Debug.Log( ("Message for an NST Object " + nstid + " arrived but that object does not exist. (yet/anymore?) This is normal during startup and shutdown."), lastNST == null); /// Skip reading if the target NST doesn't exist, or if this we compressed with a different scene (codec mismatch likely) if (lastNST == null || sceneOutOfSync) { if (sceneOutOfSync) { Debug.LogWarning(frameid + " skipped entirely due to sceneID mismatch"); } // 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. if (mirror) { /// TODO : Rather than jump ahead, Server should bulk copy the ignored data to outstream in case other clients can use it. 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, sceneIndex, sceneOutOfSync, 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); if (!isOfftick) { MasterRTT.Rcv(ref bitstream, ref outstream, mirror, senderId); } BandwidthUsage.AddUsage(ref bitstream, "RTT checks"); // Very last thing... report the bits that were used. This is conditional to the editor only BandwidthUsage.ReportMasterBits(ref bitstream, BandwidthLogType.MasterIn); }
public static int ReadCompressedAxisFromBitstream(ref UdpBitStream bitstream, int axis, bool lowerBitsOnly = false) { return(bitstream.ReadInt(lowerBitsOnly ? axisRanges[axis].lowerBits : axisRanges[axis].bits)); }
public static int ReadCompressedAxisFromBitstream(ref UdpBitStream bitstream, int axis, BitCullingLevel bcl) { return(bitstream.ReadInt(axisRanges[axis].GetBitsAtCullLevel(bcl))); }
/// <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); }