private void HelloEventHandler(NetworkFrame msg)
{
var helloMsg =
JsonConvert.DeserializeObject <HelloEvent>(msg.Data.ToString());
_interval = helloMsg.HeartbeatInterval;
if (_interval != 0)
{
Task.Factory.StartNew(async() =>
{
while (true)
{
await Task.Delay(_interval);
var toSend = JsonConvert.SerializeObject(new NetworkFrame()
{
OperationCode = GatewayOpCode.Heartbeat,
Sequence = _lastSequence
});
ws.Send(toSend);
Logger.Log("HeartBreak sent : " + toSend);
}
});
var send = JsonConvert.SerializeObject(new NetworkFrame(GatewayOpCode.Identify,
new Identify(
_config.Token,
new Properties("windows", "disco", "disco"), false, 50,
new int[] { 0, 1 }, new Presence(
new Game("Cards Against Humanity", 0), "online", null, false))),
Formatting.Indented);
ws.Send(send);
Logger.LogDebug("Send : " + send);
}
}
private void HandleGuildCreate(NetworkFrame msg)
{
var guild = JsonConvert.DeserializeObject <Guild>(msg.Data.ToString());
_guilds[guild.Id] = guild;
Logger.Log("GUILD_CREATE");
}
private void HeartbeatEventHandler(NetworkFrame msg)
{
var toSend = JsonConvert.SerializeObject(new NetworkFrame(1, msg.Sequence));
ws.Send(toSend);
Logger.Log("HeartBreak sended : " + toSend);
}
private IEnumerator HeartbeatWorker()
{
while (GetNetworkState() == NetworkState.Established)
{
foreach (var player in NetworkManager.Instance.GetPlayers())
{
if (!m_Heartbeats.ContainsKey(player.m_Id))
{
m_Heartbeats.Add(player.m_Id, 0);
continue;
}
if (m_Heartbeats[player.m_Id] == 2)
{
RemovePlayer(player, "Heartbeat lost", NetworkDisconnectType.LostConnection);
continue;
}
m_Heartbeats[player.m_Id] += 1;
NetworkFrame heartFrame = new NetworkFrame(NetworkFrame.NetworkFrameType.Heartbeat, "server", player.m_Id);
QueueFrame(heartFrame);
}
yield return(new WaitForSeconds(2.5f));
}
}
public CommandDownload(NetworkFrame nf) : base(nf)
{
byte[] data = nf.Data;
byte[] tmpBegin = new byte[4];
byte[] tmpEnd = new byte[4];
byte[] tmpString = new byte[data.Length - 8];
Array.Copy(data, 0, tmpBegin, 0, 4);
Array.Copy(data, 4, tmpEnd, 0, 4);
Array.Copy(data, 8, tmpString, 0, data.Length - 8);
begin = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(tmpBegin, 0));
end = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(tmpEnd, 0));
String tmpData = Encoding.UTF8.GetString(tmpString);
try
{
char[] separators = { ':' };
String[] tmp = tmpData.Split(separators);
filename = tmp[0];
user = tmp[1];
}
catch (NullReferenceException)
{
throw new Exception();
}
catch (IndexOutOfRangeException)
{
throw new Exception();
}
}
private void HandleReadyEvent(NetworkFrame msg)
{
var readyEvent =
JsonConvert.DeserializeObject <ReadyEvent>(msg.Data.ToString());
foreach (var guild in readyEvent.Guilds)
{
_guilds.Add(guild.Id, null);
}
Logger.Log("READY");
}
/// <summary>
/// Sends a ping request to the server to calculate our ping
/// </summary>
private void SendPing()
{
NetworkFrame pingFrame = new NetworkFrame(NetworkFrame.NetworkFrameType.Ping, GetUniqueIndentifier(), "server");
if (GetNetworkState() == NetworkState.Established)
{
m_Stopwatch = new Stopwatch();
m_Stopwatch.Start();
}
QueueFrame(pingFrame);
}
void WriteFrame(NetworkFrame frame)
{
try
{
var data = frame.ToArray();
outgoingChannel.WriteAsync(data, 0, data.Length);
}
catch
{
Close();
}
}
public NetworkWindow()
{
InitializeComponent();
NetworkSetupPage page = new NetworkSetupPage();
NetworkFrame.Navigate(page);
page.OnGoOn += () => {
Close();
};
}
/// <summary>
/// The worker in charge of processing data and pushing it to other objects
/// </summary>
private void ProcessWorker()
{
if (m_ProcessBuffer.Count == 0)
{
return;
}
DataChunk chunk = m_ProcessBuffer.Dequeue();
m_ProcessedFrames++;
OnReceiveData(NetworkFrame.ReadFromBytes(chunk.m_Bytes), chunk.m_Endpoint, chunk.m_Bytes);
}
public static NetworkFrame ReadFromBytes(byte[] bytes)
{
string content = Encoding.ASCII.GetString(bytes);
NetworkFrame frame = JsonUtility.FromJson <NetworkFrame>(content);
if (frame == null)
{
throw new Exception($"Error reading frame from bytes, {content} is not a valid NetworkFrame!");
}
return(frame);
}
public CommandLogin(NetworkFrame nf) : base(nf)
{
try
{
char[] separators = { ':' };
String[] tmp = nf.sData.Split(separators);
user = tmp[0];
pass = tmp[1];
} catch (NullReferenceException)
{
throw new Exception();
} catch (IndexOutOfRangeException)
{
throw new Exception();
}
}
private IEnumerator HeartbeatWorker()
{
while (GetNetworkState() == NetworkState.Established)
{
if (m_ServerHeartbeats == 2)
{
Disconnect("Lost connection to host");
continue;
}
m_ServerHeartbeats++;
NetworkFrame heartFrame = new NetworkFrame(NetworkFrame.NetworkFrameType.Heartbeat, GetUniqueIndentifier(), "server");
QueueFrame(heartFrame);
yield return(new WaitForSeconds(2.5f));
}
}
public void Close()
{
if (!isClosed)
{
isClosed = true;
if (incomingChannel != null)
{
try
{
var frame = NetworkFrame.CreateCloseFrame(PayloadData.Empty, MasksOutgoingMessages).ToArray();
outgoingChannel.WriteBytes(frame, frame.Length);
}
catch
{
//Do nothing
}
try
{
// incomingChannel.Close();
incomingChannel.Dispose();
}
catch
{
//Do nothing
}
}
try
{
if (outgoingChannel != null)
{
// outgoingChannel.Close();
outgoingChannel.Dispose();
}
}
catch
{
//Do nothing
}
if (OnClose != null)
{
OnClose(this, EventArgs.Empty);
}
}
}
/// <summary>
/// Called when data is processed and sent across the client/server
/// </summary>
/// <param name="frame">The frame that was processed and sent to us</param>
/// <param name="point">The ip address that sent this to us</param>
/// <param name="bytes">The raw bytes of the frame, used to parse into bigger frames</param>
public virtual void OnReceiveData(NetworkFrame frame, IPEndPoint point, byte[] bytes)
{
if (!m_Endpoints.ContainsKey(frame.m_SenderId))
{
m_Endpoints.Add(frame.m_SenderId, point);
}
if (m_NetworkState == NetworkState.Connecting)
{
if (frame.m_SenderId == "proxy")
{
m_NetworkState = NetworkState.EstablishedProxy;
}
else if (frame.m_SenderId == "server")
{
m_NetworkState = NetworkState.Established;
}
}
}
bool DealWithControlFrame(NetworkFrame frame)
{
if (frame.IsControl)
{
if (frame.IsPing)
{
WriteFrame(NetworkFrame.CreatePongFrame(PayloadData.Empty, MasksOutgoingMessages));
}
else if (frame.IsPong)
{
Trace.WriteLine("Pong received");
}
else if (frame.IsClose)
{
Close();
}
return(true);
}
return(false);
}
void Listen()
{
NetworkFrame.ReadFrameAsync(incomingChannel, !MasksOutgoingMessages, x =>
{
if (!DealWithControlFrame(x))
{
if (OnMessage != null)
{
OnMessage(this, new Message(x.IsText ? MessageType.Text : MessageType.Binary, x.PayloadData.ApplicationData));
}
}
if (!isClosed)
{
Listen();
}
}, e =>
{
Close();
});
}
private void DispatchHandler(NetworkFrame msg)
{
switch (msg.Type)
{
case "READY":
HandleReadyEvent(msg);
break;
case "GUILD_CREATE":
HandleGuildCreate(msg);
break;
case "MESSAGE_CREATE":
var message = JsonConvert.DeserializeObject <Message>(msg.Data.ToString());
OnMessageReceived(RestMessage.CreateMessage(message));
break;
default:
Logger.Log("Other type");
break;
}
}
public CommandChunk(NetworkFrame nf, bool _sentByClient) : base(nf)
{
data = nf.Data;
sentByClient = _sentByClient;
}
public CommandAccept(NetworkFrame nf) : base(nf)
{
}
private void HeartBeatAckHandler(NetworkFrame msg)
{
Logger.Log("[ACK] HeartBreak");
}
public Command(NetworkFrame nf)
{
//code = nf.nCode;
}
public CommandRollback(NetworkFrame nf) : base(nf)
{
}
public CommandError(NetworkFrame nf) : base(nf)
{
byte[] tmp = nf.Data;
errorCode = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(tmp, 0));
}
public CommandExit(NetworkFrame nf) : base(nf)
{
}
//public Message Receive()
//{
// var x = NetworkFrame.ReadFrame(incomingChannel, !MasksOutgoingMessages);
// if (DealWithControlFrame(x)) return Receive();
// return new Message(x.IsText ? MessageType.Text : MessageType.Binary, x.PayloadData.ApplicationData);
//}
public void Ping()
{
WriteFrame(NetworkFrame.CreatePingFrame(MasksOutgoingMessages));
}
public override void OnReceiveData(NetworkFrame frame, IPEndPoint point, byte[] bytes)
{
base.OnReceiveData(frame, point, bytes);
NetworkPlayer player = NetworkManager.Instance.GetPlayer(frame.m_SenderId);
if (!IsUserAuthorized(frame.m_SenderId) && frame.m_Type != NetworkFrame.NetworkFrameType.Authentication)
{
return;
}
switch (frame.m_Type)
{
case NetworkFrame.NetworkFrameType.Handshake:
{
NetworkHandshakeFrame handshake = NetworkFrame.Parse <NetworkHandshakeFrame>(bytes);
player = NetworkManager.Instance.AddPlayer(handshake.m_SenderId, new NetworkPlayer()
{
m_Id = handshake.m_SenderId,
m_Name = handshake.m_DisplayName
});
NetworkSpawnRPC spawnRpc = new NetworkSpawnRPC(-1, true);
OnRPCCommand(player, spawnRpc.ToString());
UpdatePlayer(player);
} break;
case NetworkFrame.NetworkFrameType.Authentication: // TODO: Clean this? Its terrible lol
{
NetworkAuthenticationFrame authenticationFrame = NetworkFrame.Parse <NetworkAuthenticationFrame>(bytes);
if (m_Password != "" && m_Password != null && authenticationFrame.m_Password != m_Password)
{
Debug.Log(m_Password);
authenticationFrame.m_Response = NetworkAuthenticationFrame.NetworkAuthenticationResponse.IncorrectPassword;
}
else if (NetworkManager.Instance.GetPlayerCount() == NetworkManager.Instance.m_Settings.m_MaxPlayers && NetworkManager.Instance.m_Settings.m_MaxPlayers > 0)
{
authenticationFrame.m_Response = NetworkAuthenticationFrame.NetworkAuthenticationResponse.LobbyFull;
}
else
{
Debug.Log("bop");
m_AuthorizedUsers.Add(frame.m_SenderId);
authenticationFrame.m_Response = NetworkAuthenticationFrame.NetworkAuthenticationResponse.Connected;
}
authenticationFrame.m_TargetId = authenticationFrame.m_SenderId;
authenticationFrame.m_SenderId = "server";
QueueFrame(authenticationFrame);
} break;
case NetworkFrame.NetworkFrameType.Ping:
{
NetworkFrame pingFrame = new NetworkFrame(NetworkFrame.NetworkFrameType.Ping, "server", frame.m_SenderId);
QueueFrame(pingFrame);
} break;
case NetworkFrame.NetworkFrameType.RPC:
{
NetworkRPCFrame rpcFrame = NetworkFrame.Parse <NetworkRPCFrame>(bytes);
OnRPCCommand(player, rpcFrame.m_RPC);
} break;
case NetworkFrame.NetworkFrameType.Heartbeat:
{
if (m_Heartbeats.ContainsKey(frame.m_SenderId))
{
m_Heartbeats[frame.m_SenderId] = 0;
}
else
{
m_Heartbeats.Add(frame.m_SenderId, 0);
}
} break;
}
}
public CommandCommitRdy(NetworkFrame nf) : base(nf)
{
}
public CommandCommitAck(NetworkFrame nf) : base(nf)
{
}
public CommandList(NetworkFrame nf) : base(nf)
{
user = nf.sData;
}