public static void HandleServerSelectionMessage(AuthClient client, ServerSelectionMessage message)
{
WorldServer serverById = Singleton <WorldServerManager> .Instance.GetServerById((int)message.serverId);
if (serverById == null)
{
ConnectionHandler.SendSelectServerRefusedMessage(client, serverById, ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_NO_REASON);
}
else
{
if (serverById.Status != ServerStatusEnum.ONLINE)
{
ConnectionHandler.SendSelectServerRefusedMessage(client, serverById, ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_DUE_TO_STATUS);
}
else
{
if (serverById.RequiredRole > client.Account.Role)
{
ConnectionHandler.SendSelectServerRefusedMessage(client, serverById, ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_ACCOUNT_RESTRICTED);
}
else
{
ConnectionHandler.SendSelectServerData(client, serverById);
}
}
}
}
public static void SelectedServer(ServerSelectionMessage message, AuthClient client)
{
string host = ConfigurationManager.Instance.IsCustomHost == true ? ConfigurationManager.Instance.RealHost : ConfigurationManager.Instance.Host;
var encrypted = AccountsProvider.EncryptTicket(ServersManager.TransfertToGame(client.Account), client.AesKey);
client.Send(new SelectedServerDataMessage((ushort)ConfigurationManager.Instance.ServerId, host, (ushort)ConfigurationManager.Instance.WorldPort, true, encrypted));
client.Disconnect();
}
public void ServerSelectionMessageFrame(AuthClient client, ServerSelectionMessage serverSelectionMessage)
{
List <uint> ports = new List <uint>();
ports.Add(6666);
client.SendPacket(new SelectedServerDataMessage(serverSelectionMessage.serverId, "127.0.0.1", ports, true, AuthenticationUtils.EncodeTicket(client.salt)));
client.Disconnect();
}
public static void HandleServerSelection(BigEndianReader reader, AuthClient client, AuthServer server)
{
ServerSelectionMessage message = new ServerSelectionMessage();
message.Unpack(reader);
client.Send(new SelectedServerDataMessage(1, "127.0.0.1", 442, true, client.Ticket));
client.Disconnect();
//client.Send(new SelectedServerRefusedMessage(message.serverId, (sbyte)ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_NO_REASON, (sbyte)ServerStatusEnum.NOJOIN));
//TODO HANDLE SERVER CONNECTION REQUEST FROM CLIENT
}
public void ServerSelectionMessage(Client client, ServerSelectionMessage serverSelectionMessage)
{
Container.Instance().Resolve <IAccountRepository>().Entities().AddOrUpdate(client.Account.Id, client.Account,
(i, account) =>
{
account.Ticket = Guid.NewGuid().ToString();
account.IsEdited = true;
return(account);
});
client.Send(new SelectedServerDataMessage(serverSelectionMessage.serverId, "localhost", 666, true, client.Account.Ticket, "http://localhost:666"));
}
public void ServerSelectionMessage(Client client, ServerSelectionMessage serverSelectionMessage)
{
//lock (obj)
Container.Instance().Resolve <IAccountRepository>().Entities().AddOrUpdate(client.Account.Id, client.Account,
(i, account) =>
{
account.Ticket = Guid.NewGuid().ToString();
account.IsEdited = true;
return(account);
});
//lock (obj)
Container.Instance().Resolve <AuthRepositoryPersistManager>().ForceSave();
WorldServer server = Container.Instance().Resolve <IWorldServerManager>().Servers().FirstOrDefault(x => x.Id == serverSelectionMessage.serverId);
if (server != null)
{
client.Send(new SelectedServerDataMessage(serverSelectionMessage.serverId, server.Address, server.Port, true, client.Account.Ticket, server.Access));
}
//client.Send(new SelectedServerDataMessage(serverSelectionMessage.serverId, "localhost", 666, true, client.Account.Ticket, "http://localhost:666"));
}
public static void HandleServerSelectionMessage(AuthClient client, ServerSelectionMessage message)
{
var world = WorldServerManager.Instance.GetServerById(message.serverId);
/* World not exist */
if (world == null)
{
SendSelectServerRefusedMessage(client, message.serverId,
ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_NO_REASON);
return;
}
/* Wrong state */
if (world.Status != ServerStatusEnum.ONLINE)
{
SendSelectServerRefusedMessage(client, world,
ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_DUE_TO_STATUS);
return;
}
/* not suscribe */
if (world.RequireSubscription && client.Account.SubscriptionEnd <= DateTime.Now)
{
SendSelectServerRefusedMessage(client, world,
ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_SUBSCRIBERS_ONLY);
return;
}
/* not the rights */
if (world.RequiredRole > client.UserGroup.Role && !client.UserGroup.AvailableServers.Contains(world.Id))
{
SendSelectServerRefusedMessage(client, world,
ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_ACCOUNT_RESTRICTED);
return;
}
/* Send client to the server */
SendSelectServerData(client, world);
}
public static void OnServerSelectionMessage(AuthClient client, ServerSelectionMessage message)
{
client.Write($"trying to connect to server id : {message.ServerId}");
}
public static void HandleServerSelectionMessage(Client client, ServerSelectionMessage message)
{
SendSelectedServerDataMessage(client, message.serverId);
}
public static void HandleServerSelection(ServerSelectionMessage message, AuthClient client)
{
lock (Locker)
client.ProcessServerSelection(ServerRecord.GetWorldServer(message.serverId));
}
private void HandleServerSelection(ServersListMessage message)
{
var selection = new ServerSelectionMessage((short)(message.servers.FirstOrDefault(server => server.charactersCount > 0 && server.isSelectable == true)).id);
client.Network.Send(selection);
}
private void HandleServerSelectionMessage(ServerSelectionMessage message, ConnectedHost source)
{
mServer = new Server();
mServer.Start(RemoteSetting.Default.GameListenPort);
mServer.ConnectionAccepted += Default_ConnectionAccepted;
}
