private bool StorePendingPeer(P2PPeer peer)
{
bool flag = false;
if (peer.GetHostId() != P2PPeer.s_InvalidId)
{
for (int i = 0; i < this.m_Connections.Count; i++)
{
if (this.m_Connections[i] != null)
{
P2PPeer peer2 = this.m_Connections[i].m_Peer;
if (peer2.IsSameAddress(peer))
{
bool flag2 = !peer2.IsSameId(peer);
this.m_Connections[i].m_Peer.SetFrom(peer);
if (flag2)
{
this.OnConnected(this.m_Connections[i]);
}
flag = true;
break;
}
}
}
}
if (!flag)
{
this.m_PendingPeers.Add(peer);
return(true);
}
return(false);
}
public void ReplGiveOwnership(P2PPeer peer)
{
if (!this.ReplIsOwner() && this.ReplGetOwner() != P2PPeer.s_Invalid)
{
return;
}
if (ReplTools.IsPlayingAlone())
{
if (P2PLogFilter.logError)
{
Debug.LogError("Trying to give ownership ower " + base.gameObject.name + " while playing alone!", this);
}
return;
}
ReplicationComponent.s_Writer.StartMessage(7);
ReplicationComponent.s_Writer.Write(base.gameObject);
ReplicationComponent.s_Writer.Write(peer.GetHostId());
ReplicationComponent.s_Writer.FinishMessage();
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("ReplGiveOwnership to {0} called for {1} guid: {2}", peer.GetHostId(), base.name, this.GetGuidComponent.GetGuid()), base.gameObject);
}
P2PSession.Instance.SendWriterTo(peer, ReplicationComponent.s_Writer, 0);
this.m_TransferringOwnershipTo = peer;
}
public void OnPeerDisconnected(P2PPeer peer)
{
if (!ReplTools.AmIMaster())
{
return;
}
this.DestroyPeerRepresentationRelatedObjects(peer);
this.m_GameObjectMapLock = true;
Dictionary <GameObject, ReplicationComponent> .Enumerator enumerator = this.m_GameObjectMap.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair <GameObject, ReplicationComponent> keyValuePair = enumerator.Current;
ReplicationComponent value = keyValuePair.Value;
if (!(value == null) && value.ReplGetOwner() == peer)
{
if (value.ReplCanChangeOwnership())
{
value.ReplRequestOwnership();
}
else
{
UnityEngine.Object.Destroy(value.gameObject);
}
}
}
enumerator.Dispose();
this.m_GameObjectMapLock = false;
}
public virtual void Initialize(P2PPeer peer, int networkConnectionId, HostTopology hostTopology)
{
this.m_Writer = new P2PNetworkWriter();
this.m_Reader = new P2PNetworkReader();
this.m_ConnectionId = networkConnectionId;
this.m_Peer = peer;
int channelCount = hostTopology.DefaultConfig.ChannelCount;
int packetSize = (int)hostTopology.DefaultConfig.PacketSize;
if (hostTopology.DefaultConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4)
{
throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
}
this.m_Channels = new P2PChannelBuffer[channelCount];
for (int i = 0; i < channelCount; i++)
{
ChannelQOS channelQOS = hostTopology.DefaultConfig.Channels[i];
int bufferSize = packetSize;
if (channelQOS.QOS == QosType.ReliableFragmented || channelQOS.QOS == QosType.UnreliableFragmented)
{
bufferSize = (int)(hostTopology.DefaultConfig.FragmentSize * 128);
}
this.m_Channels[i] = new P2PChannelBuffer(this, bufferSize, (byte)i, P2PConnection.IsReliableQoS(channelQOS.QOS));
}
}
private void UpdateLocalPeerId(P2PPeer peer)
{
if (this.LocalPeer.GetHostId() != peer.GetHostId())
{
this.LocalPeer.SetHostId(peer.GetHostId());
}
}
public float GetRelevance(P2PPeer peer)
{
float result = 0f;
this.m_Relevance.TryGetValue(peer, out result);
return(result);
}
public P2PPeer ReadPeer()
{
P2PPeer p2PPeer = new P2PPeer();
p2PPeer.SetHostId(this.ReadInt16());
p2PPeer.m_Address = this.ReadPeerAddress();
return(p2PPeer);
}
public void Add(P2PPeer peer)
{
DebugUtils.Assert(this.count < this.peers.Length, true);
P2PPeer[] array = this.peers;
int num = this.count;
this.count = num + 1;
array[num] = peer;
}
public float CalculateRelevance(P2PPeer peer, out Relevance.ERelevanceCalculationResult result)
{
if (peer.m_Representation == null)
{
result = Relevance.ERelevanceCalculationResult.Inactive;
return(0f);
}
if (!base.GetReplicationComponent().enabled&& !peer.IsLocalPeer())
{
result = Relevance.ERelevanceCalculationResult.Inactive;
return(0f);
}
float b = peer.m_Representation.GetWorldPosition().Distance(this.GetRelevanceReferencePosition());
float num = this.m_Relevance.ContainsKey(peer) ? this.m_Relevance[peer] : 0f;
float num2 = -1f;
for (int i = 0; i < this.m_CustomCalculators.Length; i++)
{
float num3 = this.m_CustomCalculators[i].CalculateRelevance(peer.m_Representation, peer == base.ReplGetOwner());
if (num3 != -1f)
{
num2 = System.Math.Max(num3, num2);
}
}
if (num2 == -1f)
{
num2 = CJTools.Math.GetProportionalClamp(1f, 0f, b, this.GetMaxRelevanceRange(), this.GetMinRelevanceRange());
}
if (num2 <= 0.1f)
{
if (num > 0.1f)
{
result = Relevance.ERelevanceCalculationResult.ToDeactivate;
}
else
{
result = Relevance.ERelevanceCalculationResult.Inactive;
}
}
else if (num2 >= 0.2f)
{
if (num < 0.2f)
{
result = Relevance.ERelevanceCalculationResult.ToActivate;
}
else
{
result = Relevance.ERelevanceCalculationResult.Active;
}
}
else
{
result = Relevance.ERelevanceCalculationResult.NoChange;
}
this.m_Relevance[peer] = num2;
return(num2);
}
public void OnRelevanceDeactivated(P2PPeer peer)
{
Relevance.OnRelevanceDeactivatedDelegate onRelevanceDeactivatedEvent = this.OnRelevanceDeactivatedEvent;
if (onRelevanceDeactivatedEvent == null)
{
return;
}
onRelevanceDeactivatedEvent(peer);
}
public static void ReplGiveOwnership(this IReplicatedBehaviour repl_behaviour, P2PPeer peer)
{
ReplicationComponent replicationComponent = repl_behaviour.GetReplicationComponent();
if (replicationComponent == null)
{
return;
}
replicationComponent.ReplGiveOwnership(peer);
}
private void OnRelevanceActivated(P2PPeer peer)
{
if (this.ReplIsOwner() && peer != ReplTools.GetLocalPeer())
{
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("OnRelevanceActivated called for peer {0} {1} guid {2}", peer.GetHostId(), base.name, this.GetGuidComponent.GetGuid()));
}
Replicator.Singleton.SpawnForPeer(base.gameObject, peer);
}
}
private P2PConnection FindConnection(P2PPeer peer)
{
for (int i = 0; i < this.m_Connections.Count; i++)
{
if (this.m_Connections[i] != null && this.m_Connections[i].m_Peer == peer)
{
return(this.m_Connections[i]);
}
}
return(null);
}
public P2PPeer GetSessionMaster()
{
P2PPeer p2PPeer = this.LocalPeer;
for (int i = 0; i < this.m_Connections.Count; i++)
{
if (this.m_Connections[i] != null && this.m_Connections[i].m_Peer.IsValid() && (p2PPeer == null || this.m_Connections[i].m_Peer.GetHostId() < p2PPeer.GetHostId()))
{
p2PPeer = this.m_Connections[i].m_Peer;
}
}
return(p2PPeer);
}
public bool DespawnForPeer(ReplicationComponent obj, P2PPeer peer)
{
P2PNetworkWriter p2PNetworkWriter = this.BuildDespawnWriter(obj);
if (p2PNetworkWriter != null)
{
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("DespawnForPeer [{0}] called for {1} guid: {2}", peer.GetHostId(), obj.name, obj.GetGuidComponent.GetGuid()), obj);
}
P2PSession.Instance.SendWriterTo(peer, p2PNetworkWriter, 0);
}
return(p2PNetworkWriter != null);
}
public bool SpawnForPeerAndGiveOwnership(GameObject obj, P2PPeer peer)
{
P2PNetworkWriter p2PNetworkWriter = this.BuildSpawnWriter(obj, true);
if (p2PNetworkWriter == null)
{
return(false);
}
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("SpawnForPeerAndGiveOwnership called for {0} with guid {1}", obj.name, obj.GetComponent <GuidComponent>().GetGuid()), obj);
}
P2PSession.Instance.SendWriterTo(peer, p2PNetworkWriter, 0);
return(true);
}
public static void RegisterForPeer(this IPeerWorldRepresentation representation, P2PPeer peer)
{
if (peer.m_Representation == null)
{
peer.m_Representation = representation;
}
if (peer == ReplTools.GetLocalPeer())
{
if (representation.IsReplicated())
{
IPeerWorldRepresentationHelper.s_LocalNetPlayer = representation;
return;
}
IPeerWorldRepresentationHelper.s_LocalOfflinePlayer = representation;
}
}
public float ReplGetReplicationInterval(P2PPeer peer)
{
if (!(this.GetRelevanceComponent != null))
{
return(this.GetReplicationIntervalMin());
}
if (peer == ReplTools.GetLocalPeer())
{
if (this.m_LocalReplicationIntervalUpdateTime < Time.time)
{
this.m_LocalReplicationIntervalNow = this.CalculateReplicationInterval(peer);
this.m_LocalReplicationIntervalUpdateTime = Time.time;
}
return(this.m_LocalReplicationIntervalNow);
}
return(this.CalculateReplicationInterval(peer));
}
public void OnRequestOwnership(P2PNetworkMessage netMsg)
{
GameObject gameObject = netMsg.m_Reader.ReadGameObject();
if (gameObject)
{
ReplicationComponent replComponentForGameObject = this.GetReplComponentForGameObject(gameObject, true);
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("OnRequestOwnership called for {0} guid: {1}", replComponentForGameObject.name, replComponentForGameObject.GetGuidComponent.GetGuid()), gameObject);
}
ReplicationComponent.s_DeserializedComponent = replComponentForGameObject;
P2PPeer peerById = ReplTools.GetPeerById(netMsg.m_Reader.ReadInt16());
replComponentForGameObject.ReplOnChangedOwner(peerById);
ReplicationComponent.s_DeserializedComponent = null;
}
}
public static T GetPlayerComponent <T>(this GameObject player_object) where T : MonoBehaviour
{
if (player_object == Player.Get().gameObject)
{
return(ReplicatedLogicalPlayer.s_LocalLogicalPlayer.GetPlayerComponent <T>());
}
P2PPeer p2PPeer = player_object.ReplGetOwner();
DebugUtils.Assert(p2PPeer != null, true);
foreach (ReplicatedLogicalPlayer replicatedLogicalPlayer in ReplicatedLogicalPlayer.s_AllLogicalPlayers)
{
if (replicatedLogicalPlayer.ReplGetOwner() == p2PPeer)
{
return(replicatedLogicalPlayer.GetPlayerComponent <T>());
}
}
return(default(T));
}
public void OnReplicatorUpdate(bool force_update = false)
{
if (!base.enabled || !base.gameObject.activeSelf)
{
return;
}
if (!this.ReplIsOwner() && (this.ReplGetOwner().IsValid() || !ReplTools.AmIMaster()))
{
return;
}
if (force_update || this.m_LastReplicationTimeReal < Time.realtimeSinceStartup - this.GetReplicationIntervalMin())
{
this.m_LastReplicationTime = Time.time;
this.m_LastReplicationTimeReal = Time.realtimeSinceStartup;
if (this.GetRelevanceComponent)
{
ReplicationComponent.s_SendToPeers.Reset();
foreach (KeyValuePair <P2PPeer, float> keyValuePair in this.GetRelevanceComponent.m_Relevance)
{
P2PPeer key = keyValuePair.Key;
if (!key.IsLocalPeer() && keyValuePair.Value > 0.1f)
{
float num = 0f;
this.m_LastPeerReplicationTime.TryGetValue(key, out num);
if (num + this.CalculateReplicationInterval(keyValuePair.Key) < Time.time)
{
this.m_LastPeerReplicationTime[key] = Time.time;
ReplicationComponent.s_SendToPeers.Add(key);
}
}
}
if (ReplicationComponent.s_SendToPeers.count > 0)
{
this.ReplicationSend(false, ReplicationComponent.s_SendToPeers);
return;
}
}
else
{
this.ReplicationSend(false, null);
}
}
}
public void SendWriterTo(P2PPeer peer, P2PNetworkWriter writer, int channel_id)
{
P2PConnection p2PConnection = this.FindConnection(peer);
if (p2PConnection == null || !p2PConnection.m_IsReady)
{
if (P2PLogFilter.logError)
{
if (p2PConnection == null)
{
Debug.LogError("Trying to send data without connection for peer: " + peer.GetHostId());
return;
}
Debug.LogError("Trying to send data on unready connection connection_id:" + p2PConnection.m_ConnectionId);
}
return;
}
p2PConnection.SendWriter(writer, channel_id);
}
private void DestroyPeerRepresentationRelatedObjects(P2PPeer peer)
{
IReplicatedBehaviour[] componentsInChildren = (peer.m_Representation as Component).gameObject.GetComponentsInChildren <IReplicatedBehaviour>();
HashSet <GameObject> hashSet = new HashSet <GameObject>();
IReplicatedBehaviour[] array = componentsInChildren;
for (int i = 0; i < array.Length; i++)
{
GameObject gameObject = (array[i] as Component).gameObject;
if (!hashSet.Contains(gameObject))
{
hashSet.Add(gameObject);
}
}
foreach (GameObject obj in hashSet)
{
UnityEngine.Object.Destroy(obj);
}
}
public void OnPeerConnected(P2PPeer peer)
{
if (peer.GetHostId() == P2PPeer.s_InvalidId)
{
return;
}
this.m_GameObjectMapLock = true;
Dictionary <GameObject, ReplicationComponent> .Enumerator enumerator = this.m_GameObjectMap.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair <GameObject, ReplicationComponent> keyValuePair = enumerator.Current;
ReplicationComponent value = keyValuePair.Value;
if (!(value == null) && !(value.GetRelevanceComponent != null) && (value.ReplIsOwner() || (ReplTools.AmIMaster() && value.ReplGetOwner() == P2PPeer.s_Invalid)))
{
this.SpawnForPeer(value.gameObject, peer);
}
}
enumerator.Dispose();
this.m_GameObjectMapLock = false;
}
private void OnPeerDisconnect(P2PNetworkMessage net_msg)
{
P2PConnection connection = net_msg.m_Connection;
P2PPeer p2PPeer = (connection != null) ? connection.m_Peer : null;
if (p2PPeer != null)
{
Dictionary <GameObject, Relevance> .Enumerator enumerator = this.m_Components.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair <GameObject, Relevance> keyValuePair = enumerator.Current;
Relevance value = keyValuePair.Value;
if (value)
{
value.OnPeerDisconnected(p2PPeer);
}
}
enumerator.Dispose();
}
}
public void ReplOnChangedOwner(P2PPeer peer)
{
if (this.m_OwnerPeer != peer)
{
bool flag = this.m_OwnerPeer.IsValid();
bool was_owner = this.m_OwnerPeer.IsLocalPeer();
this.m_OwnerPeer = peer;
if (this.m_TransferringOwnershipTo != null)
{
this.m_TransferringOwnershipTo = null;
}
if (flag)
{
IReplicatedBehaviour[] getReplBehaviours = this.GetReplBehaviours;
for (int i = 0; i < getReplBehaviours.Length; i++)
{
getReplBehaviours[i].ReplOnChangedOwner(was_owner);
}
}
}
}
public static float GetDistToClosestPlayer2D(GameObject obj)
{
float num = float.MaxValue;
if (ReplTools.GetLocalPeer().m_Representation != null)
{
num = ReplTools.GetLocalPeer().m_Representation.GetWorldPosition().Distance2D(obj.transform.position);
}
for (int i = 0; i < ReplTools.GetRemotePeers().Count; i++)
{
P2PPeer p2PPeer = ReplTools.GetRemotePeers()[i];
if (p2PPeer != null && p2PPeer.m_Representation != null)
{
float num2 = p2PPeer.m_Representation.GetWorldPosition().Distance2D(obj.transform.position);
if (num2 < num)
{
num = num2;
}
}
}
return(num);
}
public void OnGiveOwnership(P2PNetworkMessage netMsg)
{
byte[] array;
GameObject gameObject = netMsg.m_Reader.ReadGameObjectAndGuid(out array);
if (gameObject)
{
ReplicationComponent replComponentForGameObject = this.GetReplComponentForGameObject(gameObject, true);
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("OnGiveOwnership called for {0} guid: {1}", replComponentForGameObject.name, replComponentForGameObject.GetGuidComponent.GetGuid()), gameObject);
}
ReplicationComponent.s_DeserializedComponent = replComponentForGameObject;
P2PPeer peerById = ReplTools.GetPeerById(netMsg.m_Reader.ReadInt16());
if (peerById == ReplTools.GetLocalPeer())
{
replComponentForGameObject.ReplRequestOwnership();
}
else
{
replComponentForGameObject.ReplOnChangedOwner(peerById);
}
ReplicationComponent.s_DeserializedComponent = null;
return;
}
P2PNetworkWriter p2PNetworkWriter = new P2PNetworkWriter();
p2PNetworkWriter.StartMessage(8);
p2PNetworkWriter.Write(array, GuidComponent.GUID_BYTES_CNT);
p2PNetworkWriter.FinishMessage();
if (P2PLogFilter.logWarn)
{
Debug.LogWarning("Did not find target for give ownership message for " + new Guid(array));
}
P2PSession.Instance.SendWriterTo(netMsg.m_Connection.m_Peer, p2PNetworkWriter, 0);
}
private void OnRelevanceDeactivated(P2PPeer peer)
{
if (this.ReplIsOwner() && peer != ReplTools.GetLocalPeer())
{
if (P2PLogFilter.logPedantic)
{
Debug.Log(string.Format("OnRelevanceDeactivated called for peer {0} {1} guid {2} CanBeRemovedByRelevance {3}", new object[]
{
peer.GetHostId(),
base.name,
this.GetGuidComponent.GetGuid(),
this.GetRelevanceComponent.CanBeRemovedByRelevance(false)
}));
}
if (this.GetRelevanceComponent.CanBeRemovedByRelevance(false))
{
Replicator.Singleton.DespawnForPeer(this, peer);
return;
}
ReplicationComponent.s_SendToPeers.Reset();
ReplicationComponent.s_SendToPeers.Add(peer);
this.ReplicationSend(false, ReplicationComponent.s_SendToPeers);
}
}
public bool IsSameAddress(P2PPeer other)
{
return(this.m_Address.Equals(other.m_Address));
}
