public void OnNetworkInstantiatedServer(string type, string owner, NetDataWriter writer)
{
netStates.Clear();
netIDs.Clear();
netStates.Add(SerializeNetworkState(writer));
netIDs.Add(ID);
foreach (NetComponent nComponent in Owner.GetAllComponents <NetComponent>())
{
// Skip NetworkIdentity component since it's already processed.
if (nComponent is NetworkIdentity)
{
continue;
}
nComponent.Setup(CurrentNetworkID, owner == "SERVER");
NetworkObjects.TryAdd(CurrentNetworkID, nComponent);
CurrentNetworkID++;
if (nComponent is INetPersistable netPersist)
{
netStates.Add(NetLogicHelper.SerializePersistable(netPersist));
}
else
{
netStates.Add(null); // Padding for deserialization.
}
netIDs.Add(nComponent.ID);
}
}
// when scene loads, init all starting network objects
void LoadObjectsInNewScene()
{
List <GameObject> startingEntities =
GameObject.FindGameObjectWithTag("NetworkStartingEntities")?.GetComponent <NetworkStartingEntities>()?.startingEntities;
if (startingEntities == null)
{
return;
}
foreach (GameObject obj in startingEntities)
{
if (obj == null)
{
continue;
}
NetworkObjects.RemoveIncorrectComponents(obj);
NetworkSync sync = obj.GetComponent <NetworkSync>();
if (obj == gameObject)
{
sync.Initialize(sync.ObjectID, sync.NetworkType);
continue;
}
sync.Initialize(NextObjectID, sync.NetworkType);
obj.SetActive(true);
}
}
public void CompleteInitialization(NetworkObject networkObject)
{
lock (NetworkObjects)
{
NetworkObjects.Add(networkObject.NetworkId, networkObject);
NetworkObjectList.Add(networkObject);
}
List <Action <NetworkObject> > actions = null;
lock (missingObjectBuffer)
{
missingObjectBuffer.TryGetValue(networkObject.NetworkId, out actions);
missingObjectBuffer.Remove(networkObject.NetworkId);
}
if (actions == null)
{
return;
}
foreach (var action in actions)
{
action(networkObject);
}
}
// when scene loads, init all starting network objects
void LoadObjectsInNewScene(int sceneStartingObjectID)
{
List <GameObject> startingEntities =
GameObject.FindGameObjectWithTag("NetworkStartingEntities")?.GetComponent <NetworkStartingEntities>()?.startingEntities;
if (startingEntities == null)
{
return;
}
currentObjectID = sceneStartingObjectID;
foreach (GameObject obj in startingEntities)
{
// GameController doesn't follow the same rules
NetworkObjects.RemoveIncorrectComponents(obj);
NetworkSync sync = obj.GetComponent <NetworkSync>();
if (string.IsNullOrWhiteSpace(sync.NetworkType))
{
throw new InvalidTypeException($"NetworkType field is empty in starting network object {obj.name}");
}
if (obj == gameObject)
{
sync.Initialize(sync.ObjectID, sync.NetworkType);
continue;
}
sync.Initialize(NextObjectID, sync.NetworkType);
obj.SetActive(false);
}
StartCoroutine(LoadObjectsCoroutine(startingEntities));
}
public void OnNetworkInstantiatedClient(string type, bool isOwner, NetDataReader reader)
{
InstantiateData buffer = new InstantiateData(reader);
List <byte[]> netStates = buffer.NetStates;
uint[] netIDs = buffer.NetIDs;
// Handle any NetComponents on the GameObject.
int index = 1;
foreach (NetComponent nComponent in Owner.GetAllComponents <NetComponent>())
{
// Skip NetworkIdentity component since it's already processed.
if (nComponent is NetworkIdentity)
{
continue;
}
nComponent.Setup(netIDs[index], isOwner);
if (nComponent is INetPersistable persist && netStates[index] != null)
{
NetLogicHelper.RestorePersistable(persist, netStates[index]);
}
NetworkObjects.TryAdd(netIDs[index], nComponent);
index++;
}
}
public void Initialize()
{
networkObjects = GetComponent <NetworkObjects>();
// network handlers
natPunchEvent.NatIntroductionSuccess += (point, addrType, token) =>
{
var peer = netManager.Connect(point, ConnectionKey);
Debug.Log($"NatIntroductionSuccess. Connecting to peer: {point}, type: {addrType}, connection created: {peer != null}");
};
netEvent.PeerConnectedEvent += peer => { Debug.Log("PeerConnected: " + peer.EndPoint); };
netEvent.ConnectionRequestEvent += request => { request.AcceptIfKey(ConnectionKey); };
netEvent.NetworkReceiveEvent += (peer, reader, deliveryMethod) => {
netPacketProcessor.ReadAllPackets(reader, peer);
};
netEvent.PeerDisconnectedEvent += (peer, disconnectInfo) => { Debug.Log($"Peer {peer} Disconnected: {disconnectInfo.Reason}"); };
// packet handlers
netPacketProcessor.SubscribeReusable <NetworkMessagePacket, NetPeer>((packet, peer) =>
{
messages.SyncFromPacket(packet);
});
netPacketProcessor.SubscribeReusable <NetworkObjectDataPacket, NetPeer>((packet, peer) =>
{
data.SyncFromPacket(packet);
});
// connect
netManager = new NetManager(netEvent)
{
IPv6Enabled = IPv6Mode.Disabled,
NatPunchEnabled = true
};
netManager.NatPunchModule.Init(natPunchEvent);
netManager.Start();
LoadObjectsInNewScene(0);
}
void Awake()
{
Initialize(_NetworkPlayerPrefab, this.transform);
NetworkObjects.ObserveAdd().Subscribe(addEvent =>
{
ulong objectId = addEvent.Key;
Debug.Log("Added ObjectID: " + objectId + ", Players.Count: " + NetworkObjects.Count);
NetworkPlayer player = addEvent.Value;
player.transform.SetParent(this.transform);
if (player.IsOwner)
{
_LocalPlayerObjectId = objectId;
_OnSpawnedLocalPlayerSubject.OnNext(player);
}
})
.AddTo(this);
NetworkObjects.ObserveRemove().Subscribe(removeEvent =>
{
ulong objectId = removeEvent.Key;
Debug.Log("Removed ObjectID: " + objectId + ", Players.Count: " + NetworkObjects.Count);
if (_LocalPlayerObjectId.Equals(objectId))
{
_OnDespawnedLocalPlayerSubject.OnNext(Unit.Default);
}
})
.AddTo(this);
INetworkManager networkManager = _NetworkManagerObject.GetComponent <INetworkManager>();
if (networkManager != null)
{
networkManager.OnClientConnectedAsObservable()
.Where(_ => networkManager.IsServer)
.Subscribe(clientId =>
{
SpawnWithClientOwnership(clientId);
})
.AddTo(this);
networkManager.OnClientDisconnectedAsObservable()
.Where(_ => networkManager.IsServer)
.Subscribe(clientId =>
{
DespawnObjects(clientId);
})
.AddTo(this);
}
else
{
Debug.LogError("[SimpleMultiplayer] NetworkManager is null.");
}
}
public void NetClean()
{
List <uint> goNetIDs = NetIDs;
for (int i = 0; i < goNetIDs.Count; i++)
{
NetworkObjects.TryRemove(goNetIDs[i], out _);
SpawnedNetObjects.TryRemove(goNetIDs[i], out _);
}
Owner.OnDestroyInternal();
}
public void CompleteInitialization(NetworkObject networkObject)
{
lock (NetworkObjects)
{
if (!NetworkObjects.ContainsKey(networkObject.NetworkId))
{
NetworkObjects.Add(networkObject.NetworkId, networkObject);
NetworkObjectList.Add(networkObject);
}
}
}
/// <summary>
/// Used to manually remove a networkobject from the networker
/// </summary>
/// <param name="networkObject"></param>
public void ManualRemove(NetworkObject networkObject)
{
lock (NetworkObjects)
{
NetworkObjects.Remove(networkObject.NetworkId);
}
lock (NetworkObjectList)
{
NetworkObjectList.Remove(networkObject);
}
}
/// <summary>
/// Used to manually remove a bunch of networkobjects from the networker
/// </summary>
/// <param name="networkObjects"></param>
public void ManualRemove(List <NetworkObject> networkObjects)
{
foreach (NetworkObject obj in networkObjects)
{
lock (NetworkObjects)
{
NetworkObjects.Remove(obj.NetworkId);
}
}
foreach (NetworkObject obj in networkObjects)
{
lock (NetworkObjectList)
{
NetworkObjectList.Remove(obj);
}
}
}
void Awake()
{
Initialize(_NetworkStatePrefab, this.transform);
if (_NetworkServer != null)
{
_NetworkServer.OnServerStartedAsObservable()
.Subscribe(_ =>
{
SpawnWithServerOwnership();
})
.AddTo(this);
}
NetworkObjects.ObserveAdd().Subscribe(addEvent =>
{
_NetworkStateInstance = addEvent.Value;
_OnInitializedStateInstanceSubject.OnNext(_NetworkStateInstance);
_OnInitializedStateInstanceSubject.OnCompleted();
})
.AddTo(this);
}
private void HandleBinaryFrameMessage(FrameStream frame, NetworkingPlayer player)
{
byte routerId = ((Binary)frame).RouterId;
if (routerId == RouterIds.RPC_ROUTER_ID || routerId == RouterIds.BINARY_DATA_ROUTER_ID || routerId == RouterIds.CREATED_OBJECT_ROUTER_ID)
{
uint id = frame.StreamData.GetBasicType <uint>();
NetworkObject targetObject = null;
lock (NetworkObjects)
{
NetworkObjects.TryGetValue(id, out targetObject);
}
if (targetObject == null)
{
BufferMessageForMissingObject(id, routerId, frame, player);
}
else
{
ExecuteRouterAction(routerId, targetObject, (Binary)frame, player);
}
}
else if (routerId == RouterIds.NETWORK_OBJECT_ROUTER_ID)
{
NetworkObject.CreateNetworkObject(this, player, (Binary)frame);
}
else if (routerId == RouterIds.ACCEPT_MULTI_ROUTER_ID)
{
NetworkObject.CreateMultiNetworkObject(this, player, (Binary)frame);
}
else if (binaryMessageReceived != null)
{
binaryMessageReceived(player, (Binary)frame, this);
}
}
/// <summary>
/// 这个可以调用的messageReceived事件调用的包装器
/// A wrapper for the messageReceived event call that chindren of this can call
/// </summary>
protected void OnMessageReceived(NetworkingPlayer player, FrameStream frame)
{
// 客户端被服务器接收
if (frame.GroupId == MessageGroupIds.NETWORK_ID_REQUEST && this is IClient)
{
Time.SetStartTime(frame.TimeStep);
// 读取玩家ID， 创建客户端自己的NetworkingPlayer
Me = new NetworkingPlayer(frame.StreamData.GetBasicType <uint>(), "0.0.0.0", false, null, this);
Me.AssignPort(Port);
OnServerAccepted();
return;
}
// 收到ping
if (frame.GroupId == MessageGroupIds.PING || frame.GroupId == MessageGroupIds.PONG)
{
// 发送ping时的 发送者时间
long receivedTimestep = frame.StreamData.GetBasicType <long>();
DateTime received = new DateTime(receivedTimestep);
// 现在接收到反馈ping的时间 - 自己发送ping是的时间
TimeSpan ms = DateTime.UtcNow - received;
if (frame.GroupId == MessageGroupIds.PING)
{
// 反馈ping, 将发送ping时的 发送者时间 一起发给他
Pong(player, received);
}
else
{
// 接收都ping的反馈
OnPingRecieved(ms.TotalMilliseconds, player);
}
return;
}
// 二进制消息
if (frame is Binary)
{
if (frame.RoomId == 0)
{
byte routerId = ((Binary)frame).RouterId;
if (routerId == RouterIds.RPC_ROUTER_ID || routerId == RouterIds.BINARY_DATA_ROUTER_ID || routerId == RouterIds.CREATED_OBJECT_ROUTER_ID)
{
uint id = frame.StreamData.GetBasicType <uint>();
NetworkObject targetObject = null;
lock (NetworkObjects)
{
NetworkObjects.TryGetValue(id, out targetObject);
}
if (targetObject == null)
{
// 收到该网络对象的消息包
// 但是该玩家机器上还没有创建网络对象
// 就将该消息缓存器来，等待网络对象创建完再掉用
lock (missingObjectBuffer)
{
if (!missingObjectBuffer.ContainsKey(id))
{
missingObjectBuffer.Add(id, new List <Action <NetworkObject> >());
}
missingObjectBuffer[id].Add((networkObject) =>
{
ExecuteRouterAction(routerId, networkObject, (Binary)frame, player);
});
}
// TODO: If the server is missing an object, it should have a timed buffer
// that way useless messages are not setting around in memory
// TODO：如果服务器缺少一个对象，它应该有一个定时缓冲区
//这种无用的消息不会在内存中设置
return;
}
ExecuteRouterAction(routerId, targetObject, (Binary)frame, player);
}
// 创建网络对象
else if (routerId == RouterIds.NETWORK_OBJECT_ROUTER_ID)
{
NetworkObject.CreateNetworkObject(this, player, (Binary)frame);
}
// 在服务器接受客户端时，将服务器现有的所有网络对象 发给该玩家，让他创建
else if (routerId == RouterIds.ACCEPT_MULTI_ROUTER_ID)
{
NetworkObject.CreateMultiNetworkObject(this, player, (Binary)frame);
}
else if (binaryMessageReceived != null)
{
binaryMessageReceived(player, (Binary)frame, this);
}
}
else if (binaryMessageReceived != null)
{
binaryMessageReceived(player, (Binary)frame, this);
}
}
// 文本消息
else if (frame is Text && textMessageReceived != null)
{
textMessageReceived(player, (Text)frame, this);
}
if (messageReceived != null)
{
messageReceived(player, frame, this);
}
}
public ComboRoute(NetworkObjects.Route p)
{
this.p = p;
}
private static LineP getStartLine(Parcour parcour, NetworkObjects.Route type)
{
Line nl = null;
try
{
switch (type)
{
case NetworkObjects.Route.A:
{
nl = parcour.Line.Single(p => p.Type == (int)LineType.START_A); break;
}
case NetworkObjects.Route.B:
{
nl = parcour.Line.Single(p => p.Type == (int)LineType.START_B); break;
}
case NetworkObjects.Route.C:
{
nl = parcour.Line.Single(p => p.Type == (int)LineType.START_C); break;
}
case NetworkObjects.Route.D:
{
nl = parcour.Line.Single(p => p.Type == (int)LineType.START_D); break;
}
}
}
catch { }
LineP l=null;
if (nl != null)
{
l = new LineP();
l.start = new Vector(nl.A.longitude, nl.A.latitude, 0);
l.end = new Vector(nl.B.longitude, nl.B.latitude, 0);
l.orientation = new Vector(nl.O.longitude, nl.O.latitude, 0);
}
return l;
}
/// <summary>
/// Register a networked object with this networker
/// </summary>
/// <param name="networkObject">The object that is to be registered with this networker</param>
/// <returns><c>true</c> if the object was registered successfully, else <c>false</c> if it has already been registered</returns>
public bool RegisterNetworkObject(NetworkObject networkObject, uint forceId = 0)
{
uint id = currentNetworkObjectId;
lock (NetworkObjects)
{
// If we are forcing this object
if (forceId != 0)
{
if (NetworkObjects.ContainsKey(forceId))
{
return(false);
}
id = forceId;
if (!networkObject.RegisterOnce(id))
{
throw new BaseNetworkException("The supplied network object has already been assigned to a networker and has an id");
}
//AddNetworkObject(forceId, networkObject);
//NetworkObjectList.Add(networkObject);
}
else
{
do
{
if (NetworkObjects.ContainsKey(++currentNetworkObjectId))
{
continue;
}
if (!networkObject.RegisterOnce(currentNetworkObjectId))
{
// Backtrack since the next call to this method will increment before checking
currentNetworkObjectId--;
throw new BaseNetworkException("The supplied network object has already been assigned to a networker and has an id");
}
//AddNetworkObject(currentNetworkObjectId, networkObject);
//NetworkObjectList.Add(networkObject);
break;
} while (IsBound);
}
}
// Assign the network id to the network object
networkObject.RegisterOnce(id);
// When this object is destroyed it needs to remove itself from the list
networkObject.onDestroy += (NetWorker sender) =>
{
lock (NetworkObjects)
{
NetworkObjects.Remove(networkObject.NetworkId);
NetworkObjectList.Remove(networkObject);
}
};
return(true);
}
/// <summary>
/// A wrapper for the messageReceived event call that chindren of this can call
/// </summary>
protected void OnMessageReceived(NetworkingPlayer player, FrameStream frame)
{
if (frame.GroupId == MessageGroupIds.NETWORK_ID_REQUEST && this is IClient)
{
Time.SetStartTime(frame.TimeStep);
Me = new NetworkingPlayer(frame.StreamData.GetBasicType <uint>(), "0.0.0.0", false, null, this);
Me.AssignPort(Port);
OnServerAccepted();
return;
}
if (frame.GroupId == MessageGroupIds.PING || frame.GroupId == MessageGroupIds.PONG)
{
long receivedTimestep = frame.StreamData.GetBasicType <long>();
DateTime received = new DateTime(receivedTimestep);
TimeSpan ms = DateTime.UtcNow - received;
if (frame.GroupId == MessageGroupIds.PING)
{
Pong(player, received);
}
else
{
OnPingRecieved(ms.TotalMilliseconds, player);
}
return;
}
if (frame is Binary)
{
byte routerId = ((Binary)frame).RouterId;
if (routerId == RouterIds.RPC_ROUTER_ID || routerId == RouterIds.BINARY_DATA_ROUTER_ID || routerId == RouterIds.CREATED_OBJECT_ROUTER_ID)
{
uint id = frame.StreamData.GetBasicType <uint>();
NetworkObject targetObject = null;
lock (NetworkObjects)
{
NetworkObjects.TryGetValue(id, out targetObject);
}
if (targetObject == null)
{
lock (missingObjectBuffer)
{
if (!missingObjectBuffer.ContainsKey(id))
{
missingObjectBuffer.Add(id, new List <Action <NetworkObject> >());
}
missingObjectBuffer[id].Add((networkObject) =>
{
ExecuteRouterAction(routerId, networkObject, (Binary)frame, player);
});
}
// TODO: If the server is missing an object, it should have a timed buffer
// that way useless messages are not setting around in memory
return;
}
ExecuteRouterAction(routerId, targetObject, (Binary)frame, player);
}
else if (routerId == RouterIds.NETWORK_OBJECT_ROUTER_ID)
{
NetworkObject.CreateNetworkObject(this, player, (Binary)frame);
}
else if (routerId == RouterIds.ACCEPT_MULTI_ROUTER_ID)
{
NetworkObject.CreateMultiNetworkObject(this, player, (Binary)frame);
}
else if (binaryMessageReceived != null)
{
binaryMessageReceived(player, (Binary)frame, this);
}
}
else if (frame is Text && textMessageReceived != null)
{
textMessageReceived(player, (Text)frame, this);
}
if (messageReceived != null)
{
messageReceived(player, frame, this);
}
}
public RoleCombo(NetworkObjects.Access role)
{
this.role = role;
}
