public static async Task <int> SendDataToUserById(RPCType type, ObjectId id, PackedWebSocketMessage message)
{
//Find the group
var group = Program.holder.FindGroup(new RPCGroupQueryUser
{
type = type,
user_id = id
});
if (group == null)
{
return(0);
}
//Send event to all
await group.SendDistributedMessage(message, new List <LibDeltaSystem.WebFramework.WebSockets.Groups.GroupWebSocketService>());
return(group.clients.Count);
}
public static async Task <int> SendDataToServerTribeById(RPCType type, ObjectId id, int tribe_id, PackedWebSocketMessage message)
{
//Find the group
var group = Program.holder.FindGroup(new RPCGroupQueryServerTribe
{
type = type,
server_id = id,
tribe_id = tribe_id
});
if (group == null)
{
return(0);
}
//Send event to all
await group.SendDistributedMessage(message, new List <LibDeltaSystem.WebFramework.WebSockets.Groups.GroupWebSocketService>());
//Also send this to server admins, as they could also be viewing this tribe
int adminCount = await SendDataToServerAdminsById(type, id, message, group.clients);
return(group.clients.Count + adminCount);
}
public SwitchWorld(RPCType type, string receiver, string user, string world)
: base(type, receiver)
{
this.user = user;
this.world = world;
}
/// <summary>
/// RPC初始化
/// </summary>
/// <param name="IP">IP地址</param>
/// <param name="Point">端口号</param>
/// <param name="type">RPC类型</param>
protected RPCCore(string IP, int Point, RPCType type)
{
Net = new NetSocketCore(IP, Point);
this.Type = type;
FuncMap = new ConcurrentDictionary <string, Delegate>();
}
/// <summary>
/// Execute a remote procedure.
/// </summary>
/// <param name="netInstanceID">The <see cref="NetworkIdentity.InstanceID"/>.</param>
/// <param name="function">The name of the function.</param>
/// <param name="parameters">The function parameters.</param>
public void Call(NetworkIdentity identity, RPCType type, string function, params object[] parameters)
{
int connectionID = NetworkController.Instance.IsServer ? identity.OwnerConnection?.ConnectionID ?? -1 : NetworkController.Instance.ConnectionID;
if (!NetworkController.Instance.IsServer)
{
if (type == RPCType.Target)
{
throw new InvalidOperationException("You cannot send a targetted RPC because you are not the server.");
}
if (identity.OwnerConnection == null)
{
throw new InvalidOperationException("The network identity has no owner and cannot execute any RPCs");
}
if (identity == null)
{
throw new InvalidOperationException("The network identity specified does not exist on this client: " + identity.InstanceID);
}
if (identity.OwnerConnection.ConnectionID != NetworkController.Instance.LocalConnectionID)
{
throw new InvalidOperationException("You are not the owner of this object and cannot execute RPCs on it.");
}
}
int index = m_Methods?.FindIndex(x => x.m_MethodName == function) ?? -1;
if (index == -1)
{
return;
}
RPCMethodInfo rpc = m_Methods[index];
if (rpc.m_ArgumentCount != parameters.Length)
{
throw new InvalidOperationException("Given argument count for " + function + " does not match the argument count specified.");
}
NetworkWriter writer = GetRPCWriter(NetworkController.Instance.LocalConnectionID, identity.InstanceID, (byte)type, index, rpc.m_ArgumentCount, parameters);
byte[] data = writer.ToArray();
switch (type)
{
case RPCType.All:
{
if (NetworkController.Instance.IsServer)
{
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
else
{
NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
break;
}
case RPCType.Others:
{
if (NetworkController.Instance.IsServer)
{
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
else
{
NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
break;
}
case RPCType.ServerOnly:
{
if (NetworkController.Instance.IsServer)
{
NetworkBehaviour networkBehaviour = identity.GetComponent <NetworkBehaviour>();
networkBehaviour.InvokeRPC(function, parameters);
}
else
{
NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
break;
}
case RPCType.AllBuffered:
{
if (NetworkController.Instance.IsServer)
{
InitBuffer(identity.InstanceID);
m_BufferedMessages[identity.InstanceID].Add(new NetworkWriter(writer.ToArray()));
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
else
{
NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
break;
}
case RPCType.OthersBuffered:
{
if (NetworkController.Instance.IsServer)
{
InitBuffer(identity.InstanceID);
m_BufferedMessages[identity.InstanceID].Add(new NetworkWriter(writer.ToArray()));
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
else
{
NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
break;
}
case RPCType.Target:
{
if (parameters.Length > 0)
{
NetworkConnection connection = (NetworkConnection)parameters[0];
if (connection != null)
{
connection.Send(NetworkController.ReliableSequencedChannel, RPCMsg, data);
}
}
break;
}
}
}
private void OnRPC(NetworkWriter writer)
{
ReadRPC(writer, out int connection, out int instanceID, out byte rpcType, out int rpcIndex, out int argumentCount, out object[] arguments);
NetworkIdentity identity = NetworkIdentityManager.Instance.Get(instanceID);
if (identity == null)
{
if (!NetworkController.Instance.IsServer)
{
InitBuffer(instanceID);
m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray()));
}
return;
}
if (rpcIndex == -1 || rpcIndex >= m_Methods.Count)
{
return;
}
if (NetworkController.Instance.IsServer)
{
RPCType type = (RPCType)rpcType;
if (type != RPCType.ServerOnly)
{
if (identity.OwnerConnection == null || identity.OwnerConnection.ConnectionID != connection)
{
return;
}
if (NetworkController.Instance.GetConnection(connection) == null)
{
return;
}
}
switch (type)
{
case RPCType.All:
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, writer.ToArray());
return;
case RPCType.AllBuffered:
NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, writer.ToArray());
InitBuffer(instanceID);
m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray()));
return;
case RPCType.Others:
NetworkController.Instance.SendToAllExcluding(writer.ToArray(), NetworkController.ReliableSequencedChannel, RPCMsg, connection);
return;
case RPCType.OthersBuffered:
NetworkController.Instance.SendToAllExcluding(writer.ToArray(), NetworkController.ReliableSequencedChannel, RPCMsg, connection);
InitBuffer(instanceID);
m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray()));
return;
}
}
RPCMethodInfo method = m_Methods[rpcIndex];
NetworkBehaviour behaviour = (NetworkBehaviour)identity.GetComponent(method.m_TypeName);
behaviour.InvokeRPC(method.m_MethodName, arguments);
}
internal static async Task <Response> HandleRpc(Protos.Request req, RPCType type, Stopwatch sw)
{
byte[] data = req.Msg.Data.ToByteArray();
Route route = Route.FromString(req.Msg.Route);
string handlerName = $"{route.service}.{route.method}";
PitayaSession s = null;
var response = new Response();
RemoteMethod handler;
if (type == RPCType.Sys)
{
s = new Models.PitayaSession(req.Session, req.FrontendID);
if (!HandlersDict.ContainsKey(handlerName))
{
response = GetErrorResponse("PIT-404",
$"remote/handler not found! remote/handler name: {handlerName}");
return(response);
}
handler = HandlersDict[handlerName];
MetricsReporters.ReportMessageProccessDelay(req.Msg.Route, "local", sw);
}
else
{
if (!RemotesDict.ContainsKey(handlerName))
{
response = GetErrorResponse("PIT-404",
$"remote/handler not found! remote/handler name: {handlerName}");
return(response);
}
handler = RemotesDict[handlerName];
MetricsReporters.ReportMessageProccessDelay(req.Msg.Route, "remote", sw);
}
Task ans;
if (handler.ArgType != null)
{
var arg = _serializer.Unmarshal(data, handler.ArgType);
if (type == RPCType.Sys)
{
ans = handler.Method.Invoke(handler.Obj, new[] { s, arg }) as Task;
}
else
{
ans = handler.Method.Invoke(handler.Obj, new[] { arg }) as Task;
}
}
else
{
if (type == RPCType.Sys)
{
ans = handler.Method.Invoke(handler.Obj, new object[] { s }) as Task;
}
else
{
ans = handler.Method.Invoke(handler.Obj, new object[] { }) as Task;
}
}
await ans;
byte[] ansBytes;
if (handler.ReturnType != typeof(void))
{
ansBytes = SerializerUtils.SerializeOrRaw(ans.GetType().
GetProperty("Result")
?.GetValue(ans), _serializer);
}
else
{
ansBytes = new byte[] {};
}
response.Data = ByteString.CopyFrom(ansBytes);
return(response);
}
public RPC(RPCType rpcType, string receiver)
{
this.rpcType = rpcType;
this.receiver = receiver;
GetType();
}
public RPC(RPCType rpcType)
{
this.rpcType = rpcType;
GetType();
}
public Sync(RPCType type, string receiver, string member)
: base(type, receiver)
{
this.member = member;
}
