public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
Debug.LogError("Error, MessageInspector of type " + eventName + " called!");
// return zero to to have this inspector pass this message
// return positive number if message shouldn't be relayed to all other clients
return(1); // do not send to other clients
}
public override void SendToLocalGameObject(FFBasePacket package, GameObject go)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
switch (package.packetInstructions)
{
case FFPacketInstructionFlags.MessageBoardGameObjectSend:
FFMessageBoard <EventType> .SendToLocal(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendDown:
FFMessageBoard <EventType> .SendToLocalDown(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendUp:
FFMessageBoard <EventType> .SendToLocalUp(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendToAllConnected:
FFMessageBoard <EventType> .SendToLocalToAllConnected(sentPackage.message, go);
break;
default:
break;
}
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
// Example cast
//FFPacket<PlayerDiedEvent> packet = (FFPacket<PlayerDiedEvent>)incommingPacket;
return(1); // return positive number if message shouldn't be relayed to all other clients
}
public override bool SendToLocalEntry(FFBasePacket package, string entry)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
return(FFMessageBoard <EventType> .SendToLocal(sentPackage.message, entry));
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
FFPacket <ClientSyncTimeEvent> packet = (FFPacket <ClientSyncTimeEvent>)incommingPacket;
packet.message.serverLifeTime = FFServer.serverTime;
clientSocket.SendNetPacket <ClientSyncTimeEvent>(packet, false);
return(1); // return zero to to have this inspector pass this message
}
// Used to unpack messages from the net
public override bool SendToLocal(FFBasePacket package)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
return(FFMessage <EventType> .SendToLocal(sentPackage.message));
}
void ExecuteMessages()
{
while (singleton.recievedMessages.Count > 0)
{
FFBasePacket message = singleton.recievedMessages.Dequeue();
FFPrivate.FFMessageSystem.SendPacketToLocal(message);
}
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
//Debug.Log("NetObjectDestroyedEvent Packet Recieved"); // debug
FFPacket <NetObjectDestroyedEvent> packet = (FFPacket <NetObjectDestroyedEvent>)incommingPacket;
// Remove copy of the object which exists for new clients to create the object
// TODO: Low-Prio, Optimize for O(N), Needs custom List, very low prio.
var list = FFServer.NetObjectsCreated;
list.Remove(list.Find(x => x.gameObjectNetId == packet.message.gameObjectNetId));
return(0);
}
/// <summary>
/// Disbatch a packet to the local client
/// </summary>
/// <param name="packet"></param>
public static void DisbatchPacket(FFBasePacket packet)
{
if ((packet.packetInstructions & FFPacketInstructionFlags.Immediate).Equals(FFPacketInstructionFlags.Immediate))
{
//Debug.Log("Recieved Immediate Message from Net"); // debug
FFPrivate.FFMessageSystem.SendPacketToLocal(packet);
}
else
{
//Debug.Log("Recieved Message from Net"); // debug
singleton.recievedMessages.Enqueue(packet);
}
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
FFPacket <NetObjectCreatedEvent> packet = (FFPacket <NetObjectCreatedEvent>)incommingPacket;
long netid = FFServer.GetNewNetId;
GameObjectNetIdRecievedEvent reply = new GameObjectNetIdRecievedEvent();
reply.gameInstanceId = packet.message.gameObjectInstanceId;
packet.message.gameObjectNetId = netid;
reply.netId = netid;
// TODO make this run off of netId on local server/dedicated version
// SAVE NewObjectCreatedEvents so they can be sent to new clients later
FFServer.NetObjectsCreated.Add(packet.message);
clientSocket.SendMessage <GameObjectNetIdRecievedEvent>(reply, true);
return(0);
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
FFPacket <ClientConnectedEvent> packet = (FFPacket <ClientConnectedEvent>)incommingPacket;
clientSocket.clientData.clientName = packet.message.clientName;
clientSocket.clientData.clientGuid = packet.message.clientGuid;
packet.message.clientId = clientSocket.clientData.clientId;
packet.message.serverTime = FFServer.serverTime;
packet.message.serverStartTime = FFServer.serverStartTime;
packet.message.serverName = FFServer.serverName;
clientSocket.SendMessage <ClientConnectedEvent>(packet.message, true);
// make a copy so that it doesn't get invalidated if another thread deletes something
var netObjects = new List <NetObjectCreatedEvent>(FFServer.NetObjectsCreated);
foreach (var netobj in netObjects)
{
clientSocket.SendMessage <NetObjectCreatedEvent>(netobj, true);
}
return(0);
}
public static void SendPacket(FFBasePacket basepacket, bool varified)
{
// Assign Sender ID
basepacket.senderId = singleton._clientId; // 0 is for server, -1 Uninitialized, (1-MaxLong)
if ((basepacket.packetInstructions & FFPacketInstructionFlags.Immediate).Equals(FFPacketInstructionFlags.Immediate))
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, basepacket);
byte[] packetData = ms.ToArray();
ms.Flush();
ms.Dispose();
if (varified)
{
SendPacketTCP(packetData);
}
else
{
SendPacketUDP(packetData);
}
}
else
{
//Debug.Log("SendPacket"); // debug
if (varified)
{
AddVerifiedPacketToSend(basepacket);
}
else
{
AddUnverifiedPacketToSend(basepacket);
}
}
}
// MessageBoards/Messages executed by main thread in FFNetSystem
// MessageBoards/Messages Unpacking of packetdata
// MessageBoards/Messages direction and distribution
public static void SendPacketToLocal(FFBasePacket baseNetPacket)
{
#region FFMessage
if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.Message).Equals(FFPacketInstructionFlags.Message))
{
BaseMessage netMessage;
if (messageDictionary.TryGetValue(baseNetPacket.messageType, out netMessage))
{
netMessage.SendToLocal(baseNetPacket);
}
else
{
Debug.Log("Recieved message of non-registered NetMessage: " + baseNetPacket.messageType);
}
}
#endregion
#region FFMessageBoard
else if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoard).Equals(FFPacketInstructionFlags.MessageBoard))
{
BaseMessageBoard netMessageBoard;
if (messageBoardDictionary.TryGetValue(baseNetPacket.messageType, out netMessageBoard))
{
// goes to an entry
if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoardEntry).Equals(FFPacketInstructionFlags.MessageBoardEntry))
{
netMessageBoard.SendToLocalEntry(baseNetPacket, baseNetPacket.entry);
}
// goes to a GameObject
else if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoardGameObjectSend).Equals(FFPacketInstructionFlags.MessageBoardGameObjectSend))
{
FFSystem.GameObjectData goToSendToData;
long netId = Convert.ToInt64(baseNetPacket.entry);
if (FFSystem.TryGetGameObjectDataByNetId(netId, out goToSendToData))
{
netMessageBoard.SendToLocalGameObject(baseNetPacket, goToSendToData.gameObject);
}
else
{
Debug.Log("Recieved messageBoard packet for netId which is not registered" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry +
"\nNetId: " + netId);
}
}
else
{
Debug.Log("Recieved Invalid FFPacketInstructionFlags" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry);
}
}
else
{
Debug.Log("Recieved message for a non-registered NetMessageBoard" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry);
}
}
#endregion
}
private static void AddUnverifiedPacketToSend(FFBasePacket packet)
{
singleton._packetsToSendViaUDP.Enqueue(packet);
}
public static void SendPacket(FFBasePacket basepacket, bool varified)
{
// Assign Sender ID
basepacket.senderId = singleton._clientId; // 0 is for server, -1 Uninitialized, (1-MaxLong)
if((basepacket.packetInstructions & FFPacketInstructionFlags.Immediate).Equals(FFPacketInstructionFlags.Immediate))
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, basepacket);
byte[] packetData = ms.ToArray();
ms.Flush();
ms.Dispose();
if (varified)
{
SendPacketTCP(packetData);
}
else
{
SendPacketUDP(packetData);
}
}
else
{
//Debug.Log("SendPacket"); // debug
if (varified)
{
AddVerifiedPacketToSend(basepacket);
}
else
{
AddUnverifiedPacketToSend(basepacket);
}
}
}
private static void AddVerifiedPacketToSend(FFBasePacket packet)
{
singleton._packetsToSendViaTCP.Enqueue(packet);
}
virtual public void SendToLocalGameObject(FFBasePacket package, GameObject go)
{
Debug.LogError("Message Didn't override SentToLocalGameObject function?!?");
}
virtual public bool SendToLocal(FFBasePacket package)
{
Debug.LogError("Message Didn't override SentToLocal function?!?");
return(false);
}
private static void SendThreadLoop()
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
FFSystem.InitBinaryFormatter(bf);
uint PingCycle = (uint)(singleton._PingCycle * 1000.0f);
uint DialationSyncCycle = (uint)(singleton._DialationSyncCycle * 1000.0f);
// Sync Counters (in milliseconds)
uint DialationSyncTimeCounter = DialationSyncCycle;
uint PingTimeCounter = 0;
System.Diagnostics.Stopwatch sendThreadWatch = new System.Diagnostics.Stopwatch();
sendThreadWatch.Start();
while (true)
{
int cyclePacketCount = 0;
// sync Client if needed
if (FFClient.isReady)
{
if (sendThreadWatch.ElapsedMilliseconds >= PingTimeCounter)
{
PingTimeCounter += PingCycle;
SendClientSyncTimeEvent(false);
//Debug.Log("SendThread sent a ClientSyncTimeEvent w/o Dialation"); //debug
}
if (sendThreadWatch.ElapsedMilliseconds >= DialationSyncTimeCounter)
{
DialationSyncTimeCounter += DialationSyncCycle;
SendClientSyncTimeEvent(true);
//Debug.Log("SendThread sent a ClientSyncTimeEvent w/ Dialation"); //debug
}
}
while (singleton._packetsToSendViaTCP.Count != 0)
{
ms = new MemoryStream();
FFBasePacket packet = singleton._packetsToSendViaTCP.Dequeue();
bf.Serialize(ms, packet);
byte[] packetData = ms.GetBuffer();
ms.Flush();
ms.Dispose();
SendPacketTCP(packetData);
++cyclePacketCount;
//Debug.Log("SendThead Sent a TCP packet"); // debug
}
while (singleton._packetsToSendViaUDP.Count != 0)
{
ms = new MemoryStream();
FFBasePacket packet = singleton._packetsToSendViaUDP.Dequeue();
bf.Serialize(ms, packet);
byte[] packetData = ms.GetBuffer();
ms.Flush();
ms.Dispose();
SendPacketUDP(packetData);
++cyclePacketCount;
//Debug.Log("SendThead Sent a UDP packet"); // debug
}
if (cyclePacketCount == 0) // if we didn't send anything
{
Thread.Sleep(1); // Throw on CPU thead queue
}
}
}
