public RpcCallSenderBuilder(string name, string[] defaultData, NetworkPlayer defaultSender, RPCMode defaultMode)
{
this.name = name;
this.data = defaultData;
this.sender = defaultSender;
this.mode = defaultMode;
}
/// <summary>
/// Send the netbuffer in the specified mode.
/// Highly recommended that you don't use the buffered rpc modes, as this is kind of a manual buffering solution anyway.
/// </summary>
/// <param name="mode"></param>
/// <param name="buffer"></param>
public void SendBuffer(RPCMode mode, NetBuffer buffer)
{
var message = PNetServer.peer.CreateMessage(buffer.LengthBytes);
buffer.Clone(message);
FinishRPCSend(mode, message);
}
public static void Buffer(NetworkView view, string func, RPCMode mode, params object[] args)
{
//first fix up the mode so no one accidentally passes in a buffered mode
if(mode == RPCMode.AllBuffered)
mode = RPCMode.All;
else if(mode == RPCMode.OthersBuffered)
mode = RPCMode.Others;
if(m_RPCs == null)
m_RPCs = new BufferedRPC[0];
BufferedRPC [] temp = new BufferedRPC[m_RPCs.Length+1];
if(m_RPCs.Length > 0)
m_RPCs.CopyTo(temp,0);
BufferedRPC tempRPC = new BufferedRPC();
tempRPC.func = func;
tempRPC.mode = mode;
if(args != null)
{
// for(int i = 0; i < args.Length; i++)
// Debug.Log(args[i].ToString() + ", ");
tempRPC.args = new object[args.Length];
args.CopyTo(tempRPC.args,0);
}
tempRPC.view = view;
temp[temp.Length-1] = tempRPC;
m_RPCs = temp;
view.RPC(func, mode, args);
}
/*
* public void SendFunction(string _refName, string methodName)
* {
* if (Network.peerType != NetworkPeerType.Disconnected)
* {
* //networkView.RPC("RunFunction", RPCMode.OthersBuffered, _refName, methodName);
* networkView.RPC("RunFunction", RPCMode.Others, _refName, methodName);
* }
* }
*/
// _refNameのついたGameObjectのmethodNameをコールする。受取り側ではSendMessageをつかっている。
public void SendFunction(string _refName, string methodName, RPCMode rpcMode = RPCMode.Others)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
GetComponent <NetworkView>().RPC("RunFunction", rpcMode, _refName, methodName);
}
}
/// <summary>
/// Send RPC with RPCmode and default NetDeliveryMethod
/// </summary>
/// <param name="funcname"></param>
/// <param name="Mode"></param>
/// <param name="param"></param>
public void RPC(string funcname, RPCMode Mode, params object[] param)
{
if (Network.Ready)
{
SendRPC(funcname, Mode, _DefaultNetDeliveryMethod, param);
}
}
public void RPC(string methodName, RPCMode mode, params object[] args)
{
var argBuf = rpcTbl[methodName].GetParamBuf(args);
UdpNetManager.Instance.RequestRpc(FrameController.Instance.GetExecuteFrame, this, methodName, argBuf);
FrameController.Instance.RegisterCurrentCommand();
}
private void Buffer(NetOutgoingMessage message, RPCMode mode)
{
var nBuffer = new NetBuffer();
message.Clone(nBuffer);
bufferedMessages.Add(nBuffer);
}
/// <summary>
/// Send a message to all players in the room
/// </summary>
/// <param name="rpcId">id of the RPC</param>
/// <param name="mode"></param>
/// <param name="args"></param>
public void RPC(byte rpcId, RPCMode mode, params INetSerializable[] args)
{
var size = 1;
RPCUtils.AllocSize(ref size, args);
var message = PNetServer.peer.CreateMessage(size);
message.Write(rpcId);
RPCUtils.WriteParams(ref message, args);
if (mode == RPCMode.AllBuffered || mode == RPCMode.OthersBuffered)
{
Buffer(message, mode);
}
if (mode == RPCMode.AllUnordered || mode == RPCMode.OthersUnordered)
{
SendMessage(message, false);
}
else
{
SendMessage(message, true);
}
}
private void SendMessage(NetOutgoingMessage msg, RPCMode mode, NetConnection originalSender = null)
{
if (mode != RPCMode.Owner)
{
//all and other are identical if originalsender is null.
if ((mode == RPCMode.All || mode == RPCMode.AllBuffered || originalSender == null) && _connections.Count > 0)
{
PNetServer.peer.SendMessage(msg, _connections, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
}
else
{
if (_allButOwner.Count != 0)
{
PNetServer.peer.SendMessage(msg, _allButOwner, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
}
else
{
//need to recycle unused messages...
PNetServer.peer.Recycle(msg);
}
}
}
else
{
PNetServer.peer.SendMessage(msg, owner.connection, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
}
}
public void RPC(Group group, RPCMode mode, string fc,params object [] obs)
{
if (networkView.isMine)
{
networkView.group = (int)group;
networkView.RPC(fc, mode, obs);
}
}
public override void Reset()
{
this.gameObject = null;
this.remoteEvent = null;
this.mode = RPCMode.All;
this.stringData = null;
this.mode = RPCMode.All;
}
public override void Reset()
{
gameObject = null;
remoteEvent = null;
mode = RPCMode.All;
stringData = null;
mode = RPCMode.All;
}
internal void Send(NetBuffer msg, RPCMode mode, NetConnection originalSender = null)
{
var message = PNetServer.peer.CreateMessage();
msg.Clone(message);
SendMessage(message, mode, originalSender);
}
public override void Reset()
{
gameObject = null;
remoteEvent = null;
mode = RPCMode.All;
stringData = null;
mode = RPCMode.All;
}
public void RPC(Group group, RPCMode mode, string fc, params object [] obs)
{
if (networkView.isMine)
{
networkView.group = (int)group;
networkView.RPC(fc, mode, obs);
}
}
public void RPCLoadLevel(string level, RPCMode rpcmode)
{
print("load Level" + level);
for (int i = 0; i < 20; i++)
{
Network.RemoveRPCsInGroup(i);
}
networkView.RPC("LoadLevel", rpcmode, level, lastLevelPrefix + 1);
}
public static void RPC2(this NetworkView networkView, string methodName, RPCMode mode, params object[] args)
{
Debug.Log("sending rpc to relay: " + methodName);
object[] newArgs = new object[args.Length + 1];
args.CopyTo(newArgs, 1);
newArgs[0] = methodName;
networkView.RPC("relay", NetworkManager.server, newArgs);
}
public static bool Prefix(NetworkView __instance, string name, RPCMode mode, ref object[] args)
{
if (Assembly.GetCallingAssembly().Equals(typeof(GameScript).Assembly))
{
switch (name)
{
case "Set":
if (args.Length == 3)
{
if (args[0] is int)
{
if (!GadgetNetwork.MatrixReady && GadgetNetwork.GetTimeSinceConnect() < GadgetNetwork.MatrixTimeout)
{
InstanceTracker.GameScript.StartCoroutine(GadgetUtils.WaitAndInvoke(RPCMethod, GadgetNetwork.MatrixTimeout - GadgetNetwork.GetTimeSinceConnect(), () => GadgetNetwork.MatrixReady, __instance, name, mode, args));
return(true);
}
GadgetNetwork.ConvertIDToHost(PlanetRegistry.Singleton, ref args[0]);
}
}
else if (args.Length == 1)
{
if (args[0] is int[] arr && arr.Length == 2)
{
if (!GadgetNetwork.MatrixReady && GadgetNetwork.GetTimeSinceConnect() < GadgetNetwork.MatrixTimeout)
{
InstanceTracker.GameScript.StartCoroutine(GadgetUtils.WaitAndInvoke(RPCMethod, GadgetNetwork.MatrixTimeout - GadgetNetwork.GetTimeSinceConnect(), () => GadgetNetwork.MatrixReady, __instance, name, mode, args));
return(true);
}
ItemStandScript itemStandScript = __instance.GetComponent <ItemStandScript>();
if (itemStandScript == null || !itemStandScript.isChipStand)
{
args[0] = new int[]
{
GadgetNetwork.ConvertIDToHost(ItemRegistry.Singleton, arr[0]),
arr[1],
};
}
else
{
args[0] = new int[]
{
GadgetNetwork.ConvertIDToHost(ChipRegistry.Singleton, arr[0]),
arr[1],
};
}
}
else if (args[0] is Package2 pack2)
{
if (!GadgetNetwork.MatrixReady && GadgetNetwork.GetTimeSinceConnect() < GadgetNetwork.MatrixTimeout)
{
InstanceTracker.GameScript.StartCoroutine(GadgetUtils.WaitAndInvoke(RPCMethod, GadgetNetwork.MatrixTimeout - GadgetNetwork.GetTimeSinceConnect(), () => GadgetNetwork.MatrixReady, __instance, name, mode, args));
return(true);
}
GadgetNetwork.ConvertIDToHost(ItemRegistry.Singleton /* ProjectileRegistry */, ref pack2.id);
}
}
break;
/// <summary>
/// send an rpc using a custom method to write to the message, with a custom value to send into it
/// DO NOT STORE THE NETOUTGOINGMESSAGE. LIDGREN WILL RECYCLE IT.
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="messageSerializer"></param>
/// <param name="value"></param>
/// <param name="messageSize"></param>
/// <typeparam name="T">value to pass into the messageSerializer</typeparam>
public void RPC <T>(byte rpcID, RPCMode mode, MessageSerializer <T> messageSerializer, T value,
int messageSize = 0)
{
var size = DEFAULT_RPC_HEADER_SIZE + messageSize;
var message = CreateMessage(size, rpcID);
messageSerializer(ref message, value);
FinishRPCSend(mode, message);
}
bool SendRPC(string name, RPCMode mode, params object[] args)
{
if (Network.isClient || Network.isServer)
{
networkView.RPC(name, mode, args);
return(true);
}
return(false);
}
void FinishRPCSend(RPCMode mode, NetOutgoingMessage message)
{
if (mode == RPCMode.AllBuffered || mode == RPCMode.OthersBuffered)
{
Buffer(message);
}
SendMessage(message, mode);
}
/// <summary>
/// Send a message to the specified recipients (prevents array allocation)
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="arg0"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"> </param>
/// <param name="arg4"> </param>
public void RPC(byte rpcID, RPCMode mode,
INetSerializable arg0 = null,
INetSerializable arg1 = null,
INetSerializable arg2 = null,
INetSerializable arg3 = null,
INetSerializable arg4 = null)
{
var size = DEFAULT_RPC_HEADER_SIZE;
if (arg0 != null)
{
size += arg0.AllocSize;
}
if (arg1 != null)
{
size += arg1.AllocSize;
}
if (arg2 != null)
{
size += arg2.AllocSize;
}
if (arg3 != null)
{
size += arg3.AllocSize;
}
if (arg4 != null)
{
size += arg4.AllocSize;
}
var message = CreateMessage(size, rpcID);
if (arg0 != null)
{
arg0.OnSerialize(message);
}
if (arg1 != null)
{
arg1.OnSerialize(message);
}
if (arg2 != null)
{
arg2.OnSerialize(message);
}
if (arg3 != null)
{
arg3.OnSerialize(message);
}
if (arg4 != null)
{
arg4.OnSerialize(message);
}
FinishRPCSend(mode, message);
}
public static void RPCEx(this NetworkView view, string routineName, RPCMode mode, params object[] parameters)
{
using (var m = new MemoryStream())
{
var b = new BinaryFormatter();
b.Serialize(m, parameters);
m.Flush();
var s = Convert.ToBase64String(m.GetBuffer());
view.RPC("PerformRPCCall", mode, routineName, s);
}
}
public void CallRPC(Action n, RPCMode m)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
networkView.RPC(n.Method.Name, m);
}
else
{
n();
}
}
public static void RPCEx(this NetworkView view, string routineName, RPCMode mode, params object[] parameters)
{
using(var m = new MemoryStream())
{
var b = new BinaryFormatter();
b.Serialize(m, parameters);
m.Flush();
var s = Convert.ToBase64String(m.GetBuffer());
view.RPC("PerformRPCCall", mode, routineName, s);
}
}
public void CallRPC <T, T2, T3, T4, T5, T6>(Action <T, T2, T3, T4, T5, T6> n, RPCMode m, T p, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
networkView.RPC(n.Method.Name, m, p, p2, p3, p4, p5, p6);
}
else
{
n(p, p2, p3, p4, p5, p6);
}
}
public void CallRPC <T, T2, T3>(Action <T, T2, T3> n, RPCMode m, T p, T2 p2, T3 p3)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
networkView.RPC(n.Method.Name, m, p, p2, p3);
}
else
{
n(p, p2, p3);
}
}
public void CallRPC <T>(Action <T> n, RPCMode m, T p)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
networkView.RPC(n.Method.Name, m, p);
}
else
{
n(p);
}
}
internal void CallGeneral(string name, RPCMode mode, params object[] args)
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
foreach (object arg in args)
{
formatter.Serialize(stream, arg);
}
view.RPC("RPCCallGeneral", mode, new object[] { name, args.Length, stream.ToArray() });
stream.Close();
}
// int
public void SendFunctionWithInt(string _refName, string methodName, int i, RPCMode rpcMode = RPCMode.Others)
{
if (GetComponent <NetworkView>() == null)
{
return;
}
if (Network.peerType != NetworkPeerType.Disconnected)
{
GetComponent <NetworkView>().RPC("RunFunctionWithInt", rpcMode, _refName, methodName, i);
}
}
private const int DEFAULT_RPC_HEADER_SIZE = 3; //guid + rpcid
#region mode rpcs
/// <summary>
/// Send a message to the specified recipients
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="args"></param>
public void RPC(byte rpcID, RPCMode mode, params INetSerializable[] args)
{
var size = DEFAULT_RPC_HEADER_SIZE;
RPCUtils.AllocSize(ref size, args);
var message = CreateMessage(size, rpcID);
RPCUtils.WriteParams(ref message, args);
FinishRPCSend(mode, message);
}
/// <summary>
/// Send an rpc
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="args"></param>
public void RPC(byte rpcID, RPCMode mode, params INetSerializable[] args)
{
var size = 2;
RPCUtils.AllocSize(ref size, args);
var message = Manager.Net.Peer.CreateMessage(size);
message.Write(ViewID.guid);
message.Write(rpcID);
RPCUtils.WriteParams(ref message, args);
Manager.Net.Peer.SendMessage(message, NetDeliveryMethod.ReliableOrdered, (int)mode + Channels.BEGIN_RPCMODES);
}
public static void RPCEx(this NetworkView view, string routineName, RPCMode mode, params object[] parameters)
{
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, parameters);
memoryStream.Flush();
string text = Convert.ToBase64String(memoryStream.GetBuffer());
view.RPC("PerformRPCCall", mode, new object[]
{
routineName,
text
});
}
}
public void RPC(string name, RPCMode mode, params object[] args)
{
// call a rpc on this object
if (observed != null)
{
var type = observed.GetType();
if (type.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null)
{
Manager.ViewRPC(name, viewId, mode, args);
}
else
{
EB.Debug.LogWarning("skipping rpc (" + name + ") on type " + observed.GetType());
}
}
}
// public void NetRebroadcast(string method, NetworkPlayer source, params object[] args)
// {
// foreach (NetworkPlayer player in Network.connections) {
// if (player == source) {
// continue;
// }
// switch (args.Length) {
// case 0:
// networkView.RPC (method,)
// }
// }
// }
public static void SendDictionary(string dictionaryName, RPCMode mode = RPCMode.Others)
{
if (mode == RPCMode.All)
{
mode = RPCMode.Others;
Debug.Log("SendDictionary: RPCMode changed to RPCMode.Others to avoid endless loop");
}
stDictionary dict = GetDictionary(dictionaryName);
if (dict != null)
{
networkViewStatic.RPC("NetSetDictionary", mode, dictionaryName, dict.JSONString());
}
else
{
Debug.Log("SendDictionary: dictionary " + dictionaryName + " not found");
}
}
void SendMyData(RPCMode rpcMode)
{
NetworkViewID id = GetPlayerData(PlayerCharacterSettingsScript.currentBuild.playerName);
if(id != NetworkViewID.unassigned && id != networkManager.myID)
{
int num = 1;
id = GetPlayerData(PlayerCharacterSettingsScript.currentBuild.playerName + num);
while(id != NetworkViewID.unassigned && id != networkManager.myID)
{
num++;
id = GetPlayerData(PlayerCharacterSettingsScript.currentBuild.playerName + num);
}
//update the name with the new number appended
PlayerCharacterSettingsScript.currentBuild.playerName += num;
PlayerCharacterSettingsScript.currentBuild.SaveSettings();
PlayerCharacterSettingsScript.currentBuild.RestoreFromPrefs();
}
networkView.RPC ("UpdatePlayerData", rpcMode, networkManager.myID, PlayerCharacterSettingsScript.currentBuild.playerName, PlayerCharacterSettingsScript.currentBuild.weight, PlayerCharacterSettingsScript.currentBuild.jumpAbility, PlayerCharacterSettingsScript.currentBuild.movementAbility, PlayerCharacterSettingsScript.currentBuild.firstAbility, PlayerCharacterSettingsScript.currentBuild.secondAbility, PlayerCharacterSettingsScript.currentBuild.thirdAbility, PlayerCharacterSettingsScript.currentBuild.fourthAbility, PlayerCharacterSettingsScript.currentBuild.team.value);
}
public static void NetRPC(this MonoBehaviour caller, string methodName, RPCMode mode, params object[] args)
{
var networkView = caller.GetComponent<NetworkView>();
if (!Network.isClient && RPCMode.Server == mode)
{ // Local rpc call
LocalInvoke(caller, methodName, args);
}
else if (Network.isClient||Network.isServer)
{
networkView.RPC(methodName, mode, args);
}
else if (mode == RPCMode.All || mode == RPCMode.AllBuffered)
{ // If there is no network and this is supposed to go to everyone, make sure it goes to me!
LocalInvoke(caller, methodName, args);
}
else
{
Debug.LogWarning("NetUtil::RPC - Method '" + methodName + "' on object '" + caller + "' with mode '" + mode + "' failed !" +
" Ignoring method call!");
}
}
/// <summary>
/// Get and Send a new message and apply filter string for wrong labels
/// </summary>
/// <param name="target"> Networking targets</param>
void SendChat( RPCMode target)
{
if (chatInput != "")
{
foreach (string filter in this.blacklist)
{
if (chatInput.ToLower().IndexOf(filter) != -1)
{
chatInput = chatInput.ToLower().Replace(filter, "****");
}
}
GetComponent<NetworkView>().RPC("SendChatMessage", target, chatInput,User);
chatInput = "";
}
}
void MakeRPC(RPCMode mode, double time, string functionName, params object[] parameters)
{
if (mOldTerminal != null)
{
/*Debug.Log("NewEvent length: " + GetRPCBytes(functionName, parameters).Length);
for (int i = 0; i < parameters.Length; i++)
{
Debug.Log(i + " -> " + parameters[i]);
}*/
//MethodInfo tempMethod = this.GetType().GetMethod(functionName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
//parameters = GetParameterListFromBytes(tempMethod, GetRPCBytes(functionName, parameters));
/*for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].GetType() == typeof(byte[]))
{
Debug.Log((sizeof(float) * 3));
Debug.Log(i + " -> " + parameters[i] + " " + ((byte[])parameters[i]).Length);
}
else
{
Debug.Log(i + " -> " + parameters[i]);
}
}*/
DoRPC("NewEventPacket", RPCMode.Others, time, functionName, GetRPCBytes(functionName, parameters));
}
}
private static extern void Internal_RPC(NetworkView view, string name, RPCMode mode, object[] args);
// Use this for initialization
protected override void Start()
{
base.Start();
this.RPCMode = RPCMode.All;
}
public void RPC(string name, RPCMode mode, Object[] args){}
protected void DoRPC(string name, RPCMode mode, params object[] args)
{
if (mTerminalScript == null || mCallScript == null)
{
Debug.Log("NetCode has not been initialized");
return;
}
if (mNetworkView != null)
{
mNetworkView.RPC(mParserFunction, mode, name, mServerPacketID, GetRPCBytes(name, args));
}
/*if (DEBUG)
{
if (Server.isServer())
{
string message = "RPC " + name;
for (int i = 0; i < args.Length; i++)
{
message += " " + args[i].ToString();
}
SQDebug.log2(Common.getTime() + " : " + mServerPacketID + ") " + message, 5);
mServerPacketID++;
}
}*/
}
public void RPC(string name, RPCMode mode, params object[] args)
{
if (_nativeNetworkView != null)
_nativeNetworkView.RPC(name, mode, args);
}
public void SetDefaultMode(RPCMode defaultMode)
{
this.defaultMode = defaultMode;
}
public RpcCallSender DefaultToOthers()
{
defaultMode = RPCMode.OthersBuffered;
return this;
}
internal void Send(NetBuffer msg, RPCMode mode, NetConnection originalSender = null)
{
var message = PNetServer.peer.CreateMessage();
msg.Clone(message);
SendMessage(message, mode, originalSender);
}
public RpcCallSendData(string name, string[] data, NetworkPlayer sender, RPCMode mode)
: base(name, data, sender)
{
this.mode = mode;
}
private void SendMessage(NetOutgoingMessage msg, RPCMode mode, NetConnection originalSender = null)
{
if (mode != RPCMode.Owner)
{
//all and other are identical if originalsender is null.
if ((mode == RPCMode.All || mode == RPCMode.AllBuffered || originalSender == null) && _connections.Count > 0)
PNetServer.peer.SendMessage(msg, _connections, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
else
{
if (_allButOwner.Count != 0)
PNetServer.peer.SendMessage(msg, _allButOwner, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
else
{
//need to recycle unused messages...
PNetServer.peer.Recycle(msg);
}
}
}
else
{
PNetServer.peer.SendMessage(msg, owner.connection, mode.GetDeliveryMethod(), Channels.OWNER_RPC);
}
}
void SendChat(RPCMode target, bool isForAll)
{
if (chatInput != "")
{
if(isForAll){
networkView.RPC("SendChatMessageForAll", target, chatInput, player.Player.name);
chatInput = "";
}else{
networkView.RPC("SendChatMessageForTeam", target, chatInput, player.Player.name);
chatInput = "";
}
}
}
/// <summary>
/// Called by a client or a server to broadcast their custom property to all other players
/// </summary>
/// <param name='key'>
/// Key.
/// </param>
/// <param name='data'>
/// Data.
/// </param>
void BroadcastCustomProperty(RPCMode target, NetworkPlayer owner, string key, object data)
{
if (data.GetType() == typeof(string))
{
networkView.RPC("RPCSetPlayerCustomString", target, Network.player, key, (string)data);
}
else if (data.GetType() == typeof(int))
{
networkView.RPC("RPCSetPlayerCustomInt", target, Network.player, key, (int)data);
}
else if (data.GetType() == typeof(float))
{
networkView.RPC("RPCSetPlayerCustomFloat", target, Network.player, key, (float)data);
}
else
{
Debug.LogError("Unsupported player property type:" + data.GetType().ToString());
}
}
public static void DgRPC(this GameObject obj, string functionName, RPCMode target, params object[] args)
{
if (obj.GetComponent<NetworkView>() != null)
{
obj.GetComponent<NetworkView>().RPC(functionName, target, args);
}
else
{
obj.SendMessage(functionName, args);
}
}
public void RPCLoadLevel(string level, RPCMode rpcmode)
{
print("load Level" + level);
for (int i = 0; i < 20; i++)
Network.RemoveRPCsInGroup(i);
networkView.RPC("LoadLevel", rpcmode, level, lastLevelPrefix + 1);
}
/// <summary>
/// Send a message to the specified recipients
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="args"></param>
public void RPC(byte rpcID, RPCMode mode, params INetSerializable[] args)
{
if (_connections.Count == 0)
return;
var size = 3;
RPCUtils.AllocSize(ref size, args);
var message = PNetServer.peer.CreateMessage(size);
message.Write(viewID.guid);
message.Write(rpcID);
RPCUtils.WriteParams(ref message, args);
if (mode == RPCMode.AllBuffered || mode == RPCMode.OthersBuffered)
{
Buffer(message);
}
SendMessage(message, mode);
}
/// <summary>
///
/// </summary>
/// <param name="mode"></param>
/// <param name="player"></param>
internal NetMessageInfo(RPCMode mode, Player player)
{
this.mode = mode;
this.player = player;
}
private void SendMessage(NetOutgoingMessage msg, RPCMode mode, NetConnection originalSender = null)
{
if (mode != RPCMode.Owner)
{
if (mode == RPCMode.All || mode == RPCMode.AllBuffered)
PNetServer.peer.SendMessage(msg, _connections, NetDeliveryMethod.ReliableOrdered, Channels.OWNER_RPC);
else
{
var conns = _connections.Where(c => c != originalSender).ToList();
if (conns.Count != 0)
PNetServer.peer.SendMessage(msg, conns, NetDeliveryMethod.ReliableOrdered, Channels.OWNER_RPC);
}
}
else
{
PNetServer.peer.SendMessage(msg, owner.connection, NetDeliveryMethod.ReliableOrdered, Channels.OWNER_RPC);
}
}
public void RPC(string name, RPCMode mode, params object[] args)
{
Internal_RPC(this, name, mode, args);
}
public void RPC(string name, RPCMode mode, params object[] args)
{
MessengerInstance.networkView.RPC(name, mode, args);
}
protected void SendRPC(string name, RPCMode mode, params object[] p)
{
if (Network.peerType != NetworkPeerType.Disconnected )
NetworkSend.RPC(name, mode, p);
}
public RpcCallSender DefaultToAll()
{
defaultMode = RPCMode.AllBuffered;
return this;
}
