public SettingGeneralPaneVM()
{
Name = "General";
_options = new MBBindingList <GenericOptionDataVM>();
_settings = PartyScreenConfig.ExtraSettings;
AddSettingVms();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.AddHttpClient();
services.Configure <ConfigurationServiceSettings>(Configuration.GetSection("ConfigurationService"));
services.Configure <DpcApiSettings>(Configuration.GetSection("DPCApi"));
services.Configure <ExtraSettings>(Configuration.GetSection("Extra"));
services.Configure <PdfTemplateSelectorSettings>(Configuration.GetSection("PdfTemplateSelector"));
services.Configure <NodeServerSettings>(Configuration.GetSection("NodeServer"));
services.Configure <PdfStaticFilesSettings>(Configuration.GetSection("PdfStaticFiles"));
services.Configure <PdfSettings>(Configuration.GetSection("PdfPageSettings"));
services.Configure <CacheSettings>(Configuration.GetSection("CacheSettings"));
var props = new ExtraSettings();
Configuration.Bind("Extra", props);
services.AddSingleton <ICacheProvider, VersionedCacheCoreProvider>();
services.AddTransient <IConfigurationServiceClient, ConfigurationServiceClient>();
services.AddTransient <IPdfGenerationSettingsProvider, PdfGenerationSettingsProvider>();
services.AddTransient <IDpcDbClient, DpcDbClient>();
services.AddTransient <IDpcApiClient, DpcApiClient>();
services.AddTransient <IPdfTemplateSelector, PdfTemplateSelector>();
services.AddTransient <IHtmlGenerator, HtmlGenerator>();
services.AddTransient <IProductJsonMapper, ProductJsonMapper>();
services.AddTransient <IRegionTagsReplacer, RegionTagsReplacer>();
services.AddWkhtmltopdf();
services.AddMemoryCache();
services.AddSwaggerGen();
services.AddControllers().ConfigureApplicationPartManager(apm =>
{
apm.ApplicationParts.Clear();
apm.ApplicationParts.Add(new AssemblyPart(typeof(Startup).Assembly));
if (CurrentEnvironment.IsDevelopment())
{
apm.ApplicationParts.Add(new AssemblyPart(typeof(ConfigurationController).Assembly));
}
foreach (var library in props.Libraries)
{
var assembly = Assembly.LoadFile(Path.Combine(
AppDomain.CurrentDomain.BaseDirectory ?? string.Empty, library + ".dll"
));
apm.ApplicationParts.Add(new AssemblyPart(assembly));
var t = assembly.GetType($"{library}.Startup");
if (t != null)
{
var m = t.GetMethod("ConfigureServices");
if (m != null)
{
m.Invoke(null, new object[] { services, Configuration });
}
}
}
});
}
public SerializationSettings Clone()
{
return(new SerializationSettings
{
ignoredMembers = ignoredMembers.Clone(),
ignoreEmptyCollections = ignoreEmptyCollections,
ExtraSettings = ExtraSettings.Clone(),
ignoreFalse = ignoreFalse,
ignoreMembersThatThrow = ignoreMembersThatThrow.Clone(),
ignoreMembersWithType = ignoreMembersWithType.Clone(),
ignoredInstances = ignoredInstances.Clone(),
scrubDateTimes = scrubDateTimes,
scrubGuids = scrubGuids
});
}
public void AddServer <TStartup>(string serviceName) where TStartup : class
{
if (string.IsNullOrEmpty(nameof(serviceName)))
{
throw new ArgumentNullException(nameof(serviceName));
}
var port = PortManager.GetAvailablePort();
Ports.Add(port);
var serviceHost = GetWebHost <TStartup>(port);
Servers.Add(serviceName, serviceHost);
ExtraSettings.Add($"Services:{serviceName}:Endpoint", $"http://localhost:{port}");
}
public void Execute(GameClients.GameClient Session, Rooms.Room Room, string[] Params)
{
if (Params.Length == 1)
{
StringBuilder List = new StringBuilder();
List.Append("- LISTA DE COMANDOS STAFF -\n\n");
List.Append(":update catalogue - Atualiza o catalogo.\n········································································\n");
List.Append(":update items - Atualiza os items.\n········································································\n");
List.Append(":update jukebox - Atualiza as musicas.\n········································································\n");
List.Append(":update wordfilter - Atualiza o filtro do hotel.\n········································································\n");
List.Append(":update models - Atualiza o filtro del hotel.\n········································································\n");
List.Append(":update promotions - Atualiza as promoções.\n········································································\n");
List.Append(":update halloffame - Atualiza pontos de fama.\n········································································\n");
List.Append(":update youtube - Atualiza os videos TV's.\n········································································\n");
List.Append(":update permissions - Atualiza as permissões de rank.\n········································································\n");
List.Append(":update settings - Atualiza las configurações do hotel.\n········································································\n");
List.Append(":update bans - Atualiza os banidos do hotel.\n········································································\n");
List.Append(":update quests - Atualiza os Quests do hotel.\n········································································\n");
List.Append(":update achievements - Atualiza is logs de usuarios.\n········································································\n");
List.Append(":update bots - Atualiza os bots do hotel.\n········································································\n");
List.Append(":update achievements - Atualiza os logros de usuarios.\n········································································\n");
Session.SendMessage(new MOTDNotificationComposer(List.ToString()));
return;
}
string UpdateVariable = Params[1];
switch (UpdateVariable.ToLower())
{
case "cata":
case "catalog":
case "catalogue":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_catalog"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_catalog' permiso", "advice");
break;
}
CloudServer.GetGame().GetCatalog().Init(CloudServer.GetGame().GetItemManager());
CloudServer.GetGame().GetClientManager().SendMessage(new CatalogUpdatedComposer());
Session.LogsNotif("Catalogo actualizado correctamente", "catalogue");
break;
case "discos":
case "songs":
case "jukebox":
case "canciones":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_songsdata"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_songsdata", "advice");
break;
}
int count = TraxSoundManager.Songs.Count;
TraxSoundManager.Init();
Session.LogsNotif("Música recarregadas com sucesso, diferença de comprimento: " + checked (count - TraxSoundManager.Songs.Count), "advice");
break;
case "wordfilter":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_filter"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_filter' permiso", "advice");
break;
}
CloudServer.GetGame().GetChatManager().GetFilter().InitWords();
CloudServer.GetGame().GetChatManager().GetFilter().InitCharacters();
Session.LogsNotif("Filtro atualizado corretamente", "advice");
break;
case "items":
case "furni":
case "furniture":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_furni"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_furni' permiso", "advice");
break;
}
CloudServer.GetGame().GetItemManager().Init();
Session.LogsNotif("Items acualizados corretamente", "advice");
break;
case "models":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_models"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_models' permiso", "advice");
break;
}
CloudServer.GetGame().GetRoomManager().LoadModels();
Session.LogsNotif("Salas atualizadas corretamente.", "advice");
break;
case "promotions":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_promotions"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_promotions' permiso.", "advice");
break;
}
CloudServer.GetGame().GetLandingManager().LoadPromotions();
Session.LogsNotif("Promoçoes atualizadas corretamente.", "advice");
break;
case "halloffame":
case "salondelafama":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_halloffame"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_halloffame' permiso.", "advice");
break;
}
GetHallOfFame.GetInstance().Load();
Session.LogsNotif("Hall of Fame atualizado com sucesso.", "advice");
break;
case "youtube":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_youtube"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_youtube' permiso.", "advice");
break;
}
CloudServer.GetGame().GetTelevisionManager().Init();
Session.LogsNotif("TV's atualizados.", "advice");
break;
case "navigator":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_navigator"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_navigator'.", "advice");
break;
}
CloudServer.GetGame().GetNavigator().Init();
Session.LogsNotif("Navegador de salas atualizado.", "advice");
break;
case "ranks":
case "rights":
case "permissions":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_rights"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_rights'.", "advice");
break;
}
CloudServer.GetGame().GetPermissionManager().Init();
foreach (GameClient Client in CloudServer.GetGame().GetClientManager().GetClients.ToList())
{
if (Client == null || Client.GetHabbo() == null || Client.GetHabbo().GetPermissions() == null)
{
continue;
}
Client.GetHabbo().GetPermissions().Init(Client.GetHabbo());
}
Session.LogsNotif("Permissoes atualizadas.", "advice");
break;
case "pinatas":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_catalog"))
{
Session.SendWhisper("Oops, Você não tem permissão para atualizar prêmios pinatas.");
break;
}
CloudServer.GetGame().GetPinataManager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
CloudServer.GetGame().GetClientManager().SendMessage(RoomNotificationComposer.SendBubble("catalogue", "Premios Actualizados", ""));
break;
case "crafting":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_furni"))
{
Session.SendWhisper("Oops, Você não tem permissão para atualizar .");
break;
}
CloudServer.GetGame().GetCraftingManager().Init();
Session.SendWhisper("Crafting actualizado correctamente.");
break;
case "crackable":
case "ecotron":
case "pinata":
case "piñata":
CloudServer.GetGame().GetPinataManager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
CloudServer.GetGame().GetFurniMaticRewardsMnager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
CloudServer.GetGame().GetTargetedOffersManager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
break;
case "relampago":
case "targeted":
case "targetedoffers":
CloudServer.GetGame().GetTargetedOffersManager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
break;
case "config":
case "settings":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_configuration"))
{
Session.LogsNotif("Ups,Você não tem permissão 'command_update_configuration'.", "advice");;
break;
}
CloudServer.GetGame().GetSettingsManager().Init();
ExtraSettings.RunExtraSettings();
CatalogSettings.RunCatalogSettings();
NotificationSettings.RunNotiSettings();
CloudServer.GetGame().GetTargetedOffersManager().Initialize(CloudServer.GetDatabaseManager().GetQueryReactor());
Session.LogsNotif("Configuraçoes atualizadas.", "advice");
break;
case "bans":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_bans"))
{
Session.LogsNotif("Ups, Você não tem'command_update_bans' permiso.", "advice");
break;
}
CloudServer.GetGame().GetModerationManager().ReCacheBans();
Session.LogsNotif("Cache Ban re-cargado.", "advice");
break;
case "quests":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_quests"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_quests' permiso.", "advice");
break;
}
CloudServer.GetGame().GetQuestManager().Init();
Session.LogsNotif("Quests atualizadas.", "advice");
break;
case "achievements":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_achievements"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_achievements' permiso.", "advice");
break;
}
CloudServer.GetGame().GetAchievementManager().LoadAchievements();
Session.LogsNotif("Achievements atualizados.", "advice");
break;
case "moderation":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_moderation"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_moderation' permiso.", "advice");;
break;
}
CloudServer.GetGame().GetModerationManager().Init();
CloudServer.GetGame().GetClientManager().ModAlert("Presets de moderación se han actualizado.Por favor, vuelva a cargar el cliente para ver los nuevos presets.");
Session.LogsNotif("Configurações dos moderadores atualizadas.", "advice");
break;
case "vouchers":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_vouchers"))
{
Session.LogsNotif("Ups, Você não tem permissão'command_update_vouchers.", "advice");
break;
}
CloudServer.GetGame().GetCatalog().GetVoucherManager().Init();
Session.LogsNotif("O catálogo cache atualizado.", "advice");
break;
case "gc":
case "games":
case "gamecenter":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_game_center"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_game_center'.", "advice");
break;
}
CloudServer.GetGame().GetGameDataManager().Init();
Session.LogsNotif("Cache Game Center foi atualizado com sucesso.", "advice");
break;
case "pet_locale":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_pet_locale"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_pet_locale'.", "advice");
break;
}
CloudServer.GetGame().GetChatManager().GetPetLocale().Init();
CloudServer.GetGame().GetChatManager().GetPetCommands().Init();
Session.LogsNotif("Cache local Animais atualizado.", "advice");
break;
case "locale":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_locale"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_locale'.", "advice");
break;
}
CloudServer.GetGame().GetLanguageManager().Init();
Session.LogsNotif("Locale caché acualizado corretamente.", "advice");
break;
case "mutant":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_anti_mutant"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_anti_mutant'.", "advice");
break;
}
CloudServer.GetGame().GetFigureManager().Init();
Session.LogsNotif("FigureData manager recarregado com sucesso!", "advice");
break;
case "bots":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_bots"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_bots'.", "advice");
break;
}
CloudServer.GetGame().GetBotManager().Init();
Session.LogsNotif("Bots actualizados.", "advice");
break;
case "rewards":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_rewards"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_rewards'.", "advice");
break;
}
CloudServer.GetGame().GetRewardManager().Reload();
Session.LogsNotif("Gestor De Recompensas voltou a carregar com sucesso!", "advice");
break;
case "chat_styles":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_chat_styles"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_chat_styles'.", "advice");
break;
}
CloudServer.GetGame().GetChatManager().GetChatStyles().Init();
Session.LogsNotif("estilos de chat recarregado com sucesso!", "advice");
break;
case "definitions":
case "badge_definitions":
if (!Session.GetHabbo().GetPermissions().HasCommand("command_update_badge_definitions"))
{
Session.LogsNotif("Ups, Você não tem permissão 'command_update_badge_definitions'.", "advice");
break;
}
CloudServer.GetGame().GetBadgeManager().Init();
Session.LogsNotif("Definições placas recarregado com sucesso!", "advice");
break;
default:
Session.LogsNotif("'" + UpdateVariable + "' não é uma coisa válida para recarregar.", "advice");
break;
}
}
public void AddExtraSettings(Action <JsonSerializerSettings> action)
{
Guard.AgainstNull(action, nameof(action));
ExtraSettings.Add(action);
}
// Projeto prisma lindo
public Game()
{
Console.WriteLine();
log.Info("» Iniciando BIOS EMULADOR Para " + BiosEmuThiago.HotelName + "");
Console.WriteLine();
SessionUserRecord = 0;
// Run Extra Settings
// BotFrankConfig.RunBotFrank();
ExtraSettings.RunExtraSettings();
// Run Catalog Settings
CatalogSettings.RunCatalogSettings();
// Run Notification Settings
NotificationSettings.RunNotiSettings();
_languageManager = new LanguageManager();
_languageManager.Init();
_settingsManager = new SettingsManager();
_settingsManager.Init();
_packetManager = new PacketManager();
_clientManager = new GameClientManager();
_moderationManager = new ModerationManager();
_moderationManager.Init();
_itemDataManager = new ItemDataManager();
_itemDataManager.Init();
_catalogManager = new CatalogManager();
_catalogManager.Init(_itemDataManager);
_craftingManager = new CraftingManager();
_craftingManager.Init();
_televisionManager = new TelevisionManager();
_navigatorManager = new NavigatorManager();
_roomManager = new RoomManager();
_chatManager = new ChatManager();
_groupManager = new GroupManager();
_groupManager.Init();
_groupForumManager = new GroupForumManager();
_questManager = new QuestManager();
_achievementManager = new AchievementManager();
_talentManager = new TalentManager();
_talentManager.Initialize();
_talentTrackManager = new TalentTrackManager();
_landingViewManager = new LandingViewManager();
_gameDataManager = new GameDataManager();
_botManager = new BotManager();
_cacheManager = new CacheManager();
_rewardManager = new RewardManager();
_badgeManager = new BadgeManager();
_badgeManager.Init();
// GetHallOfFame.GetInstance().Load();
_permissionManager = new PermissionManager();
_permissionManager.Init();
_subscriptionManager = new SubscriptionManager();
_subscriptionManager.Init();
TraxSoundManager.Init();
HabboCameraManager.Init();
HelperToolsManager.Init();
_figureManager = new FigureDataManager(BiosEmuThiago.GetConfig().data["game.legacy.figure_mutant"].ToString() == "1");
_figureManager.Init();
_crackableManager = new CrackableManager();
_crackableManager.Initialize(BiosEmuThiago.GetDatabaseManager().GetQueryReactor());
_furniMaticRewardsManager = new FurniMaticRewardsManager();
_furniMaticRewardsManager.Initialize(BiosEmuThiago.GetDatabaseManager().GetQueryReactor());
_targetedoffersManager = new TargetedOffersManager();
_targetedoffersManager.Initialize(BiosEmuThiago.GetDatabaseManager().GetQueryReactor());
}
public new void OnFinalize()
{
_options = null;
_settings = null;
}
/// <summary>
/// Main Void, Initializes the Emulator.
/// </summary>
internal static void Initialize()
{
#region Precheck
Console.Title = "CityRP está iniciando..";
ServerStarted = DateTime.Now;
_defaultEncoding = Encoding.Default;
#endregion Precheck
#region Database Connection
CultureInfo = CultureInfo.CreateSpecificCulture("en-GB");
try
{
ConfigurationData.Load(Path.Combine(Application.StartupPath, "Settings/main.ini"), false);
RoleplayData.Load(Path.Combine(Application.StartupPath, "Settings/Roleplay/settings.ini"), true);
DatabaseConnectionType = ConfigurationData.Data["db.type"];
var mySqlConnectionStringBuilder = new MySqlConnectionStringBuilder
{
Server = (ConfigurationData.Data["db.hostname"]),
Port = (uint.Parse(ConfigurationData.Data["db.port"])),
UserID = (ConfigurationData.Data["db.username"]),
Password = (ConfigurationData.Data["db.password"]),
Database = (ConfigurationData.Data["db.name"]),
MinimumPoolSize = (uint.Parse(ConfigurationData.Data["db.pool.minsize"])),
MaximumPoolSize = (uint.Parse(ConfigurationData.Data["db.pool.maxsize"])),
Pooling = (true),
AllowZeroDateTime = (true),
ConvertZeroDateTime = (true),
DefaultCommandTimeout = (300),
ConnectionTimeout = (10)
};
var mySqlConnectionStringBuilder2 = mySqlConnectionStringBuilder;
Manager = new DatabaseManager(mySqlConnectionStringBuilder2.ToString(), DatabaseConnectionType);
using (var queryReactor = GetDatabaseManager().GetQueryReactor())
{
ConfigData = new ConfigData(queryReactor);
PetCommandHandler.Init(queryReactor);
PetLocale.Init(queryReactor);
OfflineMessages = new Dictionary <uint, List <OfflineMessage> >();
OfflineMessage.InitOfflineMessages(queryReactor);
}
#endregion Database Connection
#region Packets Registering
ConsoleTimer = (int.Parse(ConfigurationData.Data["console.clear.time"]));
ConsoleTimerOn = (bool.Parse(ConfigurationData.Data["console.clear.enabled"]));
FriendRequestLimit = ((uint)int.Parse(ConfigurationData.Data["client.maxrequests"]));
LibraryParser.Incoming = new Dictionary <int, LibraryParser.StaticRequestHandler>();
LibraryParser.Library = new Dictionary <string, string>();
LibraryParser.Outgoing = new Dictionary <string, int>();
LibraryParser.Config = new Dictionary <string, string>();
LibraryParser.RegisterLibrary();
LibraryParser.RegisterOutgoing();
LibraryParser.RegisterIncoming();
LibraryParser.RegisterConfig();
#endregion Packets Registering
#region Game Initalizer
ExtraSettings.RunExtraSettings();
CrossDomainPolicy.Set();
_game = new Game(int.Parse(ConfigurationData.Data["game.tcp.conlimit"]));
_game.GetNavigator().LoadNewPublicRooms();
_game.ContinueLoading();
#endregion Game Initalizer
#region Languages Parser
ServerLanguage = (Convert.ToString(ConfigurationData.Data["system.lang"]));
_languages = new Languages(ServerLanguage);
#endregion Languages Parser
#region Environment SetUp
if (ConsoleTimerOn)
{
Out.WriteLine("Console Clear Timer is enable with " + ConsoleTimer + " seconds.");
}
_connectionManager = new ConnectionHandling(int.Parse(ConfigurationData.Data["game.tcp.port"]),
int.Parse(ConfigurationData.Data["game.tcp.conlimit"]),
int.Parse(ConfigurationData.Data["game.tcp.conperip"]),
ConfigurationData.Data["game.tcp.enablenagles"].ToLower() == "true");
if (LibraryParser.Config["Crypto.Enabled"] == "true")
{
Handler.Initialize(LibraryParser.Config["Crypto.RSA.N"], LibraryParser.Config["Crypto.RSA.D"], LibraryParser.Config["Crypto.RSA.E"]);
}
_connectionManager.init();
LibraryParser.Initialize();
#endregion Environment SetUp
#region Tasks and MusSystem
if (ConsoleTimerOn)
{
Timer = new Timer {
Interval = ConsoleTimer
};
Timer.Elapsed += TimerElapsed;
Timer.Start();
}
if (ConfigurationData.Data.ContainsKey("StaffAlert.MinRank"))
{
StaffAlertMinRank = uint.Parse(ConfigurationData.Data["StaffAlert.MinRank"]);
}
if (ConfigurationData.Data.ContainsKey("SeparatedTasksInMainLoops.enabled") &&
ConfigurationData.Data["SeparatedTasksInMainLoops.enabled"] == "true")
{
SeparatedTasksInMainLoops = true;
}
if (ConfigurationData.Data.ContainsKey("SeparatedTasksInGameClientManager.enabled") &&
ConfigurationData.Data["SeparatedTasksInGameClientManager.enabled"] == "true")
{
SeparatedTasksInGameClientManager = true;
}
if (ConfigurationData.Data.ContainsKey("Debug"))
{
if (ConfigurationData.Data["Debug"] == "true")
{
DebugMode = true;
}
}
TimeSpan TimeUsed = DateTime.Now - ServerStarted;
Out.WriteLine("CityRP >> Started (" + TimeUsed.Seconds + "s, " + TimeUsed.Milliseconds + "ms)", "", ConsoleColor.Green);
IsLive = true;
using (var queryReactor = GetDatabaseManager().GetQueryReactor())
{
queryReactor.RunFastQuery("UPDATE server_settings SET value = '1' WHERE variable = 'status'");
}
}
catch (Exception e)
{
Out.WriteLine("Error in main.ini: Configuration file is invalid" + Environment.NewLine + e.Message, "", ConsoleColor.Red);
Out.WriteLine("Please press Y to get more details or press other Key to Exit", "", ConsoleColor.Red);
var key = Console.ReadKey();
if (key.Key == ConsoleKey.Y)
{
Console.WriteLine();
Out.WriteLine(
Environment.NewLine + "[Message] Error Details: " + Environment.NewLine + e.StackTrace +
Environment.NewLine + e.InnerException + Environment.NewLine + e.TargetSite +
Environment.NewLine + "[Message ]Press Any Key To Exit", "", ConsoleColor.Red);
Console.ReadKey();
Environment.Exit(1);
}
else
{
Environment.Exit(1);
}
}
#endregion Tasks and MusSystem
}
internal static void Initialize()
{
Console.Clear();
CyberEnvironment.ServerStarted = DateTime.Now;
Console.SetWindowSize(120, 40);
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
Console.WriteLine(@" ____ _ _ ___ ____ ____ ____ _ _ _ _ _ ____ ___ ____ ____ ");
Console.WriteLine(@" | \_/ |__] |___ |__/ |___ |\/| | | | |__| | | | |__/ ");
Console.WriteLine(@" |___ | |__] |___ | \ |___ | | |__| |___ | | | |__| | \ ");
Console.WriteLine();
Console.WriteLine(" Cyber Emulator - Version: " + PrettyBuild);
Console.WriteLine(" based on Plus, developed by Kessiler Rodrigues.");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(" " + PrettyRelease);
Console.Title = "Cyber Emulator | Loading data [...]";
CyberEnvironment.DefaultEncoding = Encoding.Default;
Console.WriteLine("");
CyberEnvironment.cultureInfo = CultureInfo.CreateSpecificCulture("en-GB");
TextHandling.replaceDecimal();
try
{
CyberEnvironment.Configuration = new ConfigurationData(Path.Combine(Application.StartupPath, "config.ini"), false);
MySqlConnectionStringBuilder mySqlConnectionStringBuilder = new MySqlConnectionStringBuilder();
mySqlConnectionStringBuilder.Server = (CyberEnvironment.GetConfig().data["db.hostname"]);
mySqlConnectionStringBuilder.Port = (uint.Parse(CyberEnvironment.GetConfig().data["db.port"]));
mySqlConnectionStringBuilder.UserID = (CyberEnvironment.GetConfig().data["db.username"]);
mySqlConnectionStringBuilder.Password = (CyberEnvironment.GetConfig().data["db.password"]);
mySqlConnectionStringBuilder.Database = (CyberEnvironment.GetConfig().data["db.name"]);
mySqlConnectionStringBuilder.MinimumPoolSize = (uint.Parse(CyberEnvironment.GetConfig().data["db.pool.minsize"]));
mySqlConnectionStringBuilder.MaximumPoolSize = (uint.Parse(CyberEnvironment.GetConfig().data["db.pool.maxsize"]));
mySqlConnectionStringBuilder.Pooling = (true);
mySqlConnectionStringBuilder.AllowZeroDateTime = (true);
mySqlConnectionStringBuilder.ConvertZeroDateTime = (true);
mySqlConnectionStringBuilder.DefaultCommandTimeout = (300u);
mySqlConnectionStringBuilder.ConnectionTimeout = (10u);
CyberEnvironment.manager = new DatabaseManager(mySqlConnectionStringBuilder.ToString());
using (IQueryAdapter queryreactor = CyberEnvironment.GetDatabaseManager().getQueryReactor())
{
ConfigData = new ConfigData(queryreactor);
PetLocale.Init(queryreactor);
OfflineMessages = new Dictionary <uint, List <OfflineMessage> >();
OfflineMessage.InitOfflineMessages(queryreactor);
GiftWrappers = new GiftWrappers(queryreactor);
}
FriendRequestLimit = (uint)int.Parse(CyberEnvironment.GetConfig().data["client.maxrequests"]);
if (ExtraSettings.RunExtraSettings())
{
Logging.WriteLine("Loaded an extra settings file.");
}
Game = new Game(int.Parse(GetConfig().data["game.tcp.conlimit"]));
Game.start();
ConnectionManager = new ConnectionHandling(int.Parse(GetConfig().data["game.tcp.port"]), int.Parse(GetConfig().data["game.tcp.conlimit"]), int.Parse(GetConfig().data["game.tcp.conperip"]), GetConfig().data["game.tcp.enablenagles"].ToLower() == "true");
HabboCrypto.Initialize(new RsaKeyHolder());
CyberEnvironment.ConnectionManager.init();
CyberEnvironment.ConnectionManager.Start();
StaticClientMessageHandler.Initialize();
string[] allowedIps = GetConfig().data["mus.tcp.allowedaddr"].Split(';');
MusSystem = new MusSocket(GetConfig().data["mus.tcp.bindip"], int.Parse(GetConfig().data["mus.tcp.port"]), allowedIps, 0);
if (Configuration.data.ContainsKey("StaffAlert.MinRank"))
{
StaffAlertMinRank = uint.Parse(CyberEnvironment.GetConfig().data["StaffAlert.MinRank"]);
}
if (Configuration.data.ContainsKey("SeparatedTasksInMainLoops.enabled") && Configuration.data["SeparatedTasksInMainLoops.enabled"] == "true")
{
SeparatedTasksInMainLoops = true;
}
if (Configuration.data.ContainsKey("SeparatedTasksInGameClientManager.enabled") && Configuration.data["SeparatedTasksInGameClientManager.enabled"] == "true")
{
SeparatedTasksInGameClientManager = true;
}
Logging.WriteLine("Game was succesfully loaded.");
isLive = true;
}
catch (KeyNotFoundException ex)
{
Logging.WriteLine("Something is missing in your configuration", ConsoleColor.Red);
Logging.WriteLine(ex.ToString(), ConsoleColor.Yellow);
Logging.WriteLine("Please type a key to shut down ...", ConsoleColor.Gray);
Console.ReadKey(true);
CyberEnvironment.Destroy();
}
catch (InvalidOperationException ex1)
{
Logging.WriteLine("Something wrong happened: " + ex1.Message, ConsoleColor.Red);
Logging.WriteLine(ex1.ToString(), ConsoleColor.Yellow);
Logging.WriteLine("Please type a key to shut down...", ConsoleColor.Gray);
Console.ReadKey(true);
CyberEnvironment.Destroy();
}
catch (Exception ex2)
{
Logging.WriteLine("An exception got caught: " + ex2.Message, ConsoleColor.Red);
Logging.WriteLine("Type a key to know more about the error", ConsoleColor.Gray);
Console.ReadKey();
Logging.WriteLine(ex2.ToString(), ConsoleColor.Yellow);
Logging.WriteLine("Please type a ket to shut down...", ConsoleColor.Gray);
Console.ReadKey();
Environment.Exit(1);
}
}
