public void CallRPC(Packet.sendType sendType = Packet.sendType.culledbuffered, params object[] list)
{
RPCPacketData rpcData = GenerateRPCData(sendType, list);
Packet p = new Packet(Packet.pType.rpc, sendType, ENSSerialization.SerializeRPCPacketData(rpcData));
p.sendToAll = true;
p.relatesToNetObjID = net.networkID;
if (NetTools.IsMultiplayerGame() == false)
{
InvokeRPC(rpcData.ReturnArgs());
return;
}
if (net == null || !net.initialized)
{
queued.Add(sendType, list);
//Debug.Log("Rpc called before initialization. Adding to queue");
return;
}
NetClient.instanceClient.SendPacket(p);
}
public Packet GenerateRPCPacket(Packet.sendType sendType = Packet.sendType.culledbuffered, params object[] list)
{
RPCPacketData rpcData = new RPCPacketData(net.networkID, rpcIndex, NetTools.clientID, list);
Packet p = new Packet(Packet.pType.rpc, sendType, ENSSerialization.SerializeRPCPacketData(rpcData));
p.sendToAll = true;
p.relatesToNetObjID = net.networkID;
return(p);
}
public void HandlePacketFromClient(Packet pack, NetworkPlayer client, bool fromSelf = false)
{
if (pack == null)
{
return;
}
//if (fromSelf)
//{
// Debug.Log("SELF PACKET: " + pack.packetType);
//}
if (pack.packetOwnerID != client.clientID)// && client.tcpClient == NetClient.instanceClient.client) //if server dont change cause if it is -1 it has all authority.
{
pack.packetOwnerID = client.clientID;
}
if (client.clientID == NetClient.instanceClient.clientID) //Setup server authority.
{
pack.serverAuthority = true;
}
else
{
pack.serverAuthority = false;
}
if (pack.packetType == Packet.pType.rpc)
{
RPCPacketData rPD = ENSSerialization.DeserializeRPCPacketData(pack.packetData);
rPD.packetOwnerID = client.clientID;
pack.packetData = ENSSerialization.SerializeRPCPacketData(rPD);
}
if (pack.packetSendType == Packet.sendType.buffered || pack.packetSendType == Packet.sendType.culledbuffered)
{
//If it is a culledbuffered packet, if it is a netVarEdit packet, and it relates to the same netObj and is the RPC.
//Then cull the previous of the same RPC to prevent RPC spam
//This also happens with NetworkFields, even though network fields are generally *not buffered* the logic is here.
//The reason NetworkFields aren't buffered is because the NetServer already syncs them when a client joins.
if (pack.packetSendType == Packet.sendType.culledbuffered && (pack.packetType == Packet.pType.netVarEdit || pack.packetType == Packet.pType.rpc))
{
List <Packet> related = new List <Packet>();
if (bufferedPackets.ContainsKey(pack.relatesToNetObjID.ToString()))
{
related.AddRange(bufferedPackets[pack.relatesToNetObjID.ToString()]);
}
if (bufferedPackets.ContainsKey(pack.tag) && bufferedPackets[pack.tag] != null)
{
related.AddRange(bufferedPackets[pack.tag]);
}
foreach (Packet buff in related)
{
if (buff.relatesToNetObjID == pack.relatesToNetObjID && buff.packetType == pack.packetType)
{
if (buff.packetType == Packet.pType.netVarEdit)
{
if (buff.GetPacketData <NetworkFieldPacket>().fieldName == pack.GetPacketData <NetworkField>().fieldName)
{
RemoveBufferedPacket(buff);
}
}
else if (buff.packetType == Packet.pType.rpc)
{
if (buff.GetPacketData <RPCPacketData>().rpcIndex == pack.GetPacketData <RPCPacketData>().rpcIndex)
{
RemoveBufferedPacket(buff);
}
}
}
}
}
//Debug.Log("Buffered Packet");
AddBufferedPacket(pack);
}
UnityPacketHandler.instance.QueuePacket(pack);
if (pack.sendToAll || pack.usersToRecieve.Count > 0)
{
foreach (NetworkPlayer player in connections.ToArray())
{
//Debug.Log(player.clientID + " " + NetTools.clientID);
if (player == null || player.tcpClient == null || (player.clientID == NetTools.clientID))
{
continue;
}
if (pack.sendToAll == true || pack.usersToRecieve.Contains(player.clientID))
{
if (player.tcpClient.Connected)
{
try
{
SendPacket(player, pack);
}
catch (System.Exception e)
{
if (player.tcpClient.Connected)
{
Debug.LogError(e); //If we ain't connected anymore then it makes sense.
connections.Remove(player);
}
}
}
else
{
connections.Remove(player);
}
}
}
}
}
