示例#1
0
        private void SendUpdate()
        {
            int writepos = 0;

            SerializeValuesToBitstream(buffer, ref writepos);

            /// Serialize and send out this bitstream.
            if (UsingPUN)
            {
                NetMsgSends.Send(buffer, writepos, SERVER_SND_ID, ReceiveGroup.Others);
            }
            else
            {
                NetMsgSends.Send(buffer, writepos, AsServer ? SERVER_SND_ID : CLIENT_SND_ID, AsServer ? ReceiveGroup.Others : ReceiveGroup.Master);
            }
        }
示例#2
0
        private static void SerializeAllAndSend()
        {
            byte[] buffer      = NetMsgSends.reusableBuffer;
            int    bitposition = 0;

            SerializationFlags writeFlags;
            SerializationFlags flags;

            if (TickManager.needToSendInitialForNewConn)
            {
                writeFlags = SerializationFlags.NewConnection | SerializationFlags.ForceReliable | SerializationFlags.Force;
                flags      = SerializationFlags.HasContent;
                TickManager.needToSendInitialForNewConn = false;
            }
            else
            {
                writeFlags = SerializationFlags.None;
                flags      = SerializationFlags.None;
            }

            /// Write frameId
            buffer.Write((uint)_currFrameId, ref bitposition, TickEngineSettings.frameCountBits);

            NetMasterCallbacks.OnPreSerializeTickCallbacks(_currFrameId, buffer, ref bitposition);

            #region NetObject Serialization

            /// Loop through owned NetObjects
            NetObject.NetObjDictsLocked = true;

            NonAllocDictionary <int, NetObject> controlledObjs = NetObject.activeControlledNetObjs;

            SerializeNetObjDict(controlledObjs, buffer, ref bitposition, ref flags, writeFlags);

            //NonAllocDictionary<int, NetObject> ownedButNotControlledObjs = NetObject.activeOwnedNetObjs;

            //if (ownedButNotControlledObjs.Count > 0)
            //    Debug.Log("LIMBO COUNT " + ownedButNotControlledObjs.Count);

            //SerializeNetObjDict(ownedButNotControlledObjs, buffer, ref bitposition, ref flags, writeFlags);

            //foreach (var no in ownedObjs)
            //{

            //    /// Not end of netobjs write bool
            //    int holdStartPos = bitposition;

            //    /// Write viewID
            //    buffer.WritePackedBytes((uint)no.ViewID, ref bitposition, 32);

            //    /// Write hadData bool
            //    int holdHasDataPos = bitposition;
            //    buffer.WriteBool(true, ref bitposition);

            //    /// Log the data size write position and write a placeholder.
            //    int holdDataSizePos = bitposition;
            //    bitposition += BITS_FOR_NETOBJ_SIZE;

            //    var objflags = no.OnNetSerialize(_currFrameId, buffer, ref bitposition, writeFlags);

            //    /// Skip netobjs if they had nothing to say
            //    if (objflags == SerializationFlags.None)
            //    {
            //        /// Rewind if this is a no-data write.
            //        if (no.SkipWhenEmpty)
            //        {
            //            bitposition = holdStartPos;
            //        }
            //        else
            //        {
            //            bitposition = holdHasDataPos;
            //            buffer.WriteBool(false, ref bitposition);
            //        }
            //    }
            //    else
            //    {
            //        /// Revise the data size now that we know it.
            //        flags |= objflags;
            //        int bitcount = bitposition - holdDataSizePos;
            //        buffer.Write((uint)bitcount, ref holdDataSizePos, BITS_FOR_NETOBJ_SIZE);
            //    }

            //    //Debug.Log(objflags + " / flg: " + (onNetSerialize[i]  as Component).name + " " + flags);
            //}

            NetObject.NetObjDictsLocked = false;

            #endregion

            // Any deferrered Ownership changes from SyncState happen here
            while (NetMasterCallbacks.postSerializationActions.Count > 0)
            {
                NetMasterCallbacks.postSerializationActions.Dequeue().Invoke();
            }

            if (flags == SerializationFlags.None)
            {
                return;
            }

            /// End of NetObject write bool
            buffer.WritePackedBytes(0, ref bitposition, 32);

            NetMsgSends.Send(buffer, bitposition, null, flags, true);
        }
