private void PackageReceivedEventArgs(object sender, PackageReceivedEventArgs <IPEndPoint> e)
{
var data = e.Payload;
var count = e.Count;
PeerInfo peerInfo;
if (_peerList.TryGet(e.Proto, out peerInfo) && peerInfo.EncryptionKey != null)
{
data = Aes.Decrypt(data, 0, count, peerInfo.EncryptionKey);
}
var botHeader = BotHeader.Decode(data);
if (!IsValidHeader(botHeader))
{
Logger.Warn("Invalid message received by bot {0} from {1}", botHeader.BotId, e.Proto);
_peerList.Punish(botHeader.BotId);
return;
}
botHeader.EndPoint = e.Proto;
_peerList.UpdatePeer(botHeader.BotId);
var args = new PackageReceivedEventArgs <BotHeader>(botHeader, data, count);
Events.Raise(BotPackageReceivedEventArgs, this, args);
}
private static void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
var package = e.Package;
Console.WriteLine("Package recived of type: {0}", nameof(package));
//Switch over all diffrent PackageTypes and handle them:
switch (package)
{
case AuthenticationResultPackage p:
if (p.Result == AuthenticationResult.Ok)
{
Log.Info("Authentication succeed");
}
else
{
Log.Warn("Authentication failed");
}
break;
case BasePackage p:
Console.WriteLine("Package is BasePackage");
break;
default:
Console.WriteLine("Unhandled Package");
break;
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
switch (e.Package)
{
case GameListPackage p:
HandleOnGameListReceived(p);
break;
case CreateMatchPackage p:
AddMatchToList(p.MatchData);
break;
case PlayerJoinedMatchPackage p:
HandleOnPlayerChangedMatch(p);
break;
case MatchJoinFailedPackage p:
HandleOnJoinMatchFailed(p);
break;
case PlayerLeftMatchPackage p:
HandleOnPlayerLeftMatch(p);
break;
case MatchFinishedPackage p:
HandleOnMatchFinished(p);
break;
case RemoveMatchPackage p:
HandleOnRemoveMatch(p);
break;
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
try
{
if (e.Exception != null)
{
ServerModel.Logger.Write(e.Exception);
return;
}
if (!isServerRunning)
{
return;
}
var connectionId = ((ServerConnection)sender).Id;
var command = ServerModel.Api.GetCommand(e.Package.Id);
var args = new ServerCommandArgs(connectionId, e.Package);
requestQueue.Add(connectionId, command, args);
}
catch (Exception exc)
{
ServerModel.Logger.Write(exc);
}
}
private void PackageReceivedEventArgs(object sender, PackageReceivedEventArgs <IPEndPoint> e)
{
var data = e.Payload;
var now = new TimeSpan(DateTime.UtcNow.Ticks);
var minutes = now.TotalMilliseconds / (1000 * 60);
var xor = new Mod2(BitConverter.GetBytes(minutes));
xor.Decrypt(data);
var rc4 = new Rc4(_botId.ToByteArray());
rc4.Decrypt(data);
var botHeader = BotHeader.Decode(data);
if (!IsValidHeader(botHeader))
{
_peerList.Punish(botHeader.BotId);
return;
}
botHeader.EndPoint = e.Proto;
_peerList.UpdatePeer(botHeader.BotId);
Events.Raise(BotPackageReceivedEventArgs, this, new PackageReceivedEventArgs <BotHeader>(botHeader, data));
}
private void Server_PackageReceived(object sender, UCBServer.UCBServerPackageRecveivedEventArgs e)
{
if (IdentifiedServers.ContainsKey(e.Connection))
{
PackageReceivedEventArgs arg = new PackageReceivedEventArgs(IdentifiedServers[e.Connection], e.Package);
PackageReceived?.Invoke(this, arg);
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
switch (e.Package)
{
case AuthenticationResultPackage p:
HandleAuthenticationResult(p);
break;
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
switch (e.Package)
{
case RegistrationResultPackage package:
HandleRegisterResult(package);
break;
}
}
private void ArduinoLidarDriver_PackageReceived(object sender, PackageReceivedEventArgs e)
{
switch (e.ResponseCommandByte)
{
// Messwert aufgenommen
case 100:
ProcessScanValue(e.Package);
break;
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
InvokeGui(() =>
{
switch (e.Package)
{
case MatchCreatedPackage _:
NotifyForCreatedMatch();
break;
}
});
}
private void HandleWsClientOnMessageReceived(object sender, PackageReceivedEventArgs args)
{
var target = AbonentType.WebSocketTransceiver;
if (_enableRepeaterMode)
{
target = AbonentType.Client;
Send(target, args.JsonString);
}
_eventAggregator.GetEvent <PackageTransmittedEvent>().Publish(new PackageTransmittedArgs(AbonentType.Server, target, args.JsonString));
}
private static void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
var package = e.Package;
Log.Debug("RECV: Package recived of type: " + e.Package.GetType().Name);
switch (package)
{
case AuthenticationPackage p:
HandleOnAuthenticationPackage(p, e.SenderTcpClient);
break;
case RegistrationPackage p:
HandleOnRegistrationPackage(p, e.SenderTcpClient);
break;
case RequestGamelistPackage p:
HandleOnRequestGamelistPackage(p);
break;
case CreateMatchPackage p:
HandleOnCreateMatchPackage(p);
break;
case JoinMatchPackage p:
HandleOnJoinMatchPackage(p);
break;
case LeaveMatchPackage p:
HandleOnLeaveMatchPackage(p);
break;
case RequestMatchDataPackage p:
HandleOnRequestMatchDataPackage(p);
break;
case PickedWordPackage p:
HandleOnPickedWordPackage(p);
break;
case DrawingAreaChangedPackage p:
HandleOnDrawingAreaChangedPackage(p);
break;
case WordGuessPackage p:
HandleOnWordGuessPackage(p);
break;
}
}
protected override void OnPackageReceived(PackageReceivedEventArgs e)
{
try
{
if (e.Exception != null)
{
OnError(e.Exception);
return;
}
_requestQueue.Add(ClientId, e.Unpacked);
}
catch (Exception exc)
{
OnError(exc);
}
}
private void OnDataReceived(TcpFrameArrivedEventArgs message)
{
var deserialized = _objectSerializerService.Deserialize(message.FrameData);
if (deserialized is EonPacket eonPacket)
{
var args = new PackageReceivedEventArgs {
Packet = eonPacket
};
PackageReceived?.Invoke(this, args);
}
else if (deserialized is ISignalingMessage signalingMessage)
{
var args = new MessageReceivedEventArgs {
Message = signalingMessage
};
MessageReceived?.Invoke(this, args);
}
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
try
{
if (e.Exception != null)
{
_logger.Write(e.Exception);
}
else if (_isServerRunning)
{
var connectionId = ((ServerConnection)sender).Id;
_requestQueue.Add(connectionId, e.Unpacked);
}
}
catch (Exception exc)
{
_logger.Write(exc);
}
}
protected override void OnPackageReceived(PackageReceivedEventArgs e)
{
try
{
if (e.Exception != null)
{
OnError(e.Exception);
return;
}
var command = ClientModel.Api.GetCommand(e.Unpacked.Package.Id);
var args = new ClientCommandArgs(null, e.Unpacked);
requestQueue.Add(ClientId, command, args);
}
catch (Exception exc)
{
OnError(exc);
}
}
protected override void OnPackageReceived(PackageReceivedEventArgs args)
{
if (args.Exception != null)
{
var se = args.Exception as SocketException;
if (se != null && se.SocketErrorCode == SocketError.ConnectionReset)
{
return;
}
ServerModel.Logger.Write(args.Exception);
return;
}
var temp = Interlocked.CompareExchange(ref dataReceivedCallback, null, null);
if (temp != null)
{
temp(this, args);
}
}
protected override void OnPackageReceived(PackageReceivedEventArgs args)
{
if (args.Exception != null)
{
var se = args.Exception as SocketException;
if (se != null && se.SocketErrorCode == SocketError.ConnectionReset)
{
return;
}
_logger.Write(args.Exception);
return;
}
var temp = Volatile.Read(ref _receivedCallback);
if (temp != null)
{
temp(this, args);
}
}
private static void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
var package = e.Package;
Console.WriteLine("Package recived of type: {0}", nameof(package));
//Switch over all different PackageTypes and handle them:
switch (package)
{
case AuthenticationPackage p:
HandleAuthPackage(p, e.SenderTcpClient);
break;
case BasePackage p:
Console.WriteLine("Package is BasePackage");
break;
default:
Console.WriteLine("Unhandled Package");
break;
}
}
public static void packagesListener_onPackageReceived(object o, PackageReceivedEventArgs e)
{
Console.WriteLine("Received message");
Console.WriteLine(e.sourceIp);
Console.WriteLine(e.message);
var nextPackage = new Package
{
Ip = e.sourceIp,
Message = e.message,
Parsed = false
};
if (!_lastPackages.ContainsKey(nextPackage.Message))
{
_lastPackages.Add(nextPackage.Message, DateTime.Now);
}
else
{
var diffInSeconds = (DateTime.Now - _lastPackages[nextPackage.Message]).TotalSeconds;
if (diffInSeconds < 5)
{
Console.WriteLine("Paquete rechazado, solo han pasado {0} segundos desde el ultimo.", diffInSeconds);
return;
}
}
try
{
Console.WriteLine("Insertando");
_lastPackages[nextPackage.Message] = DateTime.Now;
packagesRepository.Add(nextPackage);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected override void OnPackageReceived(PackageReceivedEventArgs e)
{
try
{
if (e.Exception != null)
{
OnError(e.Exception);
return;
}
var command = ClientModel.Api.GetCommand(e.Unpacked.Package.Id);
var args = new ClientCommandArgs(null, e.Unpacked);
requestQueue.Add(ClientId, command, args);
}
catch (Exception exc)
{
OnError(exc);
}
}
protected abstract void OnPackageReceived(PackageReceivedEventArgs args);
/// <summary>
/// 当数据包收到事件触发时，被调用
/// </summary>
/// <param name="client">引发此事件的源对象</param>
/// <param name="e">包含事件的参数</param>
internal static void OnUdpPackageReceived(IPMClient client, PackageReceivedEventArgs e)
{
SendOrPostCallback(false, UdpPackageReceived, client, e);
}
void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
_routingService.ProcessPackage(e.Packet);
}
protected override void OnPackageReceived(PackageReceivedEventArgs args)
{
if (args.Exception != null)
{
var se = args.Exception as SocketException;
if (se != null && se.SocketErrorCode == SocketError.ConnectionReset)
return;
ServerModel.Logger.Write(args.Exception);
return;
}
var temp = Interlocked.CompareExchange(ref dataReceivedCallback, null, null);
if (temp != null)
temp(this, args);
}
private void OnPackageReceived(object sender, PackageReceivedEventArgs e)
{
switch (e.Package)
{
#region Autentication
case AuthenticationResultPackage p:
HandleAuthenticationPackage(p);
break;
case MatchDataPackage p:
HandleMatchDataPackage(p);
break;
#endregion
#region MatchHandling
case PlayerJoinedMatchPackage p:
HandleOnPlayerJoinedMatch(p);
break;
case PlayerLeftMatchPackage p:
HandleOnPlayerLeftMatch(p);
break;
#endregion
#region TimerEvents
case MatchFinishedPackage _:
SetDrawingPlayerToGuessing();
StopTimer();
ClearDrawingAreaAndWord();
ClearGuessList();
HandleOnMatchFinished();
break;
case SubRoundStartedPackage _:
StartTimer();
EnableCorrectArea();
break;
case SubRoundFinishedPackage _:
StopTimer();
ClearDrawingAreaAndWord();
ResetCorrectGuessesInPlayerList();
ClearGuessList();
DisableDrawingArea();
DisableGuessingArea();
break;
case RoundStartedPackage p:
ChangeRoundNumber(p.RoundNumber);
break;
case PreparationTimeFinishedPackage _:
SetPreparingPlayerToDrawing();
break;
case PreparationTimeStartedPackage p:
SetDrawingPlayerToGuessing();
SetPlayerToPreparing(p.PreparingPlayer);
break;
#endregion
#region Wordhandling
case PickWordsPackage p:
HandlePickingWords(p);
break;
case WordToDrawPackage p:
HandleOnWordPicked(p);
break;
case WordGuessPackage p:
HandleOnWordGuessedByOtherPlayer(p);
break;
case WordGuessCorrectPackage p:
HandleOnWordGuessCorrect(p);
break;
case ScoreChangedPackage p:
HandleOnScoreChanged(p);
break;
case WordSolutionPackage p:
HandleOnWordSolution(p);
break;
#endregion
#region DrawingArea
case DrawingAreaChangedPackage p:
HandleOnDrawingAreaChanged(p);
break;
#endregion
}
}
