private void ProcessMessage(string message)
{
if (Settings.Default.AddJsonRootObject)
{
var json = ParseJson(message, out string root);
if (root.ToLower() == "request")
{
var request = JsonConvert.DeserializeObject <Request>(json);
RequestReceived?.Invoke(this, message);
HandleRequest(request);
}
else if (root.ToLower() == "acknowledge")
{
AckReceived?.Invoke(this, message);
}
else
{
Error?.Invoke(this, new NotSupportedException($"Unknown Message Type: {root}"));
}
}
else
{
var root = JsonConvert.DeserializeObject <RootObject>(message);
switch (root.MessageType)
{
case MessageType.Request:
var request = JsonConvert.DeserializeObject <Request>(message);
RequestReceived?.Invoke(this, message);
HandleRequest(request);
break;
case MessageType.Response:
break;
case MessageType.Acknowledge:
AckReceived?.Invoke(this, message);
break;
default:
Error?.Invoke(this, new NotSupportedException($"Unknown Message Type: {root}"));
break;
}
}
}
protected virtual void Client_PacketReceived(Packet packet)
{
#region LOGGING
Log(packet);
#endregion LOGGING
//Ready to go, only disabled since it is currently unusued
/*if (packet.Type != PacketType.Acknowledgement)
* {
* Send(packet.From, new Packet(new Acknowledgement()
* {
* PacketId = packet.Id
* }));
* }*/
if (packet.Type == PacketType.Acknowledgement)
{
Acknowledgement acknowledgement = packet.SpecificPacket as Acknowledgement;
AckReceived?.Invoke(acknowledgement, packet.From);
}
else if (packet.Type == PacketType.Event)
{
Event @event = packet.SpecificPacket as Event;
switch (@event.Type)
{
case Event.Types.EventType.CoordinatorAdded:
AddCoordinatorReceived(@event.ChangedObject.Unpack <Coordinator>());
break;
case Event.Types.EventType.CoordinatorLeft:
RemoveCoordinatorReceived(@event.ChangedObject.Unpack <Coordinator>());
break;
case Event.Types.EventType.MatchCreated:
AddMatchReceived(@event.ChangedObject.Unpack <Match>());
break;
case Event.Types.EventType.MatchUpdated:
UpdateMatchReceived(@event.ChangedObject.Unpack <Match>());
break;
case Event.Types.EventType.MatchDeleted:
DeleteMatchReceived(@event.ChangedObject.Unpack <Match>());
break;
case Event.Types.EventType.PlayerAdded:
AddPlayerReceived(@event.ChangedObject.Unpack <Player>());
break;
case Event.Types.EventType.PlayerUpdated:
UpdatePlayerReceived(@event.ChangedObject.Unpack <Player>());
break;
case Event.Types.EventType.PlayerLeft:
RemovePlayerReceived(@event.ChangedObject.Unpack <Player>());
break;
case Event.Types.EventType.QualifierEventCreated:
AddQualifierEventReceived(@event.ChangedObject.Unpack <QualifierEvent>());
break;
case Event.Types.EventType.QualifierEventUpdated:
UpdateQualifierEventReceived(@event.ChangedObject.Unpack <QualifierEvent>());
break;
case Event.Types.EventType.QualifierEventDeleted:
DeleteQualifierEventReceived(@event.ChangedObject.Unpack <QualifierEvent>());
break;
case Event.Types.EventType.HostAdded:
break;
case Event.Types.EventType.HostRemoved:
break;
default:
Logger.Error($"Unknown command received!");
break;
}
}
else if (packet.Type == PacketType.ConnectResponse)
{
var response = packet.SpecificPacket as ConnectResponse;
if (response.Response.Type == Response.Types.ResponseType.Success)
{
switch (response.UserCase)
{
case ConnectResponse.UserOneofCase.Coordinator:
SelfObject = response.Coordinator;
Self = new User
{
Id = response.Coordinator.Id,
Name = response.Coordinator.Name
};
break;
case ConnectResponse.UserOneofCase.Player:
SelfObject = response.Player;
Self = new User
{
Id = response.Player.Id,
Name = response.Player.Name
};
break;
}
State = response.State;
ConnectedToServer?.Invoke(response);
}
else if (response.Response.Type == Response.Types.ResponseType.Fail)
{
FailedToConnectToServer?.Invoke(response);
}
}
else if (packet.Type == PacketType.SongFinished)
{
PlayerFinishedSong?.Invoke(packet.SpecificPacket as SongFinished);
}
}
protected virtual void Client_PacketRecieved(Packet packet)
{
#region LOGGING
string secondaryInfo = string.Empty;
if (packet.Type == PacketType.PlaySong)
{
secondaryInfo = (packet.SpecificPacket as PlaySong).Beatmap.LevelId + " : " + (packet.SpecificPacket as PlaySong).Beatmap.Difficulty;
}
else if (packet.Type == PacketType.LoadSong)
{
secondaryInfo = (packet.SpecificPacket as LoadSong).LevelId;
}
else if (packet.Type == PacketType.Command)
{
secondaryInfo = (packet.SpecificPacket as Command).CommandType.ToString();
}
else if (packet.Type == PacketType.Event)
{
secondaryInfo = (packet.SpecificPacket as Event).Type.ToString();
if ((packet.SpecificPacket as Event).Type == Event.EventType.PlayerUpdated)
{
secondaryInfo = $"{secondaryInfo} from ({((packet.SpecificPacket as Event).ChangedObject as Player).Name} : {((packet.SpecificPacket as Event).ChangedObject as Player).DownloadState}) : ({((packet.SpecificPacket as Event).ChangedObject as Player).PlayState} : {((packet.SpecificPacket as Event).ChangedObject as Player).Score} : {((packet.SpecificPacket as Event).ChangedObject as Player).StreamDelayMs})";
}
else if ((packet.SpecificPacket as Event).Type == Event.EventType.MatchUpdated)
{
secondaryInfo = $"{secondaryInfo} ({((packet.SpecificPacket as Event).ChangedObject as Match).SelectedDifficulty})";
}
}
Logger.Debug($"Recieved {packet.ToBytes().Length} bytes: ({packet.Type}) ({secondaryInfo})");
#endregion LOGGING
//Ready to go, only disabled since it is currently unusued
/*if (packet.Type != PacketType.Acknowledgement)
* {
* Send(packet.From, new Packet(new Acknowledgement()
* {
* PacketId = packet.Id
* }));
* }*/
if (packet.Type == PacketType.Acknowledgement)
{
Acknowledgement acknowledgement = packet.SpecificPacket as Acknowledgement;
AckReceived?.Invoke(acknowledgement, packet.From);
}
else if (packet.Type == PacketType.Event)
{
Event @event = packet.SpecificPacket as Event;
switch (@event.Type)
{
case Event.EventType.CoordinatorAdded:
AddCoordinatorRecieved(@event.ChangedObject as MatchCoordinator);
break;
case Event.EventType.CoordinatorLeft:
RemoveCoordinatorRecieved(@event.ChangedObject as MatchCoordinator);
break;
case Event.EventType.MatchCreated:
AddMatchRecieved(@event.ChangedObject as Match);
break;
case Event.EventType.MatchUpdated:
UpdateMatchRecieved(@event.ChangedObject as Match);
break;
case Event.EventType.MatchDeleted:
DeleteMatchRecieved(@event.ChangedObject as Match);
break;
case Event.EventType.PlayerAdded:
AddPlayerRecieved(@event.ChangedObject as Player);
break;
case Event.EventType.PlayerUpdated:
UpdatePlayerRecieved(@event.ChangedObject as Player);
break;
case Event.EventType.PlayerLeft:
RemovePlayerRecieved(@event.ChangedObject as Player);
break;
default:
Logger.Error($"Unknown command recieved!");
break;
}
}
else if (packet.Type == PacketType.ConnectResponse)
{
var response = packet.SpecificPacket as ConnectResponse;
if (response.Type == ConnectResponse.ResponseType.Success)
{
Self = response.Self;
State = response.State;
ConnectedToServer?.Invoke(response);
}
else if (response.Type == ConnectResponse.ResponseType.Fail)
{
FailedToConnectToServer?.Invoke(response);
}
}
else if (packet.Type == PacketType.SongFinished)
{
PlayerFinishedSong?.Invoke(packet.SpecificPacket as SongFinished);
}
}
private void Server_PacketRecieved(ConnectedClient player, Packet packet)
{
#region LOGGING
string secondaryInfo = string.Empty;
if (packet.Type == PacketType.PlaySong)
{
secondaryInfo = (packet.SpecificPacket as PlaySong).Beatmap.LevelId + " : " + (packet.SpecificPacket as PlaySong).Beatmap.Difficulty;
}
else if (packet.Type == PacketType.LoadSong)
{
secondaryInfo = (packet.SpecificPacket as LoadSong).LevelId;
}
else if (packet.Type == PacketType.Command)
{
secondaryInfo = (packet.SpecificPacket as Command).CommandType.ToString();
}
else if (packet.Type == PacketType.Event)
{
secondaryInfo = (packet.SpecificPacket as Event).Type.ToString();
if ((packet.SpecificPacket as Event).Type == Event.EventType.PlayerUpdated)
{
secondaryInfo = $"{secondaryInfo} from ({((packet.SpecificPacket as Event).ChangedObject as Player).Name} : {((packet.SpecificPacket as Event).ChangedObject as Player).DownloadState}) : ({((packet.SpecificPacket as Event).ChangedObject as Player).PlayState} : {((packet.SpecificPacket as Event).ChangedObject as Player).Score} : {((packet.SpecificPacket as Event).ChangedObject as Player).StreamDelayMs})";
}
else if ((packet.SpecificPacket as Event).Type == Event.EventType.MatchUpdated)
{
secondaryInfo = $"{secondaryInfo} ({((packet.SpecificPacket as Event).ChangedObject as Match).SelectedDifficulty})";
}
}
else if (packet.Type == PacketType.ForwardingPacket)
{
secondaryInfo = $"{(packet.SpecificPacket as ForwardingPacket).SpecificPacket.GetType()}";
}
Logger.Debug($"Recieved {packet.ToBytes().Length} bytes: ({packet.Type}) ({secondaryInfo})");
#endregion LOGGING
SendToOverlay(packet);
//Ready to go, only disabled since it is currently unusued
/*if (packet.Type != PacketType.Acknowledgement)
* {
* Send(packet.From, new Packet(new Acknowledgement()
* {
* PacketId = packet.Id
* }));
* }*/
if (packet.Type == PacketType.Acknowledgement)
{
Acknowledgement acknowledgement = packet.SpecificPacket as Acknowledgement;
AckReceived?.Invoke(acknowledgement, packet.From);
}
else if (packet.Type == PacketType.SongList)
{
SongList songList = packet.SpecificPacket as SongList;
}
else if (packet.Type == PacketType.LoadedSong)
{
LoadedSong loadedSong = packet.SpecificPacket as LoadedSong;
}
else if (packet.Type == PacketType.Connect)
{
Connect connect = packet.SpecificPacket as Connect;
if (connect.ClientVersion != SharedConstructs.VersionCode)
{
Send(player.id, new Packet(new ConnectResponse()
{
Type = ConnectResponse.ResponseType.Fail,
Self = null,
State = null,
Message = $"Version mismatch, this server is on version {SharedConstructs.Version}",
ServerVersion = SharedConstructs.VersionCode
}));
}
else if (connect.ClientType == Connect.ConnectTypes.Player)
{
var newPlayer = new Player()
{
Id = player.id,
Name = connect.Name,
UserId = connect.UserId,
Team = new Team()
{
Id = Guid.Empty, Name = "None"
}
};
AddPlayer(newPlayer);
//Give the newly connected player their Self and State
Send(player.id, new Packet(new ConnectResponse()
{
Type = ConnectResponse.ResponseType.Success,
Self = newPlayer,
State = State,
Message = $"Connected to {serverName}!",
ServerVersion = SharedConstructs.VersionCode
}));
}
else if (connect.ClientType == Connect.ConnectTypes.Coordinator)
{
var coordinator = new MatchCoordinator()
{
Id = player.id,
Name = connect.Name
};
AddCoordinator(coordinator);
//Give the newly connected coordinator their Self and State
Send(player.id, new Packet(new ConnectResponse()
{
Type = ConnectResponse.ResponseType.Success,
Self = coordinator,
State = State,
Message = $"Connected to {serverName}!",
ServerVersion = SharedConstructs.VersionCode
}));
}
}
else if (packet.Type == PacketType.Event)
{
Event @event = packet.SpecificPacket as Event;
switch (@event.Type)
{
case Event.EventType.CoordinatorAdded:
AddCoordinator(@event.ChangedObject as MatchCoordinator);
break;
case Event.EventType.CoordinatorLeft:
RemoveCoordinator(@event.ChangedObject as MatchCoordinator);
break;
case Event.EventType.MatchCreated:
CreateMatch(@event.ChangedObject as Match);
break;
case Event.EventType.MatchUpdated:
UpdateMatch(@event.ChangedObject as Match);
break;
case Event.EventType.MatchDeleted:
DeleteMatch(@event.ChangedObject as Match);
break;
case Event.EventType.PlayerAdded:
AddPlayer(@event.ChangedObject as Player);
break;
case Event.EventType.PlayerUpdated:
UpdatePlayer(@event.ChangedObject as Player);
break;
case Event.EventType.PlayerLeft:
RemovePlayer(@event.ChangedObject as Player);
break;
default:
Logger.Error($"Unknown command recieved from {player.id}!");
break;
}
}
else if (packet.Type == PacketType.SongFinished)
{
BroadcastToAllClients(packet);
PlayerFinishedSong?.Invoke(packet.SpecificPacket as SongFinished);
}
else if (packet.Type == PacketType.ForwardingPacket)
{
var forwardingPacket = packet.SpecificPacket as ForwardingPacket;
var forwardedPacket = new Packet(forwardingPacket.SpecificPacket);
ForwardTo(forwardingPacket.ForwardTo, packet.From, forwardedPacket);
}
}
