Beispiel #1
0
        public void Serialize(IBitWriter bs, ReplicaBehaviour.SerializeContext ctx)
        {
            for (int i = 0; i < replicaBehaviours.Length; ++i)
            {
                var replicaBehaviour = replicaBehaviours[i];
#if UNITY_EDITOR
                int startSize = 0;
                var isDummy   = bs is DummyBitWriter;
                if (!isDummy)
                {
                    TransportDebugger.BeginScope(replicaBehavioursNames[i]);
                    startSize = bs.BitsWritten;
                }
#endif

                replicaBehaviour.Serialize(bs, ctx);

#if UNITY_EDITOR || DEVELOPMENT
                bs.WriteByte((byte)0b10101010);
#endif

#if UNITY_EDITOR
                if (!isDummy)
                {
                    TransportDebugger.EndScope(bs.BitsWritten - startSize);
                }
#endif
            }
        }
Beispiel #2
0
        public void Tick()
        {
            for (int i = 0; i < _replicaViews.Count; ++i)
            {
                var replicaView = _replicaViews[i];
                if (replicaView.IsLoadingLevel)
                {
                    continue;
                }

#if UNITY_EDITOR
                TransportDebugger.BeginScope("Update " + replicaView.name);
#endif

                UpdateReplicaView(replicaView);

#if UNITY_EDITOR
                TransportDebugger.EndScope();
#endif
            }

            foreach (var replica in _networkScene.Replicas)
            {
                try {
                    // Call RpcTarget.All RPCs on the server
                    // This is done in case the RPC destroys the Replica the RPC had a chance to be send
                    for (int i = 0; i < replica.queuedRpcs.Count; ++i)
                    {
                        var queuedRpc = replica.queuedRpcs[i];
                        if (queuedRpc.target == RpcTarget.All)
                        {
                            var reader = new BitReader(queuedRpc.bs);

                            var _  = reader.ReadByte();
                            var _2 = reader.ReadReplicaId();
                            replica.CallRpcServer(Connection.Invalid, reader);
                        }
                    }
                } finally {
                    replica.queuedRpcs.Clear();
                }
            }

            foreach (var idReplicaPair in _replicasInConstruction)
            {
                var replica = idReplicaPair.Value;
                if (replica == null)
                {
                    continue;
                }

                _networkScene.AddReplica(replica);

                // Don't wait for relevant Replica set update, takes far too long for a newly spawned Replica
                for (int i = 0; i < _replicaViews.Count; ++i)
                {
                    var replicaView = _replicaViews[i];
                    if (replicaView.IsLoadingLevel)
                    {
                        continue;
                    }

                    if (!IsReplicaRelevantForView(replica, replicaView))
                    {
                        continue;
                    }

                    var relevance = replica.GetRelevance(replicaView);
                    replicaView.NumRelevantReplicas++;
                    replicaView.RelevantReplicas.Add(replica);
                    replicaView.RelevantReplicaPriorityAccumulator.Add(relevance * relevance * 2); // 2 to boost sending new Replicas
                }
            }
            _replicasInConstruction.Clear();

            // Actually destroy queued Replicas
            if (_replicasInDestruction.Count > 0)
            {
                try {
                    for (int i = 0; i < _replicaViews.Count; ++i)
                    {
                        var replicaView = _replicaViews[i];
                        if (replicaView.IsLoadingLevel)
                        {
                            continue;
                        }

                        SendDestroyedReplicasToReplicaView(replicaView);
                    }

                    foreach (var replica in _replicasInDestruction)
                    {
                        FreeLocalReplicaId(replica.Id);

                        _networkScene.RemoveReplica(replica);
                        replica.Id = ReplicaId.Invalid;
                        UnityEngine.Object.Destroy(replica.gameObject);
                    }
                } finally {
                    _replicasInDestruction.Clear();
                }
            }
        }