public void Handle(IPEndPoint sender, SNMessageData messageData)
{
var playerLoginMessageData = (PlayerLoginMessageData)messageData;
Task.Run(() =>
{
if (IsValidUser(playerLoginMessageData.Email, playerLoginMessageData.Password, out string persistentId))
{
string token = tokenManager.GenerateToken(playerLoginMessageData.Email, persistentId);
tokenRepository.Add(token);
var msg = zoneServerNetPeer.CreateMessage();
var playerLoginSuccessMessageData = new PlayerLoginSuccessMessageData();
playerLoginSuccessMessageData.Token = token;
playerLoginSuccessMessageData.Encode(msg);
zoneServerNetPeer.SendUnconnectedMessage(msg, sender);
}
else
{
var msg = zoneServerNetPeer.CreateMessage();
var playerLoginErrorMessageData = new PlayerLoginErrorMessageData();
playerLoginErrorMessageData.Encode(msg);
zoneServerNetPeer.SendUnconnectedMessage(msg, sender);
}
});
}
public void ProcessesDataQueue()
{
NetIncomingMessage msg;
while (PacketQueue.TryDequeue(out msg))
{
SNMessageData messageData = zoneMessageFactory.GetMessageData(msg.PeekInt16());
if (messageData == null)
{
return;
}
messageData.Decode(msg);
switch (msg.MessageType)
{
case NetIncomingMessageType.UnconnectedData:
HandleMessageData(msg.SenderEndPoint, messageData);
break;
case NetIncomingMessageType.Data:
HandleMessageData(msg.SenderConnection, messageData);
break;
}
}
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(sender.Tag is PlayerClient))
{
return;
}
var client = (PlayerClient)sender.Tag;
var selectCharacterMessageData = (SelectCharacterMessageData)messageData;
if (!IsAccountCharacter(client.PersistentId, selectCharacterMessageData.CharacterId, out Character character))
{
return;
}
var characterSelectedMessageData = new CharacterSelectedMessageData();
characterSelectedMessageData.Character = character;
outgoingMessageService.Send(characterSelectedMessageData, sender);
var player = new Player(client, character);
playerRepository.Add(player);
sender.Tag = player;
// Send already connected players positions
entitiesProcessor.NewPlayerConnected(player);
}
public void Send(SNMessageData messageData, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered)
{
var outgoingMessage = peer.CreateMessage();
messageData.Encode(outgoingMessage);
peer.SendMessage(outgoingMessage, peer.Connections[0], method);
}
public void Handle(IPEndPoint sender, SNMessageData messageData)
{
var playerLoginSuccesMessageData = (PlayerLoginSuccessMessageData)messageData;
NetOutgoingMessage approval = zoneClientNetPeer.CreateMessage();
approval.Write(playerLoginSuccesMessageData.Token);
zoneClientNetPeer.Connect(Constants.Host, Constants.ZoneServerPort, approval);
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(sender.Tag is Player))
{
return;
}
entitiesProcessor.NewPlayerConnected((Player)sender.Tag);
}
private void HandleMessageData(IPEndPoint ep, SNMessageData messageData)
{
if (_handlersUnconnected.ContainsKey((ZoneMessageTypes)messageData.DataHeader))
{
_handlersUnconnected[(ZoneMessageTypes)messageData.DataHeader](ep, messageData);
}
else
{
loggingService.Log($"Could not handle {messageData.DataHeader.ToString()} message", LogMessageType.WARNING);
}
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(Core.Scene is CharacterSelectionScene))
{
return;
}
var sendCharactersMessageData = (SendCharactersMessageData)messageData;
((CharacterSelectionScene)Core.Scene).LoadCharacters(sendCharactersMessageData.Characters);
}
private void HandleMessageData(NetConnection connection, SNMessageData messageData)
{
if (_handlers.ContainsKey((ZoneMessageTypes)messageData.DataHeader))
{
_handlers[(ZoneMessageTypes)messageData.DataHeader](connection, messageData);
}
else
{
loggingService.Log($"Could not handle {messageData.DataHeader.ToString()} message", LogMessageType.WARNING);
}
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(sender.Tag is Player))
{
return;
}
var playerDirectionMessageData = (PlayerDirectionMessageData)messageData;
var player = (Player)sender.Tag;
player.Velocity.X = playerDirectionMessageData.X;
player.Velocity.Y = playerDirectionMessageData.Y;
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
var characterSelectedMessageData = (CharacterSelectedMessageData)messageData;
var gameScene = serviceProvider.GetService <GameScene>();
Core.Scene = gameScene;
gameScene.LoadCharacter(characterSelectedMessageData.Character);
var characterLoadedMessageData = new CharacterLoadedMessageData();
outgoingMessageService.Send(characterLoadedMessageData);
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(sender.Tag is PlayerClient))
{
return;
}
var client = (PlayerClient)sender.Tag;
var sendCharactersMessageData = new SendCharactersMessageData();
sendCharactersMessageData.Characters = GetCharacters(client.PersistentId);
outgoingMessageService.Send(sendCharactersMessageData, sender);
}
public SNMessageData GetMessageData(short type)
{
MasterMessageTypes header = (MasterMessageTypes)type;
SNMessageData message = null;
switch (header)
{
default:
loggingService.Log($"Cannot build master message {header.ToString()}", LogMessageType.WARNING);
break;
}
return(message);
}
public void Send(SNMessageData messageData, IList <NetConnection> clients, NetConnection except = null, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered)
{
var outgoingMessage = peer.CreateMessage();
messageData.Encode(outgoingMessage);
if (except != null && clients.Contains(except))
{
clients.Remove(except);
}
if (clients.Count < 1)
{
return;
}
peer.SendMessage(outgoingMessage, clients, method, 0);
}
public SNMessageData GetMessageData(short type)
{
ClientMessageTypes header = (ClientMessageTypes)type;
SNMessageData message = null;
switch (header)
{
#region Authentification
case ClientMessageTypes.PlayerLoginSuccess:
message = new PlayerLoginSuccessMessageData();
break;
case ClientMessageTypes.PlayerLoginError:
message = new PlayerLoginErrorMessageData();
break;
case ClientMessageTypes.SendCharacters:
message = new SendCharactersMessageData();
break;
case ClientMessageTypes.CharacterSelected:
message = new CharacterSelectedMessageData();
break;
#endregion
#region Entities
case ClientMessageTypes.EntityPosition:
message = new EntityPositionMessageData();
break;
case ClientMessageTypes.CharacterDisconnected:
message = new CharacterDisconnectedMessageData();
break;
#endregion
default:
loggingService.Log($"Cannot build client message {header.ToString()}", LogMessageType.WARNING);
break;
}
return(message);
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
if (!(Core.Scene is GameScene))
{
return;
}
System.Console.WriteLine("Character Disconnected");
var gameScene = (GameScene)Core.Scene;
var characterDisconnectedMessageData = (CharacterDisconnectedMessageData)messageData;
var entity = gameScene.FindEntity(characterDisconnectedMessageData.Character.AccountPersistentId);
System.Console.WriteLine(entity);
if (entity != null)
{
entity.Destroy();
}
}
public void Handle(NetConnection sender, SNMessageData messageData)
{
var entityPositionMessageData = (EntityPositionMessageData)messageData;
if (!(Core.Scene is GameScene))
{
return;
}
var gameScene = (GameScene)Core.Scene;
var entity = gameScene.FindEntity(entityPositionMessageData.Uid);
if (entity == null)
{
entity = new NetPlayerEntity();
entity.Name = entityPositionMessageData.Uid;
gameScene.AddEntity(entity);
}
entity.SetPosition(new Vector2(entityPositionMessageData.X, entityPositionMessageData.Y));
}
public SNMessageData GetMessageData(short type)
{
ZoneMessageTypes header = (ZoneMessageTypes)type;
SNMessageData message = null;
switch (header)
{
#region Authentification
case ZoneMessageTypes.PlayerLogin:
message = new PlayerLoginMessageData();
break;
case ZoneMessageTypes.RequestCharacters:
message = new RequestCharactersMessageData();
break;
case ZoneMessageTypes.SelectCharacter:
message = new SelectCharacterMessageData();
break;
case ZoneMessageTypes.CharacterLoaded:
message = new CharacterLoadedMessageData();
break;
#endregion
#region Players
case ZoneMessageTypes.PlayerDirection:
message = new PlayerDirectionMessageData();
break;
#endregion
default:
loggingService.Log($"Cannot build zone message {header.ToString()}", LogMessageType.WARNING);
break;
}
return(message);
}
public void Handle(IPEndPoint sender, SNMessageData messageData)
{
windowService.CloseTopWindow();
windowService.Open(new OkWindow(windowService, "Error", "Account not found"));
}
public void Send(SNMessageData messageData, IList <NetConnection> connections, NetConnection except = null, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered)
{
throw new Exception("[OutgoingMessageService] Can't send message to specifics client");
}
public void Send(SNMessageData messageData, NetConnection client, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered)
{
throw new Exception("[OutgoingMessageService] Can't send message to a specific client");
}
