public static NetData RecoverBytes(byte[] bytesData, int bytesCount, out ushort type)
{
ushort _type = type = BitConverter.ToUInt16(bytesData, 0);
if (bytesCount > 2 && SynchronizableTypes.TypeExists(type))
{
byte[] bytes = new byte[bytesCount - 2];
for (int i = 0; i < bytesCount - 2; i++)
{
bytes[i] = bytesData[i + 2];
}
object message = null;
try
{
using (var memoryStream = new MemoryStream(bytes))
Serializer.NonGeneric.TryDeserializeWithLengthPrefix(memoryStream, PrefixStyle.Base128, filed => typeof(NetData), out message);
return(message as NetData);
}
catch (Exception e)
{
return(null);
}
}
else
{
return(null);
}
}
static void Main(string[] args)
{
server = new ServerHandler("Users.bd", "Attributes.config", new PGN.DataBase.SQLiteBehaivour());
ServerHandler.onLogReceived += (string log) => { Console.WriteLine(log); };
serverUser = new User("Server Callback User");
server.RegistrUser(serverUser);
ServerHandler.onUserConnectedTCP += (User user) => { Console.WriteLine($"User {user.ID} was connected via TCP"); };
ServerHandler.onUserDisconnectedTCP += (User user) => { Console.WriteLine($"User {user.ID} was disconnected via TCP"); };
ServerHandler.onUserConnectedUDP += (User user) => { Console.WriteLine($"User {user.ID} was connected via UDP"); };
ServerHandler.onUserDisconnectedUDP += (User user) => { Console.WriteLine($"User {user.ID} was disconnected via UDP"); };
//server.SetLocalAdressTCP("192.168.0.1", 8000);
// server.SetLocalAdressUDP("192.168.0.1", 8001);
server.SetLocalAdressTCP("127.0.0.1", 8000);
server.SetLocalAdressUDP("127.0.0.1", 8001);
Console.WriteLine("Server IP: " + "127.0.0.1");
SynchronizableTypes.EnableTransitNonValidTypes();
server.Start();
Console.ReadLine();
}
public static byte[] GetBytesData(NetData message)
{
using (var memoryStream = new MemoryStream())
{
ushort _type = SynchronizableTypes.GetTypeID(message.data.GetType());
if (SynchronizableTypes.TypeExists(_type))
{
Serializer.NonGeneric.SerializeWithLengthPrefix(memoryStream, message, PrefixStyle.Base128, _type);
byte[] source = memoryStream.ToArray();
byte[] dest = new byte[source.Length + 2];
byte[] type = BitConverter.GetBytes(_type);
dest[0] = type[0];
dest[1] = type[1];
for (int i = 2; i < dest.Length; i++)
{
dest[i] = source[i - 2];
}
return(dest);
}
else
{
return(null);
}
}
}
public ServerHandler(string databasePath, string attributesPath, DataBase.DataBaseBehaivour dataBaseBehaivour) : base()
{
DataBaseBehaivour = dataBaseBehaivour;
dataBaseBehaivour.Init(databasePath, attributesPath);
SynchronizableTypes.AddType(typeof(ValidateServerCall.Refresh),
(object data, string id) =>
{
ValidateServerCall.Refresh refresh = data as ValidateServerCall.Refresh;
if (refresh.info == null || refresh.info.dataAttributes.Count == 0)
{
SendMessageViaTCP(new NetData(new ValidateServerCall.Refresh(clients[id].info), false), clients[id]);
}
else
{
clients[id].info = refresh.info;
}
}
);
SynchronizableTypes.AddSyncSubType(typeof(DataBase.UserInfo));
SynchronizableTypes.AddSyncSubType(typeof(DataBase.DataProperty));
MatchmakingController.Init();
}
public ClientHandler() : base()
{
SynchronizableTypes.AddType(typeof(ValidateServerCall.Refresh), (object data, string id) =>
{
OnLogReceived("Refreshed");
var refresh = data as ValidateServerCall.Refresh;
onRefreshed?.Invoke(refresh.info);
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnJoinedToRoomCallback), (object data, string id) =>
{
var joined = data as MatchmakingServerCall.OnJoinedToRoomCallback;
onJoinedToRoom?.Invoke(joined.ids);
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnMatchReadyCallback), (object data, string id) =>
{
var ready = data as MatchmakingServerCall.OnMatchReadyCallback;
onMatchReady.Invoke(ready.userInfos);
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnGetLobbysListCallback), (object data, string id) =>
{
var lobbysGet = data as MatchmakingServerCall.OnGetLobbysListCallback;
onGetLobbysList?.Invoke(lobbysGet.lobbys);
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnPlayerLeaveCallback), (object data, string id) =>
{
onUserLeaveRoom?.Invoke(id);
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnRoomRealeasedCallback), (object data, string id) =>
{
onRoomReleased?.Invoke();
});
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.OnLobbyDestoyedCallback), (object data, string id) =>
{
onLobbyDestroyed?.Invoke();
});
SynchronizableTypes.AddSyncSubType(typeof(DataBase.UserInfo));
SynchronizableTypes.AddSyncSubType(typeof(DataBase.DataProperty));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.JoinToMatch));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.GetLobbysList));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.CreateLobby));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.JoinToLobby));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.LeaveFromRoom));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.ReleaseRoom));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.StartLobby));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.DestroyLobby));
}
/// <summary>
/// Handle recieved messages
/// Обработка пришедших сообщений
/// </summary>
///
public void HandleData()
{
if (onConnectCondition)
{
onConnect?.Invoke();
onConnectCondition = false;
connected = true;
}
if (onDisconnectCondition)
{
onDisconnect?.Invoke();
onDisconnectCondition = false;
connected = false;
}
if (onConnectionLostCondition)
{
onConnectionLost?.Invoke();
onConnectionLostCondition = false;
}
if (onServerNotAvaibleCondition)
{
onServerNotAvaible?.Invoke();
onServerNotAvaibleCondition = false;
}
if (connected)
{
lock (messages)
{
while (messages.Count != 0)
{
PhantomMessage phantomMessage = messages.Dequeue();
SynchronizableTypes.InvokeClientAction(phantomMessage.bytes, phantomMessage.bytesCount);
}
}
}
}
public void GetMessage()
{
do
{
byte[] bytes = new byte[1024];
int bytesCount = 0;
try
{
bytesCount = stream.Read(bytes, 0, bytes.Length);
if (bytesCount < 2)
{
throw new Exception("null bytes");
}
}
catch
{
if (user != null)
{
ServerHandler.OnUserDisconnectedTCP(user);
ServerHandler.OnUserDisconnectedUDP(user);
ServerHandler.RemoveConnection(user);
}
Close();
return;
}
ushort type;
bool transitable;
NetData message = NetData.RecoverBytes(bytes, bytesCount, out type, out transitable);
if (!transitable)
{
if (message != null)
{
if (ServerHandler.clients.ContainsKey(message.senderID))
{
if (ServerHandler.clients[message.senderID].tcpConnection == null)
{
user = ServerHandler.clients[message.senderID];
user.tcpConnection = this;
ServerHandler.OnUserConnectedTCP(user);
}
}
else
{
user = new User(message.senderID);
user.tcpConnection = this;
ServerHandler.AddConnection(user);
ServerHandler.OnUserConnectedTCP(user);
Matchmaking.DefaultRoom.instance.JoinToRoom(user);
if (user.info == null)
{
user.info = ServerHandler.DataBaseBehaivour.GetUserData(message.senderID);
}
if (user.info == null)
{
user.info = ServerHandler.DataBaseBehaivour.CreateUser(message.senderID);
}
}
SynchronizableTypes.InvokeTypeActionTCP(type, bytes, message, ServerHandler.clients[message.senderID]);
}
else
{
if (user != null)
{
ServerHandler.OnUserDisconnectedTCP(user);
ServerHandler.OnUserDisconnectedUDP(user);
ServerHandler.RemoveConnection(user);
}
Close();
return;
}
}
else
{
user.currentRoom.BroadcastMessageTCP(bytes);
}
}while (stream.DataAvailable);
}
public Handler()
{
SynchronizableTypes.Init();
}
private static void GetMessage(UdpClient client, IAsyncResult ar)
{
IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Any, 8001);
UdpClient udpClient = (ar.AsyncState as UdpClient);
byte[] bytes = null;
try
{
bytes = udpClient.EndReceive(ar, ref iPEndPoint);
if (bytes.Length < 2)
{
throw new Exception("null bytes");
}
}
catch
{
return;
}
finally
{
if (bytes != null)
{
ushort type;
bool transitable;
NetData message = NetData.RecoverBytes(bytes, bytes.Length, out type, out transitable);
if (!transitable || !ServerHandler.udpConnections.ContainsKey(iPEndPoint))
{
if (message != null)
{
User udpUser = null;
if (ServerHandler.clients.ContainsKey(message.senderID))
{
if (ServerHandler.clients[message.senderID].udpConnection == null)
{
ServerHandler.OnUserConnectedUDP(ServerHandler.clients[message.senderID]);
UdpConnection udpConnection = new UdpConnection(iPEndPoint);
udpConnection.user = ServerHandler.clients[message.senderID];
ServerHandler.clients[message.senderID].udpConnection = udpConnection;
ServerHandler.udpConnections.Add(iPEndPoint, udpConnection);
}
udpUser = ServerHandler.clients[message.senderID];
}
else
{
udpUser = new User(message.senderID);
udpUser.udpConnection = new UdpConnection(iPEndPoint);
ServerHandler.udpConnections.Add(iPEndPoint, udpUser.udpConnection);
ServerHandler.AddConnection(udpUser);
Matchmaking.DefaultRoom.instance.JoinToRoom(udpUser);
ServerHandler.OnUserConnectedUDP(udpUser);
if (udpUser.info == null)
{
udpUser.info = ServerHandler.DataBaseBehaivour.GetUserData(message.senderID);
}
if (udpUser.info == null)
{
udpUser.info = ServerHandler.DataBaseBehaivour.CreateUser(message.senderID);
}
}
SynchronizableTypes.InvokeTypeActionUDP(type, bytes, message, ServerHandler.clients[message.senderID]);
}
}
else
{
ServerHandler.udpConnections[iPEndPoint].user.currentRoom.BroadcastMessageUDP(bytes);
}
}
}
}
public static void Init()
{
defaultRoom = new DefaultRoom("defaultRoomType");
matchmakingRooms.Add("defaultRoomType", new List <Room>(1));
matchmakingRooms["defaultRoomType"].Add(defaultRoom);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.CreateLobby),
(object data, string id) =>
{
MatchmakingServerCall.CreateLobby createRoom = data as MatchmakingServerCall.CreateLobby;
CreateLobby(ServerHandler.clients[id], createRoom.name, createRoom.roomFactors);
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.GetLobbysList),
(object data, string id) =>
{
ServerHandler.clients[id].tcpConnection.SendMessage(new NetData(new MatchmakingServerCall.OnGetLobbysListCallback(GetLobbyList()), false));
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.JoinToMatch),
(object data, string id) =>
{
MatchmakingServerCall.JoinToMatch joinToMatch = data as MatchmakingServerCall.JoinToMatch;
JoinToMatch(ServerHandler.clients[id], joinToMatch.roomFactors);
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.JoinToLobby),
(object data, string id) =>
{
MatchmakingServerCall.JoinToLobby joinToLobby = data as MatchmakingServerCall.JoinToLobby;
if (rooms.ContainsKey(joinToLobby.id))
{
rooms[joinToLobby.id].JoinToRoom(ServerHandler.clients[id]);
}
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.StartLobby),
(object data, string id) =>
{
if (ServerHandler.clients[id].currentRoom is Lobby)
{
ServerHandler.clients[id].currentRoom.StartRoom();
}
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.DestroyLobby),
(object data, string id) =>
{
if (ServerHandler.clients[id].currentRoom is Lobby)
{
ServerHandler.clients[id].currentRoom.DestroyRoom();
}
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.LeaveFromRoom),
(object data, string id) =>
{
ServerHandler.clients[id].currentRoom.LeaveFromRoom(ServerHandler.clients[id]);
}
);
SynchronizableTypes.AddType(typeof(MatchmakingServerCall.ReleaseRoom),
(object data, string id) =>
{
ServerHandler.clients[id].currentRoom.ReleaseRoom();
}
);
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnMatchReadyCallback));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnPlayerLeaveCallback));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnJoinedToRoomCallback));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnGetLobbysListCallback));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnRoomRealeasedCallback));
SynchronizableTypes.AddSyncSubType(typeof(MatchmakingServerCall.OnLobbyDestoyedCallback));
}
