public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
if (isServer)
{
if (messageType == UnconnectedMessageType.Broadcast)
{
// 服务端接收到广播寻找请求
if (reader.GetUShort() == transport.broadcastKey)
{
//Debug.Log("Server 接收到Broadcast");
_serverWriter.Reset();
_serverWriter.Put(transport.broadcastKey);
_serverWriter.Put(transport.broadcastdata);
transport.netManager.SendUnconnectedMessage(_serverWriter, remoteEndPoint);
}
}
}
else
{
if (reader.GetUShort() == transport.broadcastKey)
{
//Debug.Log("Client 接收到Broadcast返回");
//客户端接收到来自服务端的寻找请求回复
eventQueue.Enqueue(new TransportEventData()
{
type = ENetworkEvent.DiscoveryEvent,
reader = reader,
endPoint = remoteEndPoint
});
}
}
}
/// <inheritdoc/>
public override void Read(NetPacketReader message)
{
base.Read(message);
try {
NetworkID = message.GetUInt();
MethodID = message.GetUShort();
RPCInfo = Network.InstanceType == NetInstanceType.Server
? (RPCInfo)Network.ServerRPCLookupTable.GetRPCInfo(MethodID)
: Network.ClientRPCLookupTable.GetRPCInfo(MethodID);
ParametersNum = RPCInfo.ParameterTypes.Length;
if (Parameters.Length < ParametersNum)
{
Parameters = new object[ParametersNum];
}
for (int i = 0; i < ParametersNum; i++)
{
Parameters[i] = NetData.Read(RPCInfo.ParameterTypes[i], message);
}
} catch (Exception e) {
throw new MalformedPacketException("Failed to read packet.", e);
}
}
private void _serverListener_NetworkReceiveUnconnectedEvent(System.Net.IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
// Send back server data
if (reader.GetUShort() == broadcastKey)
{
_serverWriter.Reset();
_serverWriter.Put(broadcastKey);
_serverWriter.Put(data);
_server.SendUnconnectedMessage(_serverWriter, remoteEndPoint);
}
}
private void _clientListener_NetworkReceiveUnconnectedEvent(System.Net.IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
// Receive server data
if (reader.GetUShort() == broadcastKey)
{
if (onReceivedBroadcast != null)
{
onReceivedBroadcast.Invoke(remoteEndPoint, reader.GetString());
}
}
}
void ReceivePackage(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
NetDataWriter writer = new NetDataWriter();
ushort msgid = reader.GetUShort();
print("receivepackage event: " + msgid);
switch (msgid)
{
case 1: //register to host
{
RegisterPlayer(reader);
}
break;
case 101: //create networkObject
{
int objectId;
int lobjectId = reader.GetUShort();
ObjectData objectData = reader.GetBytesWithLength().ToStructure <ObjectData>();
do
{
objectId = UnityEngine.Random.Range(1000000, 9999999);
} while (NetworkObjects.ContainsKey(objectId));
objectData.objectId = objectId;
var netObj = new NetworkObjectData(objectId, objectData);
NetworkObjects.Add(objectId, netObj);
netObj.SendObjectData(peer, writer);
writer.Put(lobjectId);
client.SendToAll(writer, DeliveryMethod.ReliableOrdered);
}
break;
}
}
void ReceivePackage(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
NetDataWriter writer = new NetDataWriter();
ushort msgid = reader.GetUShort();
print("receivepackage event: " + msgid);
switch (msgid)
{
case 1:
{
ColorPacket result = reader.GetBytesWithLength().ToStructure <ColorPacket>();
currentColor = result.ToColor();
UnityThread.executeInUpdate(() => {
RefreshColor();
});
}
break;
}
}
//protected void WritePlayerData(NetDataWriter writer)
//{
// writer.Put(id);
// writer.Put(displayName);
// writer.Put(this.settings.gameKey);
// writer.Put(this.settings.gameVersion);
// writer.Put(this.settings.platform);
//}
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader packetReader, DeliveryMethod deliveryMethod)
{
byte clientInstruction = packetReader.GetByte();
if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_LIST)
{
if (roomList == null)
{
roomList = new LNSRoomList();
}
JsonUtility.FromJsonOverwrite(packetReader.GetString(), roomList);
if (onRoomListReceived != null)
{
threadDispatcher.Add(() => onRoomListReceived(roomList));
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_CREATED)
{
isInActiveRoom = true;
_lastConnectedRoom = packetReader.GetString();
if (onRoomCreated != null)
{
threadDispatcher.Add(() => onRoomCreated());
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_DISCONNECTED)
{
if (onDisconnectedFromRoom != null)
{
threadDispatcher.Add(() => onDisconnectedFromRoom());
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_CREATE)
{
byte reason = packetReader.GetByte();
if (onRoomCreateFailed != null)
{
threadDispatcher.Add(() => onRoomCreateFailed((ROOM_FAILURE_CODE)reason));
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_JOIN)
{
byte reason = packetReader.GetByte();
if (onRoomJoinFailed != null)
{
threadDispatcher.Add(() => onRoomJoinFailed((ROOM_FAILURE_CODE)reason));
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_REJOIN)
{
byte reason = packetReader.GetByte();
if (onRoomRejoinFailed != null)
{
threadDispatcher.Add(() => onRoomRejoinFailed((ROOM_FAILURE_CODE)reason));
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_JOINED)
{
isInActiveRoom = true;
_lastConnectedRoom = packetReader.GetString();
if (onRoomJoined != null)
{
threadDispatcher.Add(() => onRoomJoined());
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_REJOINED)
{
isInActiveRoom = true;
_lastConnectedRoom = packetReader.GetString();
if (onRoomRejoined != null)
{
threadDispatcher.Add(() => onRoomRejoined());
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_RANDOM_JOIN)
{
isInActiveRoom = false;
if (onRandomRoomJoinFailed != null)
{
threadDispatcher.Add(() => onRandomRoomJoinFailed());
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_MASTERCLIENT_CHANGED)
{
_lastConnectedRoomMasterClient = packetReader.GetString();
localClient.isMasterClient = isLocalPlayerMasterClient = (_lastConnectedRoomMasterClient == id);
if (onMasterClientUpdated != null)
{
try
{
if (isLocalPlayerMasterClient)
{
threadDispatcher.Add(() =>
{
onMasterClientUpdated(localClient);
});
}
else
{
for (int i = 0; i < clients.Count; i++)
{
if (clients[i].id == _lastConnectedRoomMasterClient)
{
clients[i].isMasterClient = true;
LNSClient client = clients[i];
threadDispatcher.Add(() =>
{
onMasterClientUpdated(client);
});
}
else
{
clients[i].isMasterClient = false;
}
}
}
}catch (System.Exception ex)
{
Debug.LogError(ex.Message + " " + ex.StackTrace);
}
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_PLAYER_CONNECTED)
{
string client_id = packetReader.GetString();
string client_displayName = packetReader.GetString();
CLIENT_PLATFORM client_platform = (CLIENT_PLATFORM)packetReader.GetByte();
int client_netID = packetReader.GetInt();
LNSClient client = null;
for (int i = 0; i < clients.Count; i++)
{
if (clients[i].id == client_id)
{
client = clients[i];
client.displayName = client_displayName;
client.platform = client_platform;
client.networkID = client_netID;
break;
}
}
if (client == null)
{
client = new LNSClient();
client.id = client_id;
client.displayName = client_displayName;
client.platform = client_platform;
client.networkID = client_netID;
clients.Add(client);
}
client.isConnected = true;
if (onPlayerConnected != null)
{
threadDispatcher.Add(() =>
{
onPlayerConnected(client);
});
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_PLAYER_DISCONNECTED)
{
string client_id = packetReader.GetString();
for (int i = 0; i < clients.Count; i++)
{
if (clients[i].id == client_id)
{
clients[i].isConnected = false;
if (onPlayerDisconnected != null)
{
threadDispatcher.Add(() =>
{
onPlayerDisconnected(clients[i]);
});
}
return;
}
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_CACHE_DATA)
{
LNSReader reader = LNSReader.GetFromPool();
string key = packetReader.GetString();
byte[] data = packetReader.GetRemainingBytes();
reader.SetSource(data);
if (persistentData.ContainsKey(key))
{
persistentData[key] = data;
}
else
{
persistentData.Add(key, data);
}
if (dataReceiver != null)
{
threadDispatcher.Add(() =>
{
try
{
dataReceiver.OnCachedDataReceived(key, reader);
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + " " + ex.StackTrace);
}
reader.Recycle();
});
}
}
else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_RAW)
{
string fromid = packetReader.GetString();
for (int i = 0; i < clients.Count; i++)
{
if (fromid == clients[i].id)
{
if (dataReceiver != null)
{
ushort eventCode = packetReader.GetUShort();
LNSReader reader = LNSReader.GetFromPool();
LNSClient fromClient = clients[i];
DeliveryMethod _deliveryMethod = deliveryMethod;
reader.SetSource(packetReader.GetRemainingBytes());
threadDispatcher.Add(() =>
{
try
{
dataReceiver.OnEventRaised(fromClient, eventCode, reader, _deliveryMethod);
}
catch (System.Exception ex) {
Debug.LogError(ex.Message + " " + ex.StackTrace);
}
reader.Recycle();
});
}
break;
}
}
}
packetReader.Recycle();
}
void ReceivePackage(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
client.Statistics.BytesReceived += (ulong)reader.RawDataSize;
client.Statistics.PacketsReceived++;
NetDataWriter writer = new NetDataWriter();
ushort msgid = reader.GetUShort();
Debug.Log(msgid);
switch (msgid)
{
case 1: //register to server
var networkId = reader.GetInt();
var playerId = reader.GetInt();
var isHost = reader.GetBool();
var charId = 0;
var playerColor = _myColor;
var pName = _myName;
MyNetworkId = networkId;
IsHost = isHost;
InitPlayer(networkId, playerId, pName, isHost, charId, playerColor);
writer.Put((ushort)1);
writer.Put(playerId);
writer.Put(pName);
writer.Put(isHost);
writer.Put(charId);
writer.Put(playerColor.r);
writer.Put(playerColor.g);
writer.Put(playerColor.b);
Send(writer, DeliveryMethod.ReliableOrdered);
writer.Reset();
LobbyManager.Instance.NeedUpdate = true;
break;
case 2: //register new player;
var newNetworkId = reader.GetInt();
var newPlayerId = reader.GetInt();
var npName = reader.GetString();
var nIsHost = reader.GetBool();
var newCharId = reader.GetInt();
var newPlayerColor = new Color(
reader.GetFloat(),
reader.GetFloat(),
reader.GetFloat());
InitPlayer(newNetworkId, newPlayerId, npName, nIsHost, newCharId, newPlayerColor);
LobbyManager.Instance.NeedUpdate = true;
break;
case 3: //remove disconnected player
var rnid = reader.GetInt();
List <int> plrs = new List <int>();
foreach (var pl in Players)
{
if (pl.Value.networkId == rnid)
{
plrs.Add(pl.Key);
}
}
foreach (var i in plrs)
{
Players.Remove(i);
}
foreach (var no in NetworkObjects)
{
if (no.Value.networkId == rnid)
{
objectsToDestroy.Add(no.Key);
}
}
LobbyManager.Instance.NeedUpdate = true;
break;
case 4:
Players[reader.GetInt()].ReadPlayerData(reader);
LobbyManager.Instance.NeedUpdate = true;
break;
case 101:
var OBobjectType = reader.GetInt();
var OBobjectId = reader.GetInt();
var OBplayerId = reader.GetInt();
var OBnetId = reader.GetInt();
var OBposX = reader.GetFloat();
var OBposY = reader.GetFloat();
var OBposZ = reader.GetFloat();
var OBrotX = reader.GetFloat();
var OBrotY = reader.GetFloat();
var OBrotZ = reader.GetFloat();
var OBrotW = reader.GetFloat();
var OBpos = new Vector3(OBposX, OBposY, OBposZ);
var OBrot = new Quaternion(OBrotX, OBrotY, OBrotZ, OBrotW);
var OBnetObj = objectDataFactory.createObjectData(
OBobjectType,
OBnetId,
OBplayerId,
OBobjectId,
OBpos,
OBrot);
objectsToCreate.Add(OBnetObj);
break;
case 102:
var objectToDelete = reader.GetInt();
objectsToDestroy.Add(objectToDelete);
break;
case 103:
var UobjectId = reader.GetInt();
if (NetworkObjects.ContainsKey(UobjectId))
{
NetworkObjects[UobjectId].ReadData(reader);
}
break;
case 201:
var rpcTarget = reader.GetByte();
var rpcName = reader.GetString();
var rpcObjectId = reader.GetInt();
rpcList.Add(new Tuple <string, int, byte[]>(rpcName, rpcObjectId, reader.GetRemainingBytes()));
break;
case 301:
var levelId = reader.GetInt();
LevelToLoad = levelId;
break;
}
reader.Recycle();
}
private static void OnListenerOnNetworkReceiveEvent(NetPeer fromPeer, NetPacketReader dataReader,
DeliveryMethod deliveryMethod)
{
ushort msgid = dataReader.GetUShort();
NetDataWriter writer = new NetDataWriter();
switch (msgid)
{
case 1:
var playerId = dataReader.GetInt();
var pName = dataReader.GetString();
var isHost = dataReader.GetBool();
var charId = dataReader.GetInt();
var pColorR = dataReader.GetFloat();
var pColorG = dataReader.GetFloat();
var pColorB = dataReader.GetFloat();
var player = new Player(fromPeer, playerId, isHost, pName, charId, pColorR, pColorG, pColorB);
Players.Add(playerId, player);
player.SendNewPlayerData(writer);
SendOthers(fromPeer, writer, DeliveryMethod.ReliableOrdered);
Console.WriteLine("registering player " + pName + " pid " + playerId);
break;
case 101: //create networkObject
int objectId;
do
{
objectId = rand.Next(1000000, 9999999);
} while (NetworkObjects.ContainsKey(objectId));
var netObj = new NetworkObject(
fromPeer,
dataReader.GetInt(),
objectId,
dataReader.GetInt(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat());
NetworkObjects.Add(objectId, netObj);
netObj.SendObjectData(writer);
server.SendToAll(writer, DeliveryMethod.ReliableOrdered);
break;
case 102:
var objectToDelete = dataReader.GetInt();
NetworkObjects.Remove(objectToDelete);
writer.Put((ushort)102);
writer.Put(objectToDelete);
server.SendToAll(writer, DeliveryMethod.ReliableOrdered);
break;
case 103:
var objectToUpdate = dataReader.GetInt();
if (NetworkObjects.ContainsKey(objectToUpdate))
{
NetworkObjects[objectToUpdate].ReadData(dataReader);
NetworkObjects[objectToUpdate].WriteData(writer);
SendOthers(fromPeer, writer, DeliveryMethod.Unreliable);
}
break;
case 201:
byte[] data = new byte[dataReader.UserDataSize];
Array.Copy(dataReader.RawData, dataReader.UserDataOffset, data, 0, dataReader.UserDataSize);
var target = dataReader.GetByte();
var rpcName = dataReader.GetString();
var rpcObjectId = dataReader.GetInt();
switch (target)
{
case 0:
NetworkObjects[rpcObjectId].peer.Send(data, DeliveryMethod.ReliableUnordered);
break;
case 1:
SendOthers(NetworkObjects[rpcObjectId].peer, data, DeliveryMethod.ReliableUnordered);
break;
case 2:
server.SendToAll(data, DeliveryMethod.ReliableUnordered);
break;
}
break;
}
dataReader.Recycle();
}
