ArrayList RPC_data_queue = new ArrayList(); //analogue to a vector of <RPCData>.
#endregion Fields
#region Methods
public void ScheduleRPC( string function_name, float delay, params object[] args )
{
//Function that will call function_name with args on all screens, after delay.
//Use this to schedule functions.
for ( int i = 0; i < npindex; i++ ) //for each connection,
{
RPCData temp_RPC = new RPCData( function_name, delay, i );
temp_RPC.args = args;
RPC_data_queue.Add ( temp_RPC );
}
}
private void OnPacketRemoveFactionMember(RPCData data)
{
Type type = typeof(ClientRemoveFleetMember);
cFunctions[type]?.Invoke(data);
foreach (EventListener action in Events[type])
{
try
{
action?.Execute(new GenericEvent(type, data));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
protected void OnPacketChatMessage(RPCData data)
{
Type type = typeof(ClientChatMessage);
cFunctions[type]?.Invoke(data);
foreach (EventListener action in Events[type])
{
try
{
action?.Execute(new GenericEvent(type, data));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
private void OnPacketSetShipPurchasable(RPCData data)
{
Type type = typeof(ClientSetShipPurchasable);
cFunctions[type]?.Invoke(data);
foreach (EventListener action in Events[type])
{
try
{
action?.Execute(new GenericEvent(type, data));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
private void i_onPacketGhostClientRequestChunkSaveDataAcknowledge(RPCData data)
{
Type type = typeof(GhostClientRequestChunkSaveDataAcknowledge);
cFunctions[type]?.Invoke(data);
foreach (EventListener action in Events[type])
{
try
{
action?.Execute(new GenericEvent(type, data));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
protected void i_onPacketClientPlayerCommandData(RPCData data)
{
Type type = typeof(ClientPlayerToolData);
cFunctions[type]?.Invoke(data);
foreach (EventListener action in Events[type])
{
try
{
action?.Execute(new GenericEvent(type, data));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
public GameRunnerResults RunGamesOnline(string HostName, int gamesToPlay, string controller, int RandomSeed = 0, List <double> gameParameters = null)
{
var grr2 = new GameRunnerResults();
RPCData sendData = new RPCData();
MapData md = new MapData(gameParameters);
sendData.MapData = md;
sendData.GamesToPlay = gamesToPlay;
sendData.AIToUse = controller;
sendData.RandomSeed = RandomSeed;
var Results = GetRemoteGameResults(sendData, HostName);
grr2.scores = new List <double>();
if (gamesToPlay > 0)
{
//foreach (var Results in RunResults)
{
if (Results != null)
{
var lines = Results.Split('\n');
foreach (var line in lines)
{
if (line.Length > 1)
{
var result = line.Split(',');
int Ghosts = int.Parse(result[0]);
int Pills = int.Parse(result[1]);
int Score = int.Parse(result[2]);
grr2.totalGhostsEaten += Ghosts;
grr2.pillsEatenTotal += Pills;
//grr.TotalGames[Level]++;
grr2.totalScore += Score;
grr2.scores.Add(Score);
}
}
}
}
}
grr2.gamesPlayed = gamesToPlay;
return(grr2);
}
protected void OnSpawnPlayerServerPacket(RPCData data)
{
var packet = data.DeserializedObject as SpawnPlayerServerPacket;
GameObjects.Client.ClientCharacter playerCharacter = new GameObjects.Client.PlayerControlledCharacter(packet.id, m_clControllers.GetSSBBRenderPipeline(), MathHelpers.OpenTkVecToSystemVec(packet.position), new Vector2(32, 32), m_clControllers.GetTextureManager().GetOrCreateTexture("arrow", "Textures/Arrow.png"), m_clControllers.GetShaderManager().GetDefaultShader());
if (packet.aiType != GameObjects.Client.Ai.AiFactory.AiType.AT_None)
{
var aiComp = new ComponentAiSystem();
aiComp.AddState(GameObjects.Client.Ai.AiFactory.CreateBaseAiState(packet.aiType, playerCharacter.GetMovementSpeed()));
playerCharacter.GetComponents().AddComponent(aiComp);
}
m_clControllers.GetRootScene().AddGameObject(playerCharacter);
var camera = new FollowCamera(playerCharacter.GetId());
camera.SetExtends(new Vector2(-800, -600), new Vector2(800, 600));
m_clControllers.GetRootScene().AddGameObject(camera);
m_clControllers.SetCamera(camera);
}
protected void OnPacketCharacterUpdate(RPCData data)
{
var packet = (CharacterUpdateClientPacket)data.DeserializedObject;
if (m_netIdToCharacterId.TryGetValue(data.OriginalMessage.SenderConnectionId, out var characterId))
{
var characterObj = m_svControllers.GetRootScene().GetGameObject(characterId);
if (characterObj != null)
{
var replicator = characterObj.GetComponents().GetComponent <ComponentReplicator>();
replicator.OnReplicate(m_svControllers, characterObj, packet.replicationData);
}
else
{
Console.WriteLine("Client has no character");
}
}
else
{
Console.WriteLine("Update packet from unknown client!!");
}
}
string GetRemoteGameResults(RPCData sendData, string HostName)
{
try
{
string message = "";
XmlSerializer xmlSerializer = new XmlSerializer(sendData.GetType());
using (StringWriter textWriter = new StringWriter())
{
xmlSerializer.Serialize(textWriter, sendData);
message = textWriter.ToString();
}
RPCClient rpcClient = null;
while (rpcClient == null)
{
try
{
rpcClient = new RPCClient(HostName);
}
catch
{
rpcClient = null;
}
}
var response = rpcClient.CallRunGame(message);
rpcClient.Close();
return(response);
}
catch (Exception e)
{
Console.WriteLine(" ERROR: " + e.Message);
return("0,0,0,0"); //RunResults[i]
}
}
// Update is called once per frame
void Update()
{
//Constantly update pings.
for (int i = 0; i < npindex; i++)
{
if (pings[i].isDone)
{
ping_results[i] = pings[i].time;
//Check if the greatest ping has changed
CheckGreatestPing();
//Ping it again! (ping can change)
string temp_ip = pings[i].ip;
pings[i].DestroyPing(); //good memory management?
pings[i] = new Ping(temp_ip);
}
}
for (int i = 0; i < RPC_data_queue.Count; i++)
{
RPCData RPC_data = (RPCData)RPC_data_queue[i];
((RPCData)RPC_data_queue[i]).delay -= Time.deltaTime;
//abstraction inefficiency
float delay = RPC_data.delay;
float ping = ping_results[RPC_data.id];
if (ping <= delay)
{
//SEND THE MESSAGE! NAO!
//get message data (abstraction inefficiency)
string function_name = RPC_data.function_name;
NetworkPlayer target = network_players[RPC_data.id];
object[] args = RPC_data.args;
//Send the message
if (RPC_data.id != 0) //not self-referential
{
GetComponent <NetworkView>().RPC(function_name, target, args);
}
else
{
//call it locally from string.
#region reflection
//APPROACH 1: (using reflection)
/*
* Type a_type = Type.GetType("SynchingViaPing");
* System.Type a_type = System.Type.GetType("SynchingViaPing");
* MethodInfo a_method = a_type.GetMethod( function_name );
* a_method.Invoke( this, args );
*/
#endregion
#region invokation
//APPROACH 2: Using invokation. No parameters can be passed, though
//Invoke ( function_name, 0.0f ); //call function now
#endregion
#region coroutine
//APPROACH 3: using coroutine. Parameters can be passed.
StartCoroutine(function_name, args);
#endregion
//NOTE: to use this, THIS SCRIPT must contain the function to call...
//Consider abstracting this away to be more general...?
#region terribad hax
//APPROACH 4:
//The hacky way of doing reflection: (this does give you power + control for weird cases)
/*
* if ( function_name == "ExampleFunction" )
* {
* ExampleFunction ( args );
* }
* else
* {
* Debug.LogError ( "Bad RPC function name!" );
* }
*/
#endregion
}
//Mark request as processed.
((RPCData)RPC_data_queue[i]).tagged_for_deletion = true;
}
}
//Delete items tagged for deletion (processed requests)
for (int i = RPC_data_queue.Count - 1; i >= 0; i--)
{
if (((RPCData)RPC_data_queue[i]).tagged_for_deletion)
{
RPC_data_queue.RemoveAt(i);
}
}
}
protected void OnPacketHelloWorld(RPCData data)
{
Console.WriteLine("Hello world (server)");
m_svControllers.Net.SendRPC(new HelloWorldPacket(), data.OriginalMessage.SenderConnectionId);
}
protected void OnPacketHelloWorld(RPCData data)
{
Console.WriteLine("Hello world (client)");
}
public override void Dispatch(RPCData data)
{
data.Serializer.Buffer.Position = 0;
data.Header.Read();
manager.Process(data);
}
public GenericEvent(Type type, RPCData data) : base(type)
{
Data = data;
EID = type;
}
private static void ProcessRPC(Player player, string rpc)
{
// 6 bytes is the minimum rpc size
if (rpc.Length < 6)
{
return;
}
if (rpc[0] == 'k')
{
Logger.Trace($"Recieved {rpc}");
// get the event id
// get the length of the mod name
if (!uint.TryParse(rpc.Substring(1, 3), NumberStyles.HexNumber, null, out uint id) ||
!uint.TryParse(rpc.Substring(4, 1), NumberStyles.HexNumber, null, out uint len))
{
return;
}
// check if we are in bounds to read the name
if (rpc.Length < 6 + len)
{
return;
}
string name = rpc.Substring(5, (int)len);
// grab the amount of parameters
if (!uint.TryParse(rpc.Substring(5 + (int)len, 1), NumberStyles.HexNumber, null, out uint pcount))
{
return;
}
if (rpc.Length < 6 + len + pcount * 2)
{
return;
}
int[] plens = new int[pcount];
for (int i = 0; i < pcount; i++)
{
if (!uint.TryParse(rpc.Substring(6 + (int)len + i * 2, 2), NumberStyles.HexNumber, null, out uint plen))
{
return;
}
plens[i] = (int)plen;
}
if (rpc.Length < 6 + len + pcount * 2 + plens.Sum())
{
return;
}
int inc = 0;
string[] parameters = new string[pcount];
for (int i = 0; i < plens.Length; i++)
{
parameters[i] = rpc.Substring(6 + (int)len + (int)pcount * 2 + inc, plens[i]);
inc += plens[i];
}
RPCData data = new RPCData(player.field_Private_APIUser_0.displayName, (int)id, name, parameters);
if (len == 0)
{
TransformRPCData(ref data);
}
Callback(data);
}
}
