/// <summary>
/// Gets the achievement levels.
/// </summary>
/// <param name="achievements">The achievements.</param>
/// <param name="dbClient">The database client.</param>
internal static void GetAchievementLevels(out Dictionary <string, Achievement> achievements,
IQueryAdapter dbClient)
{
achievements = new Dictionary <string, Achievement>();
dbClient.SetQuery("SELECT * FROM achievements_data");
foreach (DataRow dataRow in dbClient.GetTable().Rows)
{
string achievementName = dataRow["achievement_name"].ToString();
AchievementLevel level = new AchievementLevel((uint)dataRow["achievement_level"], (uint)dataRow["reward_pixels"],
(uint)dataRow["reward_points"], (uint)dataRow["progress_needed"]);
if (!achievements.ContainsKey(achievementName))
{
achievements.Add(achievementName,
new Achievement((uint)dataRow["id"], achievementName,
dataRow["achievement_category"].ToString()));
}
if (!achievements[achievementName].CheckLevel(level))
{
achievements[achievementName].AddLevel(level);
}
else
{
YupiWriterManager.WriteLine(
"Was Found a Duplicated Level for: " + achievementName + ", Level: " + level.Level,
"Yupi.Achievements", ConsoleColor.Cyan);
}
}
}
/// <summary>
/// Checks the connection.
/// </summary>
/// <param name="sock">The sock.</param>
/// <param name="maxIpConnectionCount">The maximum ip connection count.</param>
/// <param name="antiDDosStatus">if set to <c>true</c> [anti d dos status].</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
internal static bool CheckConnection(Socket sock, int maxIpConnectionCount, bool antiDDosStatus)
{
if (!antiDDosStatus)
{
return(true);
}
string iP = sock.RemoteEndPoint.ToString().Split(':')[0];
if (iP == _mLastIpBlocked)
{
return(false);
}
if (GetConnectionAmount(iP) > maxIpConnectionCount)
{
YupiWriterManager.WriteLine(iP + " was banned by Anti-DDoS system.", "Yupi.Security", ConsoleColor.Blue);
_mLastIpBlocked = iP;
return(false);
}
int freeConnectionId = GetFreeConnectionId();
if (freeConnectionId < 0)
{
return(false);
}
_mConnectionStorage[freeConnectionId] = iP;
return(true);
}
/// <summary>
/// Loads the room.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="forceLoad"></param>
/// <returns>Room.</returns>
internal Room LoadRoom(uint id, bool forceLoad = false)
{
if (IsRoomLoaded(id))
{
return(GetRoom(id));
}
RoomData roomData = GenerateRoomData(id);
if (roomData == null)
{
return(null);
}
Room room = new Room();
LoadedRooms.AddOrUpdate(id, room, (key, value) => room);
room.Start(roomData, forceLoad);
YupiWriterManager.WriteLine($"Room #{id} was loaded", "Yupi.Rooms", ConsoleColor.DarkCyan);
room.InitBots();
room.InitPets();
return(room);
}
/// <summary>
/// Closes all.
/// </summary>
internal void CloseAll()
{
YupiWriterManager.WriteLine("Saving Inventary Content....", "Yupi.Boot", ConsoleColor.DarkCyan);
foreach (GameClient current2 in Clients.Values.Where(current2 => current2.GetHabbo() != null))
{
current2.GetHabbo().GetInventoryComponent().RunDbUpdate();
current2.GetHabbo().RunDbUpdate();
}
YupiWriterManager.WriteLine("Inventary Content Saved!", "Yupi.Boot", ConsoleColor.DarkCyan);
try
{
YupiWriterManager.WriteLine("Closing Connection YupiDatabaseManager...", "Yupi.Boot", ConsoleColor.DarkMagenta);
foreach (GameClient current3 in Clients.Values.Where(current3 => current3.GetConnection() != null))
{
current3.GetConnection().Dispose();
Console.ForegroundColor = ConsoleColor.DarkMagenta;
YupiWriterManager.WriteLine("Connection YupiDatabaseManager Closed!", "Yupi.Boot", ConsoleColor.DarkMagenta);
}
}
catch (Exception ex)
{
YupiLogManager.LogCriticalException(ex, "Failed Closing Connection YupiDatabaseManager.");
}
Clients.Clear();
YupiWriterManager.WriteLine("Connections closed", "Yupi.Conn", ConsoleColor.DarkYellow);
}
/// <summary>
/// Destroys this instance.
/// </summary>
internal void Destroy()
{
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
DatabaseCleanup(queryReactor);
GetClientManager();
YupiWriterManager.WriteLine("Database YupiDatabaseManager destroyed", "Yupi.Game", ConsoleColor.DarkYellow);
}
/// <summary>
/// Gets the variable.
/// </summary>
/// <param name="var">The variable.</param>
/// <returns>System.String.</returns>
internal string GetVar(string var)
{
if (Texts.Contains(var))
{
return(Texts[var].ToString());
}
YupiWriterManager.WriteLine("Variable not found: " + var, "Yupi.Languages");
return("Language variable not Found: " + var);
}
/// <summary>
/// Console Clear Thread
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="ElapsedEventArgs" /> instance containing the event data.</param>
internal static void ConsoleRefreshTimerElapsed(object sender, ElapsedEventArgs e)
{
Console.Clear();
Console.WriteLine();
YupiWriterManager.WriteLine($"Console Cleared in: {DateTime.Now} Next Time on: {ConsoleCleanTimeInterval} Seconds ", "Yupi.Boot", ConsoleColor.DarkGreen);
Console.WriteLine();
GC.Collect();
ConsoleRefreshTimer.Start();
}
/// <summary>
/// Removes all rooms.
/// </summary>
internal void RemoveAllRooms()
{
lock (LoadedRooms)
{
foreach (Room current in LoadedRooms.Values)
{
Yupi.GetGame().GetRoomManager().UnloadRoom(current, "RemoveAllRooms void called");
}
}
YupiWriterManager.WriteLine("RoomManager Destroyed", "Yupi.Rooms", ConsoleColor.DarkYellow);
}
/// <summary>
/// Shutdown the Emulator
/// </summary>
/// <param name="restart">if set to <c>true</c> [restart].</param>
/// Set a Different Message in Hotel
internal static void PerformShutDown(bool restart)
{
DateTime now = DateTime.Now;
CacheManager.StopProcess();
ShutdownStarted = true;
Console.Title = "Yupi Emulator | Shutting down...";
GetGame().StopGameLoop();
GetGame().GetRoomManager().RemoveAllRooms();
GetGame().GetClientManager().CloseAll();
GetConnectionManager().Destroy();
foreach (Group group in GetGame().GetGroupManager().Groups.Values)
{
group.UpdateForum();
}
using (IQueryAdapter queryReactor = YupiDatabaseManager.GetQueryReactor())
{
queryReactor.RunFastQuery("UPDATE users SET online = '0'");
queryReactor.RunFastQuery("UPDATE rooms_data SET users_now = 0");
queryReactor.RunFastQuery("TRUNCATE TABLE users_rooms_visits");
}
GetConnectionManager().Destroy();
GetGame().Destroy();
YupiLogManager.Stop();
YupiWriterManager.WriteLine(" destroyed", "Yupi.Game", ConsoleColor.DarkYellow);
TimeSpan span = DateTime.Now - now;
YupiWriterManager.WriteLine("Elapsed " + TimeSpanToString(span) + "ms on Shutdown Proccess", "Yupi.Life", ConsoleColor.DarkYellow);
IsLive = false;
if (restart)
{
Process.Start(Assembly.GetEntryAssembly().Location);
}
Console.WriteLine("Closing...");
Environment.Exit(0);
}
public static int OutgoingRequest(string packetName)
{
int packetId;
if (Outgoing.TryGetValue(packetName, out packetId))
{
return(packetId);
}
YupiWriterManager.WriteLine("Outgoing " + packetName + " doesn't exist.", "Yupi.Communication", ConsoleColor.Gray);
return(-1);
}
/// <summary>
/// Loads the rights.
/// </summary>
/// <param name="dbClient">The database client.</param>
internal void LoadRights(IQueryAdapter dbClient)
{
ClearRights();
dbClient.SetQuery("SELECT * FROM server_fuses;");
DataTable table = dbClient.GetTable();
if (table == null)
{
return;
}
foreach (DataRow dataRow in table.Rows)
{
if (!_cmdRights.ContainsKey(dataRow["command"].ToString()))
{
_cmdRights.Add(dataRow["command"].ToString(), dataRow["rank"].ToString());
}
else
{
YupiWriterManager.WriteLine($"Duplicate Fuse Command \"{dataRow[0]}\" found", "Yupi.Fuses");
}
}
dbClient.SetQuery("SELECT * FROM server_fuserights");
DataTable table2 = dbClient.GetTable();
if (table2 == null)
{
return;
}
foreach (DataRow dataRow2 in table2.Rows)
{
if ((int)dataRow2["min_sub"] > 0)
{
_subRights.Add(dataRow2["fuse"].ToString(), (int)dataRow2["min_sub"]);
}
else if (!_rights.ContainsKey(dataRow2["fuse"].ToString()))
{
_rights.Add(dataRow2["fuse"].ToString(), (uint)dataRow2["min_rank"]);
}
}
}
/// <summary>
/// Loads this instance.
/// </summary>
public static void Load()
{
foreach (
string line in
File.ReadAllLines($"{Yupi.YupiVariablesDirectory}\\Settings\\filter.ini", Encoding.Default)
.Where(line => !line.StartsWith("#") || !line.StartsWith("//") || line.Contains("=")))
{
string[] array = line.Split('=');
string mode = array[0];
string jsonStr = string.Join("=", array.Skip(1));
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic items = serializer.Deserialize <object[]>(jsonStr);
Dictionary <string, string> dic = new Dictionary <string, string>();
foreach (object[] item in items)
{
string key = item[0].ToString();
string value = string.Empty;
if (item.Length > 1)
{
value = item[1].ToString();
}
dic.Add(key, value);
}
if (dic.ContainsKey(mode))
{
continue;
}
if (Default == null)
{
Default = mode;
}
Dictionary.Add(mode, dic);
}
YupiWriterManager.WriteLine("Loaded " + Dictionary.Count + " filter modes.", "Yupi.Security");
}
/// <summary>
/// Initializes the swear word.
/// </summary>
internal static void Load()
{
Word = new List <string>();
Word.Clear();
using (IQueryAdapter adapter = Yupi.GetDatabaseManager().GetQueryReactor())
{
adapter.SetQuery("SELECT `word` FROM wordfilter");
DataTable table = adapter.GetTable();
if (table == null)
{
return;
}
foreach (DataRow row in table.Rows)
{
Word.Add(row[0].ToString().ToLower());
}
}
YupiWriterManager.WriteLine("Loaded " + Word.Count + " Bobba Filters", "Yupi.Security");
}
/// <summary>
/// Loads this instance.
/// </summary>
public static void Load()
{
using (IQueryAdapter adapter = Yupi.GetDatabaseManager().GetQueryReactor())
{
adapter.SetQuery("SELECT * FROM server_blackwords");
DataTable table = adapter.GetTable();
if (table == null)
{
return;
}
foreach (DataRow row in table.Rows)
{
string word = row["word"].ToString();
string typeStr = row["type"].ToString();
AddPrivateBlackWord(typeStr, word);
}
}
YupiWriterManager.WriteLine("Loaded " + Words.Count + " BlackWords", "Yupi.Security");
//Console.WriteLine();
}
/// <summary>
/// Unloads the room.
/// </summary>
/// <param name="room">The room.</param>
/// <param name="reason">The reason.</param>
internal void UnloadRoom(Room room, string reason)
{
if (room?.RoomData == null || room.Disposed)
{
return;
}
room.Disposed = true;
if (Yupi.GetGame().GetNavigator().PrivateCategories.Contains(room.RoomData.Category))
{
((PublicCategory)Yupi.GetGame().GetNavigator().PrivateCategories[room.RoomData.Category]).UsersNow -=
room.UserCount;
}
room.RoomData.UsersNow = 0;
string state = "open";
if (room.RoomData.State == 1)
{
state = "locked";
}
else if (room.RoomData.State > 1)
{
state = "password";
}
uint roomId = room.RoomId;
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
queryReactor.SetQuery("UPDATE rooms_data SET " +
"caption = @roomcaption," +
"description = @description," +
"password = @password," +
"category = @category," +
"state = @state," +
"tags = @tags," +
"users_now = @usersnow," +
"users_max = @usersmax," +
"allow_pets = @allowpets," +
"allow_pets_eat = @allowpetseat," +
"allow_walkthrough = @allowwalk," +
"hidewall = @hidewall," +
"floorthick = @floorthick," +
"wallthick = @wallthick," +
"mute_settings = @whocanmute," +
"kick_settings = @kicksettings," +
"ban_settings = @bansettings," +
"walls_height = @wallheight," +
"chat_type = @chat_t," +
"chat_balloon = @chat_b," +
"chat_speed = @chat_s," +
"chat_max_distance = @chat_m," +
"chat_flood_protection = @chat_f," +
"trade_state = @tradestate " +
"WHERE id = " + roomId);
queryReactor.AddParameter("usersnow", room.RoomData.UsersNow);
queryReactor.AddParameter("roomcaption", room.RoomData.Name);
queryReactor.AddParameter("usersmax", room.RoomData.UsersMax);
queryReactor.AddParameter("allowpets", Yupi.BoolToEnum(room.RoomData.AllowPets));
queryReactor.AddParameter("allowpetseat", Yupi.BoolToEnum(room.RoomData.AllowPetsEating));
queryReactor.AddParameter("allowwalk", Yupi.BoolToEnum(room.RoomData.AllowWalkThrough));
queryReactor.AddParameter("hidewall", Yupi.BoolToEnum(room.RoomData.HideWall));
queryReactor.AddParameter("floorthick", room.RoomData.FloorThickness);
queryReactor.AddParameter("wallthick", room.RoomData.WallThickness);
queryReactor.AddParameter("whocanmute", room.RoomData.WhoCanMute);
queryReactor.AddParameter("kicksettings", room.RoomData.WhoCanKick);
queryReactor.AddParameter("bansettings", room.RoomData.WhoCanBan);
queryReactor.AddParameter("wallheight", room.RoomData.WallHeight);
queryReactor.AddParameter("tradestate", room.RoomData.TradeState);
queryReactor.AddParameter("category", room.RoomData.Category);
queryReactor.AddParameter("state", state);
queryReactor.AddParameter("description", room.RoomData.Description);
queryReactor.AddParameter("password", room.RoomData.PassWord);
queryReactor.AddParameter("tags", string.Join(",", room.RoomData.Tags));
queryReactor.AddParameter("chat_t", room.RoomData.ChatType);
queryReactor.AddParameter("chat_b", room.RoomData.ChatBalloon);
queryReactor.AddParameter("chat_s", room.RoomData.ChatSpeed);
queryReactor.AddParameter("chat_m", room.RoomData.ChatMaxDistance);
queryReactor.AddParameter("chat_f", room.RoomData.ChatFloodProtection);
queryReactor.RunQuery();
}
if (room.GetRoomUserManager() != null && room.GetRoomUserManager().UserList != null)
{
foreach (RoomUser current in room.GetRoomUserManager().UserList.Values.Where(current => current != null))
{
if (current.IsPet)
{
if (current.PetData == null)
{
continue;
}
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
queryReactor.SetQuery("UPDATE pets_data SET x=@x, y=@y, z=@z WHERE id=@id LIMIT 1");
queryReactor.AddParameter("x", current.X);
queryReactor.AddParameter("y", current.Y);
queryReactor.AddParameter("z", current.Z);
queryReactor.AddParameter("id", current.PetData.PetId);
queryReactor.RunQuery();
}
if (current.BotAi == null)
{
continue;
}
current.BotAi.Dispose();
}
else if (current.IsBot)
{
if (current.BotData == null)
{
continue;
}
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
queryReactor.SetQuery(
"UPDATE bots_data SET x=@x, y=@y, z=@z, name=@name, motto=@motto, look=@look, rotation=@rotation, dance=@dance WHERE id=@id LIMIT 1");
queryReactor.AddParameter("name", current.BotData.Name);
queryReactor.AddParameter("motto", current.BotData.Motto);
queryReactor.AddParameter("look", current.BotData.Look);
queryReactor.AddParameter("rotation", current.BotData.Rot);
queryReactor.AddParameter("dance", current.BotData.DanceId);
queryReactor.AddParameter("x", current.X);
queryReactor.AddParameter("y", current.Y);
queryReactor.AddParameter("z", current.Z);
queryReactor.AddParameter("id", current.BotData.BotId);
queryReactor.RunQuery();
}
current.BotAi?.Dispose();
}
else
{
if (current.GetClient() != null)
{
room.GetRoomUserManager().RemoveUserFromRoom(current.GetClient(), true, false);
current.GetClient().CurrentRoomUserId = -1;
}
}
}
}
room.SaveRoomChatlog();
Room junkRoom;
LoadedRooms.TryRemove(room.RoomId, out junkRoom);
YupiWriterManager.WriteLine(string.Format("Room #{0} was unloaded, reason: " + reason, room.RoomId),
"Yupi.Rooms", ConsoleColor.DarkGray);
room.Destroy();
}
private static void AddPrivateBlackWord(string typeStr, string word)
{
BlackWordType type;
switch (typeStr)
{
case "hotel":
type = BlackWordType.Hotel;
break;
case "insult":
type = BlackWordType.Insult;
break;
case "all":
YupiWriterManager.WriteLine("Word type [all] it's reserved for system. Word: " + word, "Yupi.Security",
ConsoleColor.DarkRed);
return;
default:
YupiWriterManager.WriteLine("Undefined type [" + typeStr + "] of word: " + word, "Yupi.Security",
ConsoleColor.DarkRed);
return;
}
Words.Add(new BlackWord(word, type));
if (Replaces.ContainsKey(type))
{
return;
}
string filter = UserChatInputFilter.Default,
alert = "User [{0}] with Id: {1} has said a blackword. Word: {2}. Type: {3}. Message: {4}",
imageAlert = "bobba";
uint maxAdvices = 7u;
bool autoBan = true, showMessage = true;
if (File.Exists($"{Yupi.YupiVariablesDirectory}\\Settings\\BlackWords\\" + typeStr + ".ini"))
{
foreach (
string[] array in
File.ReadAllLines($"{Yupi.YupiVariablesDirectory}\\Settings\\BlackWords\\" + typeStr + ".ini")
.Where(line => !line.StartsWith("#") || !line.StartsWith("//") || line.Contains("="))
.Select(line => line.Split('=')))
{
if (array[0] == "filterType")
{
filter = array[1];
}
if (array[0] == "maxAdvices")
{
maxAdvices = uint.Parse(array[1]);
}
if (array[0] == "alertImage")
{
imageAlert = array[1];
}
if (array[0] == "autoBan")
{
autoBan = array[1] == "true";
}
if (array[0] == "showMessage")
{
showMessage = array[1] == "true";
}
}
}
if (File.Exists($"{Yupi.YupiVariablesDirectory}\\Settings\\BlackWords\\" + typeStr + ".alert.txt"))
{
alert = File.ReadAllText($"{Yupi.YupiVariablesDirectory}\\Settings\\BlackWords\\" + typeStr + ".alert.txt");
}
Replaces.Add(type, new BlackWordTypeSettings(filter, alert, maxAdvices, imageAlert, autoBan, showMessage));
}
/// <summary>
/// Updates the information.
/// </summary>
public static void UpdateInfo()
{
using (IQueryAdapter dbClient = Yupi.GetDatabaseManager().GetQueryReactor())
{
dbClient.SetQuery("SELECT command, description, params, rank, alias FROM server_fuses");
DataTable commandsTable = dbClient.GetTable();
foreach (DataRow commandRow in commandsTable.Rows)
{
string key = commandRow["command"].ToString();
if (!CommandsDictionary.ContainsKey(key))
{
continue;
}
Command command = CommandsDictionary[key];
if (!string.IsNullOrEmpty(commandRow["description"].ToString()))
{
command.Description = commandRow["description"].ToString();
}
if (!string.IsNullOrEmpty(commandRow["params"].ToString()))
{
command.Usage = ':' + key + " [" + commandRow["params"] + "]";
}
if (!string.IsNullOrEmpty(commandRow["alias"].ToString()))
{
string aliasStr = commandRow["alias"].ToString().Replace(" ", "").Replace(";", ",");
foreach (string alias in aliasStr.Split(',').Where(alias => !string.IsNullOrEmpty(alias)))
{
if (AliasDictionary.ContainsKey(alias))
{
YupiWriterManager.WriteLine("Duplicate alias key: " + alias, "Yupi.Commands", ConsoleColor.DarkRed);
continue;
}
if (CommandsDictionary.ContainsKey(alias))
{
YupiWriterManager.WriteLine("An alias cannot have same name as a normal command", "Yupi.Commands",
ConsoleColor.DarkRed);
continue;
}
AliasDictionary.Add(alias, key);
}
command.Alias = aliasStr;
}
short minRank;
if (short.TryParse(commandRow["rank"].ToString(), out minRank))
{
command.MinRank = minRank;
}
}
}
}
/// <summary>
/// Invokes the command.
/// </summary>
/// <param name="inputData">The input data.</param>
internal static void InvokeCommand(string inputData)
{
if (string.IsNullOrEmpty(inputData) && YupiWriterManager.DisabledState)
{
return;
}
try
{
if (inputData == null)
{
return;
}
string firstArgument = inputData, secondArgument = string.Empty;
if (inputData.Contains(" "))
{
string[] strArguments = inputData.Split(' ');
firstArgument = strArguments[0];
secondArgument = strArguments[1];
}
switch (firstArgument)
{
case "shutdown":
YupiLogManager.LogMessage($"Server Shutdowning at {DateTime.Now}.");
YupiWriterManager.DisablePrimaryWriting(true);
YupiWriterManager.WriteLine("Shutdown Initalized", "Yupi.Life", ConsoleColor.DarkYellow);
Yupi.PerformShutDown();
Console.WriteLine();
break;
case "restart":
YupiLogManager.LogMessage($"Server Restarting at {DateTime.Now}.");
YupiWriterManager.DisablePrimaryWriting(true);
YupiWriterManager.WriteLine("Restart Initialized", "Yupi.Life", ConsoleColor.DarkYellow);
Yupi.PerformRestart();
Console.WriteLine();
break;
case "reload":
switch (secondArgument)
{
case "database":
Console.WriteLine("Database destroyed");
Console.WriteLine();
break;
case "packets":
LibraryParser.ReloadDictionarys();
Console.WriteLine("> Packets Reloaded Suceffuly...");
Console.WriteLine();
break;
case "catalogue":
FurnitureDataManager.SetCache();
using (IQueryAdapter adapter = Yupi.GetDatabaseManager().GetQueryReactor())
GetGame().GetCatalogManager().Init(adapter);
FurnitureDataManager.Clear();
GetGame()
.GetClientManager()
.QueueBroadcaseMessage(
new ServerMessage(LibraryParser.OutgoingRequest("PublishShopMessageComposer")));
Console.WriteLine("Catalogue was re-loaded.");
Console.WriteLine();
break;
case "modeldata":
using (IQueryAdapter adapter2 = Yupi.GetDatabaseManager().GetQueryReactor())
GetGame().GetRoomManager().LoadModels(adapter2);
Console.WriteLine("Room models were re-loaded.");
Console.WriteLine();
break;
case "bans":
using (IQueryAdapter adapter3 = Yupi.GetDatabaseManager().GetQueryReactor())
GetGame().GetBanManager().LoadBans(adapter3);
Console.WriteLine("Bans were re-loaded");
Console.WriteLine();
break;
case "filter":
UserChatInputFilter.Reload();
BlackWordsManager.Reload();
break;
default:
UnknownCommand(inputData);
Console.WriteLine();
break;
}
break;
case "clear":
Console.Clear();
break;
case "status":
TimeSpan uptime = DateTime.Now - Yupi.YupiServerStartDateTime;
Console.WriteLine("Server status:");
Console.WriteLine();
Console.WriteLine("Uptime:");
Console.WriteLine("\tDays: {0}", uptime.Days);
Console.WriteLine("\tHours: {0}", uptime.Hours);
Console.WriteLine("\tMinutes: {0}", uptime.Minutes);
Console.WriteLine();
Console.WriteLine("Stats:");
Console.WriteLine("\tAccepted Connections: {0}",
Yupi.GetConnectionManager().Manager.AcceptedConnections);
Console.WriteLine("\tActive Threads: {0}", Process.GetCurrentProcess().Threads.Count);
Console.WriteLine();
Console.WriteLine();
break;
case "gcinfo":
{
Console.WriteLine("Mode: " + GCSettings.LatencyMode);
Console.WriteLine("Is server GC: " + GCSettings.IsServerGC);
break;
}
case "memstat":
{
Console.WriteLine("GC status:");
Console.WriteLine("\tGeneration supported: " + GC.MaxGeneration);
Console.WriteLine("\tLatency mode: " + GCSettings.LatencyMode);
Console.WriteLine("\tIs server GC: " + GCSettings.IsServerGC);
Console.WriteLine();
break;
}
case "memory":
{
GC.Collect();
Console.WriteLine("Memory flushed");
break;
}
case "help":
Console.WriteLine("shutdown");
Console.WriteLine("clear");
Console.WriteLine("memory");
Console.WriteLine("status");
Console.WriteLine("restart");
Console.WriteLine("memstat");
Console.WriteLine("reload catalogue");
Console.WriteLine("reload modeldata");
Console.WriteLine("reload bans");
Console.WriteLine("reload packets");
Console.WriteLine("reload filter");
Console.WriteLine("reload packets");
Console.WriteLine("reload database");
Console.WriteLine();
break;
default:
UnknownCommand(inputData);
break;
}
}
catch (Exception)
{
// ignored
}
}
/// <summary>
/// Unknowns the command.
/// </summary>
/// <param name="command">The command.</param>
private static void UnknownCommand(string command)
{
YupiWriterManager.WriteLine("Undefined Command: " + command, "Yupi.Commands");
}
/// <summary>
/// Main Void, Initializes the Emulator.
/// </summary>
internal static void Initialize()
{
Console.Title = "Yupi Emulator | Starting [...]";
YupiServerStartDateTime = DateTime.Now;
YupiServerTextEncoding = Encoding.Default;
MutedUsersByFilter = new Dictionary <uint, uint>();
ChatEmotions.Initialize();
CultureInfo = CultureInfo.CreateSpecificCulture("en-GB");
YupiRootDirectory = Directory.GetParent(Directory.GetParent(Environment.CurrentDirectory).FullName).FullName;
YupiVariablesDirectory = Path.Combine(YupiRootDirectory, "Variables");
try
{
ServerConfigurationSettings.Load(Path.Combine(YupiVariablesDirectory, "Settings/main.ini"));
ServerConfigurationSettings.Load(Path.Combine(YupiVariablesDirectory, "Settings/Welcome/settings.ini"), true);
if (uint.Parse(ServerConfigurationSettings.Data["db.pool.maxsize"]) > MaxRecommendedMySqlConnections)
{
YupiWriterManager.WriteLine("MySQL Max Conn is High!, Recommended Value: " + MaxRecommendedMySqlConnections, "Yupi.Data", ConsoleColor.DarkYellow);
}
MySqlConnectionStringBuilder mySqlConnectionStringBuilder = new MySqlConnectionStringBuilder
{
Server = ServerConfigurationSettings.Data["db.hostname"],
Port = uint.Parse(ServerConfigurationSettings.Data["db.port"]),
UserID = ServerConfigurationSettings.Data["db.username"],
Password = ServerConfigurationSettings.Data["db.password"],
Database = ServerConfigurationSettings.Data["db.name"],
MinimumPoolSize = uint.Parse(ServerConfigurationSettings.Data["db.pool.minsize"]),
MaximumPoolSize = uint.Parse(ServerConfigurationSettings.Data["db.pool.maxsize"]),
Pooling = true,
AllowZeroDateTime = true,
ConvertZeroDateTime = true,
DefaultCommandTimeout = 300,
ConnectionTimeout = 10
};
YupiDatabaseManager = new BasicDatabaseManager(mySqlConnectionStringBuilder);
using (IQueryAdapter queryReactor = GetDatabaseManager().GetQueryReactor())
{
DatabaseSettings = new ServerDatabaseSettings(queryReactor);
PetCommandHandler.Init(queryReactor);
PetLocale.Init(queryReactor);
OfflineMessages = new Dictionary <uint, List <OfflineMessage> >();
OfflineMessage.InitOfflineMessages(queryReactor);
}
YupiLogManager.Init(MethodBase.GetCurrentMethod().DeclaringType);
ConsoleCleanTimeInterval = int.Parse(ServerConfigurationSettings.Data["console.clear.time"]);
ConsoleTimerOn = bool.Parse(ServerConfigurationSettings.Data["console.clear.enabled"]);
FriendRequestLimit = (uint)int.Parse(ServerConfigurationSettings.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.ReleaseName = ServerConfigurationSettings.Data["client.build"];
LibraryParser.RegisterLibrary();
LibraryParser.RegisterOutgoing();
LibraryParser.RegisterIncoming();
LibraryParser.RegisterConfig();
Plugins = new Dictionary <string, IPlugin>();
ICollection <IPlugin> plugins = LoadPlugins();
if (plugins != null)
{
foreach (IPlugin item in plugins.Where(item => item != null))
{
Plugins.Add(item.PluginName, item);
YupiWriterManager.WriteLine("Loaded Plugin: " + item.PluginName + " ServerVersion: " + item.PluginVersion, "Yupi.Plugins", ConsoleColor.DarkBlue);
}
}
ServerExtraSettings.RunExtraSettings();
FurnitureDataManager.SetCache();
CrossDomainSettings.Set();
GameServer = new HabboHotel(int.Parse(ServerConfigurationSettings.Data["game.tcp.conlimit"]));
GameServer.ContinueLoading();
FurnitureDataManager.Clear();
if (ServerConfigurationSettings.Data.ContainsKey("server.lang"))
{
ServerLanguage = ServerConfigurationSettings.Data["server.lang"];
}
ServerLanguageVariables = new ServerLanguageSettings(ServerLanguage);
YupiWriterManager.WriteLine("Loaded " + ServerLanguageVariables.Count() + " Languages Vars", "Yupi.Boot");
if (plugins != null)
{
foreach (IPlugin plugin in plugins)
{
plugin?.message_void();
}
}
if (ConsoleTimerOn)
{
YupiWriterManager.WriteLine("Console Clear ConsoleRefreshTimer is Enabled, with " + ConsoleCleanTimeInterval + " Seconds.", "Yupi.Boot");
}
ClientMessageFactory.Init();
YupiUserConnectionManager = new ConnectionHandler(int.Parse(ServerConfigurationSettings.Data["game.tcp.port"]),
int.Parse(ServerConfigurationSettings.Data["game.tcp.conlimit"]),
int.Parse(ServerConfigurationSettings.Data["game.tcp.conperip"]),
ServerConfigurationSettings.Data["game.tcp.antiddos"].ToLower() == "true",
ServerConfigurationSettings.Data["game.tcp.enablenagles"].ToLower() == "true");
YupiWriterManager.WriteLine("Server Started at Port "
+ ServerConfigurationSettings.Data["game.tcp.port"] + " and Address "
+ ServerConfigurationSettings.Data["game.tcp.bindip"], "Yupi.Boot");
if (LibraryParser.Config["Crypto.Enabled"] == "true")
{
Handler.Initialize(LibraryParser.Config["Crypto.RSA.N"], LibraryParser.Config["Crypto.RSA.D"], LibraryParser.Config["Crypto.RSA.E"]);
YupiWriterManager.WriteLine("Started RSA crypto service", "Yupi.Crypto");
}
else
{
YupiWriterManager.WriteLine("The encryption system is disabled.", "Yupi.Crypto", ConsoleColor.DarkYellow);
}
LibraryParser.Initialize();
if (ConsoleTimerOn)
{
ConsoleRefreshTimer = new Timer {
Interval = ConsoleCleanTimeInterval
};
ConsoleRefreshTimer.Elapsed += ConsoleRefreshTimerElapsed;
ConsoleRefreshTimer.Start();
}
if (ServerConfigurationSettings.Data.ContainsKey("game.multithread.enabled"))
{
SeparatedTasksInMainLoops = ServerConfigurationSettings.Data["game.multithread.enabled"] == "true";
}
if (ServerConfigurationSettings.Data.ContainsKey("client.multithread.enabled"))
{
SeparatedTasksInGameClientManager = ServerConfigurationSettings.Data["client.multithread.enabled"] == "true";
}
if (ServerConfigurationSettings.Data.ContainsKey("debug.packet"))
{
PacketDebugMode = ServerConfigurationSettings.Data["debug.packet"] == "true";
}
YupiWriterManager.WriteLine("Yupi Emulator ready.", "Yupi.Boot");
IsLive = true;
}
catch (Exception e)
{
YupiWriterManager.WriteLine("Error When Starting Yupi Environment!" + Environment.NewLine + e.Message, "Yupi.Boot", ConsoleColor.Red);
YupiWriterManager.WriteLine("Please press Y to get more details or press other Key to Exit", "Yupi.Boot", ConsoleColor.Red);
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key == ConsoleKey.Y)
{
Console.WriteLine();
YupiWriterManager.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", "Yupi.Boot", ConsoleColor.Red);
Console.ReadKey();
}
Environment.Exit(1);
}
}
/// <summary>
/// Sets the cache.
/// </summary>
public static void SetCache(bool forceReload = false)
{
XmlDocument xmlParser = new XmlDocument();
WebClient wC = new WebClient();
try
{
string xmlFileContent;
string cacheDirectory = $"{Yupi.YupiVariablesDirectory}\\Cache";
Directory.CreateDirectory(cacheDirectory);
if (File.Exists($"{cacheDirectory}\\FurniDataCache.xml") && !forceReload)
{
xmlFileContent = File.ReadAllText($"{cacheDirectory}\\FurniDataCache.xml");
}
else
{
File.WriteAllText($"{cacheDirectory}\\FurniDataCache.xml",
xmlFileContent = wC.DownloadString(ServerExtraSettings.FurnitureDataUrl));
}
wC.Dispose();
xmlParser.LoadXml(xmlFileContent);
FloorItems = new Dictionary <string, FurnitureData>();
XmlNodeList xmlNodeList = xmlParser.DocumentElement?.SelectNodes("/furnidata/roomitemtypes/furnitype");
if (xmlNodeList != null)
{
foreach (XmlNode node in xmlNodeList)
{
try
{
FloorItems.Add(node?.Attributes?["classname"]?.Value,
new FurnitureData(int.Parse(node.Attributes["id"].Value),
node.SelectSingleNode("name").InnerText,
ushort.Parse(node.SelectSingleNode("xdim").InnerText),
ushort.Parse(node.SelectSingleNode("ydim").InnerText),
node.SelectSingleNode("cansiton").InnerText == "1",
node.SelectSingleNode("canstandon").InnerText == "1"));
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(node?.Attributes?["classname"]?.Value))
{
Console.WriteLine("Errror parsing furnidata by {0} with exception: {1}",
node.Attributes["classname"].Value, e.StackTrace);
}
}
}
}
WallItems = new Dictionary <string, FurnitureData>();
foreach (XmlNode node in xmlParser.DocumentElement.SelectNodes("/furnidata/wallitemtypes/furnitype"))
{
WallItems.Add(node.Attributes["classname"].Value,
new FurnitureData(int.Parse(node.Attributes["id"].Value),
node.SelectSingleNode("name").InnerText));
}
}
catch (WebException)
{
YupiWriterManager.WriteLine("Impossible to reach remote host to download FurniData.", "Yupi.Data", ConsoleColor.Red);
}
catch (XmlException)
{
YupiWriterManager.WriteLine("The XML content of the FurniData is in an invalid XML format.", "Yupi.Data", ConsoleColor.Red);
}
catch (NullReferenceException)
{
YupiWriterManager.WriteLine("The content of the FurniData file is empty, impossible to parse.", "Yupi.XML", ConsoleColor.Red);
}
}
/// <summary>
/// Called when [disconnect].
/// </summary>
/// <param name="reason">The reason.</param>
internal void OnDisconnect(string reason)
{
if (Disconnected)
{
return;
}
Disconnected = true;
if (_inventoryComponent != null)
{
lock (_inventoryComponent)
{
_inventoryComponent?.RunDbUpdate();
_inventoryComponent?.SetIdleState();
}
}
string navilogs = string.Empty;
if (NavigatorLogs.Any())
{
navilogs = NavigatorLogs.Values.Aggregate(navilogs,
(current, navi) => current + $"{navi.Id},{navi.Value1},{navi.Value2};");
navilogs = navilogs.Remove(navilogs.Length - 1);
}
Yupi.GetGame().GetClientManager().UnregisterClient(Id, UserName);
YupiWriterManager.WriteLine(UserName + " left game. Reason: " + reason, "Yupi.Users",
ConsoleColor.DarkYellow);
TimeSpan getOnlineSeconds = DateTime.Now - TimeLoggedOn;
int secondsToGive = getOnlineSeconds.Seconds;
if (!_habboinfoSaved)
{
_habboinfoSaved = true;
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
queryReactor.SetQuery("UPDATE users SET activity_points = " + Duckets +
", credits = " +
Credits + ", diamonds = " + Diamonds +
", online='0', last_online = '" +
Yupi.GetUnixTimeStamp() + "', builders_items_used = " +
BuildersItemsUsed +
", navigator_logs = @navilogs WHERE id = " + Id +
" LIMIT 1;UPDATE users_stats SET achievement_score=" +
AchievementPoints +
" WHERE id=" + Id + " LIMIT 1;");
queryReactor.AddParameter("navilogs", navilogs);
queryReactor.RunQuery();
queryReactor.RunFastQuery("UPDATE users_stats SET online_seconds = online_seconds + " +
secondsToGive + " WHERE id = " + Id);
if (Rank >= 4)
{
queryReactor.RunFastQuery(
$"UPDATE moderation_tickets SET status='open', moderator_id=0 WHERE status='picked' AND moderator_id={Id}");
}
queryReactor.RunFastQuery("UPDATE users SET block_newfriends = '" +
Convert.ToInt32(HasFriendRequestsDisabled) +
"', hide_online = '" +
Convert.ToInt32(AppearOffline) + "', hide_inroom = '" +
Convert.ToInt32(HideInRoom) + "' WHERE id = " + Id);
}
}
if (InRoom)
{
CurrentRoom?.GetRoomUserManager().RemoveUserFromRoom(_mClient, false, false);
}
if (_messenger != null)
{
_messenger.AppearOffline = true;
_messenger.Destroy();
_messenger = null;
}
_avatarEffectComponent?.Dispose();
_mClient = null;
}
public static void Initialize()
{
YupiWriterManager.WriteLine($"Loaded {CountReleases} Habbo Releases", "Yupi.Communication");
YupiWriterManager.WriteLine($"Loaded {Incoming.Count} Event Controllers", "Yupi.Communication");
}
/// <summary>
/// Loads the items.
/// </summary>
/// <param name="dbClient">The database client.</param>
internal void LoadItems(IQueryAdapter dbClient)
{
_items.Clear();
GiftWrapper.Clear();
dbClient.SetQuery("SELECT * FROM catalog_furnitures");
DataTable table = dbClient.GetTable();
if (table == null)
{
return;
}
List <double> heights = null;
foreach (DataRow dataRow in table.Rows)
{
try
{
uint id = (uint)dataRow["id"];
uint modes = (uint)dataRow["interaction_modes_count"];
uint effect = (uint)dataRow["effectid"];
char type = char.Parse((string)dataRow["type"]);
uint flatId = (uint)dataRow["flat_id"];
int sprite = 0;
string name = (string)dataRow["item_name"];
string publicName = (string)dataRow["item_name"];
string stackHeightStr = (string)dataRow["stack_height"];
string vendingIds = (string)dataRow["vending_ids"];
bool sub = (string)dataRow["subscriber"] == "1";
bool stackable = (string)dataRow["can_stack"] == "1";
bool allowRecycle = (string)dataRow["allow_recycle"] == "1";
bool allowTrade = (string)dataRow["allow_trade"] == "1";
bool allowMarketplaceSell = (string)dataRow["allow_marketplace_sell"] == "1";
bool allowGift = (string)dataRow["allow_gift"] == "1";
bool allowInventoryStack = (string)dataRow["allow_inventory_stack"] == "1";
bool canWalk = false, canSit = false, stackMultiple = false;
ushort x = ushort.MinValue, y = ushort.MinValue;
double stackHeight;
Interaction typeFromString = InteractionTypes.GetTypeFromString((string)dataRow["interaction_type"]);
if (stackHeightStr.Contains(';'))
{
heights =
stackHeightStr.Split(';')
.Select(heightStr => double.Parse(heightStr, CultureInfo.InvariantCulture))
.ToList();
stackHeight = heights[0];
stackMultiple = true;
}
else
{
stackHeight = double.Parse(stackHeightStr, CultureInfo.InvariantCulture);
}
if (name == "landscape" || name == "floor" || name == "wallpaper")
{
sprite = FurnitureDataManager.WallItems[name].Id;
x = 1;
y = 1;
}
else if (type == 's' && FurnitureDataManager.FloorItems.ContainsKey(name))
{
sprite = FurnitureDataManager.FloorItems[name].Id;
publicName = FurnitureDataManager.FloorItems[name].Name;
x = FurnitureDataManager.FloorItems[name].X;
y = FurnitureDataManager.FloorItems[name].Y;
canWalk = FurnitureDataManager.FloorItems[name].CanWalk;
canSit = FurnitureDataManager.FloorItems[name].CanSit;
}
else if (type == 'i' && FurnitureDataManager.WallItems.ContainsKey(name))
{
sprite = FurnitureDataManager.WallItems[name].Id;
publicName = FurnitureDataManager.WallItems[name].Name;
}
else if ((name.StartsWith("pet_") || publicName.StartsWith("pet_")) &&
InteractionTypes.AreFamiliar(GlobalInteractions.Pet, typeFromString))
{
x = 1;
y = 1;
publicName = name;
}
else if (type != 'e' && type != 'h' && type != 'r' && type != 'b')
{
continue;
}
if (name.StartsWith("present_gen"))
{
GiftWrapper.AddOld(sprite);
}
else if (name.StartsWith("present_wrap*"))
{
GiftWrapper.Add(sprite);
}
// If Can Walk
if (InteractionTypes.AreFamiliar(GlobalInteractions.Gate, typeFromString) ||
(typeFromString == Interaction.BanzaiPyramid) || name.StartsWith("hole"))
{
canWalk = false;
}
// Add Item
Item value = new Item(id, sprite, publicName, name, type, x, y, stackHeight, stackable, canWalk,
canSit, allowRecycle, allowTrade, allowMarketplaceSell, allowGift, allowInventoryStack,
typeFromString, modes, vendingIds, sub, effect, stackMultiple,
heights?.ToArray(), flatId);
_items.Add(id, value);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadKey();
YupiWriterManager.WriteLine(
$"Could not load item #{Convert.ToUInt32(dataRow[0])}, please verify the data is okay.",
"Yupi.Items", ConsoleColor.DarkRed);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HabboHotel" /> class.
/// </summary>
/// <param name="conns">The conns.</param>
internal HabboHotel(int conns)
{
YupiWriterManager.WriteLine(@"Starting up Yupi Emulator for " + Environment.MachineName + "...", @"Yupi.Boot");
_clientManager = new GameClientManager();
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
AbstractBar bar = new AnimatedBar();
const int wait = 15, end = 5;
uint itemsLoaded;
uint navigatorLoaded;
uint roomModelLoaded;
uint achievementLoaded;
uint pollLoaded;
Progress(bar, wait, end, "Cleaning dirty in database...");
DatabaseCleanup(queryReactor);
Progress(bar, wait, end, "Loading Bans...");
_banManager = new ModerationBanManager();
_banManager.LoadBans(queryReactor);
Progress(bar, wait, end, "Loading Roles...");
_roleManager = new RoleManager();
_roleManager.LoadRights(queryReactor);
Progress(bar, wait, end, "Loading Items...");
_itemManager = new ItemManager();
_itemManager.LoadItems(queryReactor, out itemsLoaded);
Progress(bar, wait, end, "Loading Catalog...");
_catalog = new CatalogManager();
Progress(bar, wait, end, "Loading Targeted Offers...");
_targetedOfferManager = new TargetedOfferManager();
Progress(bar, wait, end, "Loading Clothing...");
_clothingManager = new ClothingManager();
_clothingManager.Initialize(queryReactor);
Progress(bar, wait, end, "Loading Rooms...");
_roomManager = new RoomManager();
_roomManager.LoadModels(queryReactor, out roomModelLoaded);
Progress(bar, wait, end, "Loading NavigatorManager...");
_navigatorManager = new HotelBrowserManager();
_navigatorManager.Initialize(queryReactor, out navigatorLoaded);
Progress(bar, wait, end, "Loading Groups...");
_groupManager = new GroupManager();
_groupManager.InitGroups();
Progress(bar, wait, end, "Loading PixelManager...");
_pixelManager = new ExchangeManager();
Progress(bar, wait, end, "Loading HotelView...");
_hotelView = new HotelLandingManager();
Progress(bar, wait, end, "Loading Hall Of Fame...");
_hallOfFame = new HallOfFame();
Progress(bar, wait, end, "Loading ModerationTool...");
_moderationTool = new ModerationTool();
_moderationTool.LoadMessagePresets(queryReactor);
_moderationTool.LoadPendingTickets(queryReactor);
Progress(bar, wait, end, "Loading Bots...");
_botManager = new BotManager();
Progress(bar, wait, end, "Loading Events...");
_events = new RoomEvents();
Progress(bar, wait, end, "Loading Talents...");
_talentManager = new TalentManager();
_talentManager.Initialize(queryReactor);
Progress(bar, wait, end, "Loading Pinata...");
_pinataHandler = new PinataHandler();
_pinataHandler.Initialize(queryReactor);
Progress(bar, wait, end, "Loading Crackable Eggs...");
_crackableEggHandler = new CrackableEggHandler();
_crackableEggHandler.Initialize(queryReactor);
Progress(bar, wait, end, "Loading Polls...");
_pollManager = new PollManager();
_pollManager.Init(queryReactor, out pollLoaded);
Progress(bar, wait, end, "Loading Achievements...");
_achievementManager = new AchievementManager(queryReactor, out achievementLoaded);
Progress(bar, wait, end, "Loading StaticMessages ...");
StaticMessagesManager.Load();
Progress(bar, wait, end, "Loading Guides ...");
_guideManager = new GuideManager();
Progress(bar, wait, end, "Loading and Registering Commands...");
CommandsManager.Register();
CacheManager.StartProcess();
//Progress(bar, wait, end, "Loading ServerMutantManager...");
//this.ServerMutantManager = new ServerMutantManager();
Console.Write("\r".PadLeft(Console.WindowWidth - Console.CursorLeft - 1));
}
}
