public static void InterpretCommand(dynamic message, SyncService s, SyncRoom room)
{
if (RegisteredInterpreters[(string)message.CommandType] != null)
{
Action <dynamic, SyncService, SyncRoom> act = RegisteredInterpreters[(string)message.CommandType];
act.Invoke(message, s, room);
}
}
public static void OnAddLike(dynamic message, SyncService s, SyncRoom room)
{
var res = new
{
CommandType = CommandType.UPDATELIKES.Value,
Likes = room.AddLike()
};
room.Broadcast(JsonConvert.SerializeObject(res));
}
public static void OnUsernameUpdate(dynamic message, SyncService s, SyncRoom room)
{
s.Nickname = (string)message.Nickname;
//notify of nickname change
var res1 = new
{
CommandType = CommandType.SETUSERNICKNAME.Value,
Nickname = s.Nickname
};
s.SendMessage(JsonConvert.SerializeObject(res1));
//notify rest of room of nickname change
room.SendUserList();
}
public static void OnKickUser(dynamic message, SyncService s, SyncRoom room)
{
if (s.Permissions == UserPermissionLevel.OWNER)
{
SyncService target = room.GetServiceByNickname((string)message.TargetNickname);
var res = new
{
CommandType = CommandType.KICKUSER.Value
};
target.SendMessage(JsonConvert.SerializeObject(res));
target.Disconnect();
}
}
public static void OnUpgradeUserPermissions(dynamic message, SyncService s, SyncRoom room)
{
if (s.Permissions == UserPermissionLevel.OWNER)
{
SyncService target = room.GetServiceByNickname((string)message.TargetNickname);
if ((bool)message.Upgrade)
{
target.Permissions = UserPermissionLevel.TRUSTED;
}
else
{
target.Permissions = UserPermissionLevel.VIEWER;
}
}
}
public static void OnSyncState(dynamic message, SyncService s, SyncRoom room)
{
if (s.Permissions == UserPermissionLevel.OWNER)
{
var res = new
{
CommandType = CommandType.SYNCSTATE.Value,
State = new
{
Paused = message.Paused,
Time = message.Time
}
};
room.Broadcast(JsonConvert.SerializeObject(res));
}
}
public static void OnModifyQueue(dynamic message, SyncService s, SyncRoom room)
{
if (s.Permissions == UserPermissionLevel.OWNER || s.Permissions == UserPermissionLevel.TRUSTED)
{
room.CurrentQueue.Name = message.Queue.Name;
room.CurrentQueue.QueueIndex = message.Queue.QueueIndex;
room.CurrentQueue.URLs = message.Queue.URLs.ToObject <string[]>();
var res = new
{
CommandType = CommandType.QUEUEUPDATE.Value,
Queue = new
{
Name = room.CurrentQueue.Name,
QueueIndex = room.CurrentQueue.QueueIndex,
URLs = room.CurrentQueue.URLs
}
};
room.BroadcastExcept(JsonConvert.SerializeObject(res), s);
}
}
public static void OnRegisterUser(dynamic message, SyncService s, SyncRoom room)
{
var success = false;
if (UserAuth.RegisterUser((string)message.Username, (string)message.Email, (string)message.Password))
{
Logger.Log("Client {0} successfully registered as {1}.", s.Nickname, message.Username);
s.Nickname = message.Username;
success = true;
}
else
{
Logger.Log("Something went wrong with registration");
}
var res = new
{
CommandType = CommandType.REGISTERUSER.Value,
Value = success
};
s.SendMessage(JsonConvert.SerializeObject(res));
}
public static void OnStatusUpdate(dynamic message, SyncService s, SyncRoom room)
{
s.status = (UserStatus)message.Status;
room.SendUserList();
}
public static void OnUserListRequested(dynamic message, SyncService s, SyncRoom room)
{
room.SendUserList();
}
public static void OnChat(dynamic message, SyncService s, SyncRoom room)
{
room.Broadcast(JsonConvert.SerializeObject(message));
}
public static void OnLoginUser(dynamic message, SyncService s, SyncRoom room)
{
throw new NotImplementedException();
}
private static void GotMessage(object state)
{
NetIncomingMessage incomingMessage;
while ((incomingMessage = Client.ReadMessage()) != null)
{
// handle incoming message
switch (incomingMessage.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
var text = incomingMessage.ReadString();
Console.WriteLine($"{incomingMessage.MessageType}: {text}");
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)incomingMessage.ReadByte();
var reason = incomingMessage.ReadString();
Console.WriteLine($"{status}, Reason: {reason}");
switch (status)
{
case NetConnectionStatus.Connected:
Connected?.Invoke(null, EventArgs.Empty);
break;
case NetConnectionStatus.Disconnected:
Disconnected?.Invoke(null, EventArgs.Empty);
break;
}
break;
case NetIncomingMessageType.Data:
var messageType = (PacketType)incomingMessage.ReadInt16();
switch (messageType)
{
case PacketType.SPacketJoinRoom:
JoinRoomResponse?.Invoke(null, incomingMessage.ReadStruct <SPacketJoinRoom>());
break;
case PacketType.SPacketCreateRoom:
CreateRoomResponse?.Invoke(null, incomingMessage.ReadStruct <SPacketCreateRoom>());
break;
case PacketType.SPacketSyncRoom:
{
var packet = incomingMessage.ReadClass <SPacketSyncRoom>();
if (Room == null || Room.Id != packet.RoomId)
{
Room = new Room(packet.RoomId);
}
Player = packet.Players[packet.YourPlayer];
Room.Players.Clear();
Room.Players.AddRange(packet.Players);
Room.Board.Clear();
Room.Board.AddRange(packet.Board);
if (Room.CurrentPlayer != Player.Id && packet.CurrentPlayer == Player.Id)
{
TurnStarted?.Invoke(null, EventArgs.Empty);
}
Room.CurrentPlayer = packet.CurrentPlayer;
SyncRoom?.Invoke(null, packet);
break;
}
case PacketType.SPacketFloatingPiece:
FloatingPiece?.Invoke(null, incomingMessage.ReadStruct <SPacketFloatingPiece>());
break;
}
break;
default:
Console.WriteLine($"Unhandled type: {incomingMessage.MessageType} {incomingMessage.LengthBytes} bytes");
break;
}
Client.FlushSendQueue();
Client.Recycle(incomingMessage);
}
}