示例#3
0
        public SerializationFlags OnNetSerialize(int frameId, byte[] buffer, ref int bitposition, SerializationFlags writeFlags)
        {
#if PUN_2_OR_NEWER
            //Debug.Log(name + " OnNetSerialize NO " + pv.IsMine + " / " + pv.IsMine);
            if (!pv.IsMine)
            {
                return(SerializationFlags.None);
            }

            //if ((writeFlags & SerializationFlags.Force) != 0)
            //	Debug.LogError("FORCE " + writeFlags);

            if (pv.Group != 0)

            {
                /// TODO: Ideally objects will not be individually serializing themselves into their own send.
                /// Serialize and Send this netobj state if this is a net tick.
                buffer = NetMsgSends.reusableNetObjBuffer;
                int localbitposition = 0;

                /// Write FrameId
                buffer.Write((uint)frameId, ref localbitposition, SimpleSyncSettings.FrameCountBits);

                /// Write not end of netObjs bool
                //buffer.WriteBool(true, ref localbitposition);

                /// Write netid
                buffer.WritePackedBytes((uint)netObjId, ref localbitposition, 32);

                /// Placeholder for data size. False means this is a contentless heartbea
                int holdHasDataPos = localbitposition;
                buffer.WriteBool(true, ref localbitposition);

                /// Placeholder for data size. False means this is a contentless heartbeat
                int holdDataSizePos = localbitposition;
                localbitposition += NetMaster.BITS_FOR_NETOBJ_SIZE;

                SerializationFlags lclflags = GenerateMessage(frameId, buffer, ref localbitposition, writeFlags);

                if (lclflags == SerializationFlags.None)
                {
                    if (skipWhenEmpty)
                    {
                        return(SerializationFlags.None);
                    }
                    else
                    {
                        /// revise the hasData bool to be false and rewind the bitwriter.
                        localbitposition = holdHasDataPos;
                        buffer.WriteBool(false, ref bitposition);
                    }
                }

                if (lclflags != SerializationFlags.None || !SkipWhenEmpty)
                {
                    /// Revise the data size now that we know it
                    buffer.Write((uint)(localbitposition - holdDataSizePos), ref holdDataSizePos, NetMaster.BITS_FOR_NETOBJ_SIZE);

                    /// Write end of netObjs marker
                    buffer.WritePackedBytes(0, ref localbitposition, 32);

                    NetMsgSends.Send(buffer, localbitposition, gameObject, lclflags, false);
                }

                /// We sent this object at the netObj level, so we report back to the NetMaster that nothing has been added to the master byte[] send.
                return(SerializationFlags.None);
            }
#endif
            var flags = GenerateMessage(frameId, buffer, ref bitposition, writeFlags);
            return(flags);
        }
示例#4
0
        private static void SerializeAndSendNetObjects()
        {
            byte[] buffer      = NetMsgSends.reusableBuffer;
            int    bitposition = 0;

            SerializationFlags writeFlags;
            SerializationFlags flags;

            if (TickManager.needToSendInitialForNewConn)
            {
                //Debug.LogError("needToSendInitialForNewConn");
                //Debug.Log("<b>New connection</b> - send forced initial");
                writeFlags = SerializationFlags.NewConnection | SerializationFlags.ForceReliable | SerializationFlags.Force;
                flags      = SerializationFlags.HasChanged;            // SerializationFlags.ForceReliable;
                TickManager.needToSendInitialForNewConn = false;
            }
            else
            {
                writeFlags = SerializationFlags.None;
                flags      = SerializationFlags.None;
            }

            /// Write frameId
            buffer.Write((uint)_currFrameId, ref bitposition, frameCountBits);

            int cnt = onNetSerializes.Count;

            for (int i = 0; i < cnt; ++i)
            {
                IOnNetSerialize icb = onNetSerializes[i];

                /// Not end of netobjs write bool
                int holdStartPos = bitposition;

                /// Write netid
                buffer.WritePackedBytes((uint)(icb as NetObject).netObjId, ref bitposition, 32);

                /// Write hadData bool
                int holdHasDataPos = bitposition;
                buffer.WriteBool(true, ref bitposition);

                /// Log the data size write position and write a placeholder.
                int holdDataSizePos = bitposition;
                bitposition += BITS_FOR_NETOBJ_SIZE;

                var objflags = icb.OnNetSerialize(_currFrameId, buffer, ref bitposition, writeFlags);

                /// Skip netobjs if they had nothing to say
                if (objflags == SerializationFlags.None)
                {
                    /// Rewind if this is a no-data write.
                    if (icb.SkipWhenEmpty)
                    {
                        bitposition = holdStartPos;
                        //Debug.Log((icb as Component).name + " SLEEP OUT");
                    }
                    else
                    {
                        bitposition = holdHasDataPos;
                        buffer.WriteBool(false, ref bitposition);
                    }
                }
                else
                {
                    /// Revise the data size now that we know it.
                    flags |= objflags;
                    int bitcount = bitposition - holdDataSizePos;
                    buffer.Write((uint)bitcount, ref holdDataSizePos, BITS_FOR_NETOBJ_SIZE);
                }

                //Debug.Log(objflags + " / flg: " + (onNetSerialize[i]  as Component).name + " " + flags);
            }

            if (flags == SerializationFlags.None)
            {
                return;
            }

            /// End of NetObject write bool
            buffer.WritePackedBytes(0, ref bitposition, 32);


            NetMsgSends.Send(buffer, bitposition, null, flags, true);
        }