/// <summary> /// Randomly select a single character from within a scope /// </summary> /// <param name="scope">PlayerCharacters, NPCs or AllPeople</param> /// <returns></returns> public SMCharacter GetRandomCharacter(SMCharacter ignoreChar, string scope = null) { switch (scope) { case "PlayerCharacters": List <SMCharacter> pc = this.GetPeople(); pc.Remove(ignoreChar); pc.Shuffle(); return(pc.FirstOrDefault()); case "NPCs": List <SMCharacter> npcs = new List <SMCharacter>(); List <SMNPC> npcl = this.GetNPCs(); if (npcl != null) { foreach (SMNPC npc in npcl) { npcs.Add(npc); } } npcs.Remove(ignoreChar); npcs.Shuffle(); return(npcs.FirstOrDefault()); default: List <SMCharacter> ap = GetAllPeople(); ap.Remove(ignoreChar); ap.Shuffle(); return(ap.FirstOrDefault()); } }
/// <summary> /// Character "Shout" method /// </summary> /// <param name="speech">What the character is "Shouting"</param> /// <param name="charSpeaking">The character who is speaking</param> public void ChatShout(string speech, SMCharacter charSpeaking) { // variable for the message sending used later. string message; // Send the message to all people connected to the room foreach (SMCharacter smc in this.GetPeople()) { // construct the local message to be sent. message = this.Formatter.Bold(charSpeaking.GetFullName() + " shouts:", 0) + " \"" + speech + "\""; this.ChatSendMessage(smc, message); } // Send a message to people connected to rooms around this room foreach (SMExit sme in this.RoomExits) { // Get the room details from the exit id SMRoom otherRooms = new SMRoom(); otherRooms = new SlackMud().GetRoom(sme.RoomID); // Get the "from" location SMExit smre = otherRooms.RoomExits.FirstOrDefault(smef => smef.RoomID == this.RoomID); // Construct the message message = this.Formatter.Italic("Someone shouts from " + smre.Description + " (" + smre.Shortcut + "):", 0) + " \"" + speech + "\""; // Send the message to all people connected to the room foreach (SMCharacter smcInOtherRoom in otherRooms.GetPeople()) { otherRooms.ChatSendMessage(smcInOtherRoom, message); } } }
/// <summary> /// Gets a list of all the people in the room. /// </summary> public string GetPeopleDetails(SMCharacter smc = null) { string returnString = this.Formatter.Bold("People:"); // Get the people within the location List <SMCharacter> smcs = this.GetPeople(); // Check if the character already exists or not. if (smcs != null) { string[] people = new string[smcs.Count]; for (int i = 0; i < smcs.Count; i++) { if (smcs[i].UserID == smc.UserID) { people[i] = "You"; } else { people[i] = smcs[i].GetFullName(); } } returnString += this.Formatter.ListItem(String.Join(", ", people)); } else { returnString += this.Formatter.ListItem("There's nobody here."); } return(returnString); }
/// <summary> /// Attack a character /// </summary> /// <param name="attackingCharacter">The attacking character</param> /// <param name="targetItem">The target string</param> public static void Attack(SMCharacter attackingCharacter, SMCharacter targetCharacter) { // Check that the target has hitpoints if (targetCharacter.Attributes.HitPoints > 0) { // Work out if this is an NPC or not SMRoom room = attackingCharacter.GetRoom(); SMNPC targetNPC = room.GetNPCs().FirstOrDefault(checkChar => checkChar.GetFullName() == targetCharacter.GetFullName()); if (targetNPC != null) { room.ProcessNPCReactions("PlayerCharacter.AttacksThem", attackingCharacter); } List <SMNPC> NPCsInRoom = targetCharacter.GetRoom().GetNPCs().FindAll(npc => npc.GetFullName() != attackingCharacter.GetFullName()); if (NPCsInRoom.Count > 0) { room.ProcessNPCReactions("PlayerCharacter.Attack", attackingCharacter); } // Use the skill attackingCharacter.UseSkill(GetSkillToUse(attackingCharacter), targetCharacter.GetFullName(), true); } else // Report that the target is already dead... { attackingCharacter.sendMessageToPlayer(ResponseFormatterFactory.Get().General($"{targetCharacter.GetFullName()} is already dead!")); } }
public void FindAllPartyMembers(SMCharacter invokingCharacter) { if (invokingCharacter.PartyReference != null) { SMParty sp = SMPartyHelper.GetParty(invokingCharacter.PartyReference.PartyID); string stringToSend = "[b]Party Members:[/b] "; bool first = true; foreach (SMPartyMember pm in sp.PartyMembers) { if (first) { first = false; } else { stringToSend += ", "; } stringToSend += pm.CharacterName; } invokingCharacter.sendMessageToPlayer(stringToSend); } else // They're not in a party { invokingCharacter.sendMessageToPlayer("[i]You're not in a party.[/i]"); } }
/// <summary> /// Decrease the faction level for a character /// </summary> /// <param name="smc">The Character</param> /// <param name="factionName">The Faction Name</param> /// <param name="amount">The amount to decrease</param> /// <returns></returns> public static void DecreaseFactionLevel(SMCharacter smc, string factionName, int amount) { // Find the faction information from the player SMFaction smf = GetFactionFromPlayerList(smc, factionName); // Check if it's null.. if (smf != null) { smc.Factions.Remove(smf); smf.Level -= amount; } else { smf = new SMFaction(factionName, (0 - amount)); if (smc.Factions == null) { smc.Factions = new List <SMFaction>(); } } smc.Factions.Add(smf); smc.sendMessageToPlayer("[i]" + smf.FactionName + " standing decreased by " + amount + " to " + smf.Level + "[/i]"); smc.SaveToApplication(); smc.SaveToFile(); }
private void ProcessResponse(NPCResponses npr, SMCharacter invokingCharacter, SMItem itemIn) { // Process each of the response steps foreach (NPCResponseStep NPCRS in npr.ResponseSteps) { // Get the invoking character invokingCharacter = new SlackMud().GetCharacter(invokingCharacter.UserID); // Check the character is still in the same room if (invokingCharacter.RoomID == this.RoomID) { switch (NPCRS.ResponseStepType) { case "Conversation": ProcessConversation(NPCRS, invokingCharacter); break; case "Attack": this.Attack(invokingCharacter.GetFullName()); break; case "UseSkill": string[] dataSplit = null; if (NPCRS.ResponseStepData.Contains('.')) { dataSplit = NPCRS.ResponseStepData.Split('.'); } else { dataSplit[0] = NPCRS.ResponseStepData; dataSplit[1] = null; } this.UseSkill(dataSplit[0], dataSplit[1]); break; case "ItemCheck": // Get the additional data string[] itemType = npr.AdditionalData.Split('.'); if (itemType[0] == "Family") { if (itemIn.ItemFamily != itemType[1]) { // Drop the item this.GetRoom().AddItem(itemIn); this.GetRoom().Announce(OutputFormatterFactory.Get().Italic($"\"{this.GetFullName()}\" dropped {itemIn.SingularPronoun} {itemIn.ItemName}.")); } else { ProcessConversation(NPCRS, invokingCharacter); } } break; } } } }
/// <summary> /// SMHelp class constructor, populate commandsList /// </summary> public SMHelp(string UserId) { this.commandList = this.GetCommandsList(); this.character = new SlackMud().GetCharacter(UserId); this.outputFormatter = OutputFormatterFactory.Get(); }
private string ProcessResponseString(string responseStringToProcess, SMCharacter invokingCharacter) { string responseString = responseStringToProcess; responseString = responseString.Replace("{playercharacter}", invokingCharacter.GetFullName()); responseString = responseString.Replace("{response}", invokingCharacter.VariableResponse); return(responseString); }
public void RebuildCharacterJSONFile() { string commandsFolderPath = FilePathSystem.GetFilePathFromFolder("Characters"); DirectoryInfo dirInfo = new DirectoryInfo(commandsFolderPath); FileInfo[] CommandFiles = dirInfo.GetFiles("*.json"); List <SMCharacter> smcl = new List <SMCharacter>(); foreach (FileInfo file in CommandFiles) { if (file.Name != "CharNamesList.json") { string path = FilePathSystem.GetFilePath("Characters", file.Name, ""); // Use a stream reader to read the file in (based on the path) using (StreamReader r = new StreamReader(path)) { // Create a new JSON string to be used... string json = r.ReadToEnd(); // Get all the commands from the commands file try { SMCharacter nsmc = JsonConvert.DeserializeObject <SMCharacter>(json); smcl.Add(nsmc); } catch { Utils.LogError("Failed to write char record in CharNamesList.json - record: " + file.Name); } } } } List <SMAccount> smal = new List <SMAccount>(); foreach (SMCharacter smc in smcl) { SMAccount sma = new SMAccount(); sma.AccountReference = smc.UserID; sma.CharacterName = smc.GetFullName(); sma.UserName = smc.Username; sma.HashedPassword = smc.Password; smal.Add(sma); } string listJSON = JsonConvert.SerializeObject(smal, Formatting.Indented); string path2 = FilePathSystem.GetFilePath("Characters", "CharNamesList"); using (StreamWriter w = new StreamWriter(path2)) { w.WriteLine(listJSON); } }
/// <summary> /// Character "SAY" method /// </summary> /// <param name="speech">What the character is "Saying"</param> /// <param name="charSpeaking">The character who is speaking</param> public void ChatSay(string speech, SMCharacter charSpeaking) { // Construct the message string message = this.Formatter.Italic(charSpeaking.GetFullName() + " says:", 0) + " \"" + speech + "\""; // Send the message to all people connected to the room foreach (SMCharacter smc in this.GetPeople()) { this.ChatSendMessage(smc, message); } }
/// <summary> /// Adds the name to the CharNamesList /// </summary> /// <param name="fullCharName">The full name of the character being added</param> /// <returns></returns> public void AddNameToList(string fullCharName, string accountReference, SMCharacter smc = null) { // Load the char names list into memory string path = FilePathSystem.GetFilePath("Characters", "CharNamesList"); List <SMAccount> allCharacters = new List <SMAccount>(); // Check if the file exists at the path. if (File.Exists(path)) { using (StreamReader r = new StreamReader(path)) { string json = r.ReadToEnd(); allCharacters = JsonConvert.DeserializeObject <List <SMAccount> >(json); } } // Create a new character reference SMAccount smcn = new SMAccount(); smcn.CharacterName = fullCharName; smcn.AccountReference = accountReference; // If the character is passed in... if (smc != null) { // ... check if there is a username and password associated if ((smc.Username != null) && (smc.Password != null)) { // Assigned the username to the email address smcn.UserName = smc.Username; smcn.HashedPassword = smc.Password; } } // Check if the account reference is already in the list SMAccount sma = allCharacters.FirstOrDefault(c => c.AccountReference == accountReference); // If it does exist... if (sma != null) { // ... remove the old version allCharacters.Remove(sma); } // Add the character to the list allCharacters.Add(smcn); // Save the list to disk. string listJSON = JsonConvert.SerializeObject(allCharacters, Formatting.Indented); using (StreamWriter w = new StreamWriter(path)) { w.WriteLine(listJSON); } }
public static void StartAnNPCReactionCheck(SMNPC npc, string actionType, SMCharacter invokingCharacter, SMItem itemIn = null) { HttpContext ctx = HttpContext.Current; Thread npcReactionThread = new Thread(new ThreadStart(() => { HttpContext.Current = ctx; npc.RespondToAction("PlayerCharacter.GivesItemToThem", invokingCharacter, itemIn); })); npcReactionThread.Start(); }
/// <summary> /// Checks if a user is logged in by getting their character from memory by UserID. /// </summary> /// <param name="UserID"></param> /// <returns>True if the user is logged in, otherwise false.</returns> private bool IsLoggedIn(string UserID) { List <SMCharacter> smcs = (List <SMCharacter>)HttpContext.Current.Application["SMCharacters"]; SMCharacter charInMem = smcs.FirstOrDefault(smc => smc.UserID == UserID); if (charInMem != null) { return(true); } return(false); }
/// <summary> /// Gets any type of character and also loads the character to memory if it isn't already there. /// Note: This returns NPCs as well as Player Characters /// </summary> /// <param name="userID">The id of the character you want to load</param> /// <returns>A character</returns> public SMCharacter GetAllCharacters(string userID) { // Get the room file if it exists SMCharacter returnCharacter = ((List <SMNPC>)HttpContext.Current.Application["SMNPCs"]).FirstOrDefault(smc => smc.UserID == userID); if (returnCharacter == null) { returnCharacter = GetCharacter(userID); } return(returnCharacter); }
/// <summary> /// Attack a Creature /// </summary> /// <param name="attackingCharacter">The attacking character</param> /// <param name="targetCharacter">The target character</param> public static void Attack(SMCharacter attackingCharacter, SMCreature targetCreature) { // Check that the target has hitpoints if (targetCreature.Attributes.HitPoints > 0) { // Use the skill attackingCharacter.UseSkill(GetSkillToUse(attackingCharacter), targetCreature.CreatureName, true); } else // Report that the target can not be found { attackingCharacter.sendMessageToPlayer(ResponseFormatterFactory.Get().General($"{targetCreature.CreatureName} can not be found")); } }
/// <summary> /// Attack an item /// </summary> /// <param name="attackingCharacter">The attacking character</param> /// <param name="targetItem">The target item</param> public static void Attack(SMCharacter attackingCharacter, SMItem targetItem) { // Check that the target has hitpoints if (targetItem.HitPoints > 0) { // Use the skill attackingCharacter.UseSkill(GetSkillToUse(attackingCharacter), targetItem.ItemName, true); } else // Report that the target can not be found { attackingCharacter.sendMessageToPlayer(targetItem.ItemName + " can not be found"); } }
/// <summary> /// Gets a character object, and loads it into memory. /// </summary> /// <param name="userID">userID is based on the id from the slack channel</param> /// <param name="newCharacter">newCharacter to change the output of the text based on whether the character is new or not</param> /// <returns>String message for usage</returns> public string GetCharacterOLD(string userID, bool newCharacter = false) { List <SMCharacter> smcs = (List <SMCharacter>)HttpContext.Current.Application["SMCharacters"]; SMCharacter character = smcs.FirstOrDefault(smc => smc.UserID == userID); if ((character != null) && (!newCharacter)) { return("You're already logged in!"); } else { string path = FilePathSystem.GetFilePath("Characters", "Char" + userID); if (File.Exists(path)) { SMCharacter smc = new SMCharacter(); using (StreamReader r = new StreamReader(path)) { string json = r.ReadToEnd(); smc = JsonConvert.DeserializeObject <SMCharacter>(json); } SMRoom room = smc.GetRoom(); if (room != null) { //TODO room.Announce() someone has entered the room or new player ect... } smcs.Add(smc); HttpContext.Current.Application["SMCharacters"] = smcs; if (!newCharacter) { return("Welcome back " + smc.FirstName); } string returnString = "Welcome to SlackMud!\n"; returnString += "We've created your character in the magical world of Arrelvia!"; // TODO, use a welcome script! // TODO, get room details return(returnString); } else { // If the UserID doesn't have a character already, inform them that they need to create one. return("You do not have a character yet, you need to create one..."); } } }
private void ProcessConversation(NPCResponseStep NPCRS, SMCharacter invokingCharacter) { // First get the conversation string[] rsd = NPCRS.ResponseStepData.Split('.'); // Get the conversation NPCConversations npcc = this.NPCConversationStructures.FirstOrDefault(constructure => constructure.ConversationID == rsd[0]); // Check we definitely found a structure to use if (npcc != null) { ProcessConversationStep(npcc, rsd[1], invokingCharacter); } }
public void LeaveParty(SMCharacter invokingCharacter, bool suppressMessages = false) { // Find the current party if they have one (and it's not just at "invited" stage). if ((invokingCharacter.PartyReference == null) || (invokingCharacter.PartyReference.Status != "Invited")) { // Remove them from the party reference. // Get the list of parties List <SMParty> smp = (List <SMParty>)HttpContext.Current.Application["Parties"]; // Find the relevant party SMParty sp = smp.FirstOrDefault(p => p.PartyID == invokingCharacter.PartyReference.PartyID); if (!suppressMessages) { sp.SendMessageToAllPartyMembers(sp, "[i]" + invokingCharacter.GetFullName() + " left the party[/i]"); } // Remove the party from the global list element. smp.Remove(sp); // Find the relevant member SMPartyMember pm = sp.PartyMembers.FirstOrDefault(p => p.CharacterName == invokingCharacter.GetFullName()); sp.PartyMembers.Remove(pm); // Check there are still people in the party if (sp.PartyMembers.Count > 0) { // Add the member back to the list smp.Add(sp); } // Save it out to the global list again HttpContext.Current.Application["Parties"] = smp; // Remove the party reference from the character file invokingCharacter.PartyReference = null; // Save the player information to the application. invokingCharacter.SaveToApplication(); } else { if (!suppressMessages) { invokingCharacter.sendMessageToPlayer("[i]You are not in a party so can't leave one[/i]"); } } }
/// <summary> /// Send a global message to all players - it is suppressed for the player sending the message. /// </summary> /// <param name="invokingCharacter">The character invoking the message</param> /// <param name="message">The message being sent</param> public void SendGlobalMessage(SMCharacter invokingCharacter, string message) { // Load the player list. List <SMCharacter> smcs = (List <SMCharacter>)HttpContext.Current.Application["SMCharacters"]; // Look around the players... foreach (SMCharacter smc in smcs) { // ... if it isn't the character invoking the message send... if (smc != invokingCharacter) { // ... send them the message. smc.sendMessageToPlayer(message); } } }
/// <summary> /// Get the faction level for character for a specific faction /// </summary> /// <param name="smc">The Character</param> /// <param name="factionName">The Faction Name</param> /// <returns></returns> public static int GetFactionAmount(SMCharacter smc, string factionName) { // Find the faction information from the player SMFaction smf = GetFactionFromPlayerList(smc, factionName); // Check if it's null.. if (smf != null) { // .. if it's not return the level return(smf.Level); } else // there isn't a faction yet { // return 0 return(0); } }
public void RespondToAction(string actionType, SMCharacter invokingCharacter, SMItem itemIn = null) { // Get a list of characters that respond to this action type in the room List <NPCResponses> listToChooseFrom = NPCResponses.FindAll(npcr => npcr.ResponseType == actionType); // If there are some responses for this character for the actionType if (listToChooseFrom != null) { // If there is more than one of the item randomise the list if (listToChooseFrom.Count > 1) { listToChooseFrom = listToChooseFrom.OrderBy(item => new Random().Next()).ToList(); } // Loop around until a response is selected bool responseSelected = false; foreach (NPCResponses npr in listToChooseFrom) { // If we're still looking for a response try the next one (if there is one) if (!responseSelected) { // randomly select whether this happens or not int rndChance = new Random().Next(1, 100); if (rndChance <= npr.Frequency) { // If the invoking character is null if ((invokingCharacter == null) && (this.RoomID != "IsSpawned")) { // Get a random player (in line with the scope of the additional data) invokingCharacter = this.GetRoom().GetRandomCharacter(this, npr.AdditionalData); } // If the invoking character is not null if (invokingCharacter != null) { // Process the response ProcessResponse(npr, invokingCharacter, itemIn); } // Set that a response has been selected so we can drop out of the loop responseSelected = true; } } } } }
public void ProcessNPCReactions(string actionType, SMCharacter invokingCharacter, string extraData = null) { List <SMNPC> lNPCs = new List <SMNPC>(); lNPCs = ((List <SMNPC>)HttpContext.Current.Application["SMNPCs"]).FindAll(npc => ((npc.RoomID == invokingCharacter.RoomID) && (npc.GetFullName() != invokingCharacter.GetFullName()))); // Check if the character already exists or not. if (lNPCs != null) { // Get the NPCs who have a response of the right type if (extraData != null) { switch (actionType) { case "PlayerCharacter.ExaminesThem": lNPCs = lNPCs.FindAll(npc => ((npc.NPCResponses.Count(npcr => npcr.ResponseType.ToLower() == actionType.ToLower()) > 0) && (npc.UserID == extraData))); break; default: lNPCs = lNPCs.FindAll(npc => npc.NPCResponses.Count(npcr => npcr.ResponseType.ToLower() == actionType.ToLower()) > 0); break; } } else { lNPCs = lNPCs.FindAll(npc => npc.NPCResponses.Count(npcr => npcr.ResponseType.ToLower() == actionType.ToLower()) > 0); } if (lNPCs != null) { foreach (SMNPC reactingNPC in lNPCs) { HttpContext ctx = HttpContext.Current; Thread npcReactionThread = new Thread(new ThreadStart(() => { HttpContext.Current = ctx; reactingNPC.RespondToAction(actionType, invokingCharacter); })); npcReactionThread.Start(); } } } }
/// <summary> /// Character "Whisper" method /// </summary> /// <param name="speech">What the character is "Whispering"</param> /// <param name="charSpeaking">The character who is speaking</param> /// /// <param name="whisperToName">The character who is being whispered to</param> public void ChatWhisper(string speech, SMCharacter charSpeaking, string whisperToName) { // Construct the message string message = this.Formatter.Italic(charSpeaking.GetFullName() + " whispers:", 0) + " \"" + speech + "\""; // See if the person being whispered to is in the room SMCharacter smc = this.GetPeople().FirstOrDefault(charWhisperedto => charWhisperedto.GetFullName() == whisperToName); if (smc != null) { this.ChatSendMessage(smc, message); } else { message = "That person doesn't appear to be here?"; // TODO Send message to player to say they can't whisper to that person. } }
public void Announce(string msg, SMCharacter sender = null, bool suppressMessageToSender = false) { // Send the message to all people connected to the room foreach (SMCharacter smc in this.GetPeople()) { bool sendMessage = true; if ((suppressMessageToSender) && (sender != null) && (sender.UserID == smc.UserID)) { sendMessage = false; } if (sendMessage) { this.ChatSendMessage(smc, msg); } } }
/// <summary> /// Gets a character and also loads the character to memory if it isn't already there. /// </summary> /// <param name="userID">The id of the character you want to load</param> /// <returns>A character</returns> public SMCharacter GetCharacter(string userID, string userName = null, string password = null) { // Get the character file if it exists List <SMCharacter> smcs = (List <SMCharacter>)HttpContext.Current.Application["SMCharacters"]; SMCharacter charInMem = smcs.FirstOrDefault(smc => smc.UserID == userID); if (charInMem == null) { // Get the right path, and work out if the file exists. string path = FilePathSystem.GetFilePath("Characters", "Char" + userID); // Check if the character exists.. if (File.Exists(path)) { using (StreamReader r = new StreamReader(path)) { // Get the character from the json string string json = r.ReadToEnd(); charInMem = JsonConvert.DeserializeObject <SMCharacter>(json); bool canLogin = true; if (password != null) { canLogin = (Crypto.DecryptStringAES(charInMem.Password) == password); } if ((canLogin) && (password != null)) { canLogin = (Crypto.DecryptStringAES(charInMem.Password) == password); } if (canLogin) { // Add the character to the application memory smcs.Add(charInMem); HttpContext.Current.Application["SMCharacters"] = smcs; // Send a message so everyone knows someone has logged in. SendGlobalMessage(charInMem, "[i][b]Global Message:[/b] " + charInMem.GetFullName() + " has logged into the game[/i]"); } } } } return(charInMem); }
/// <summary> /// Internal Method to create a room decription, created as it's going to be used over and over... /// </summary> /// <param name="smr">An SMRoom</param> /// <returns>String including a full location string</returns> public string GetLocationInformation(SMCharacter smc) { // Construct the room string. string returnString = ""; if (smc != null) { if ((!smc.NewbieTipsDisabled) && (this.RoomNewbieTips != null) && (this.RoomNewbieTips != "")) { returnString += this.Formatter.GetNewLines(1); returnString += this.Formatter.Bold("----- NEWBIE TIPS -----", 1); returnString += this.Formatter.General(this.RoomNewbieTips, 1); returnString += this.Formatter.Bold("----- END -----", 2); } } // Add the location details for the room string nameOfLocation = this.RoomID; if (nameOfLocation.Contains("||")) { nameOfLocation = nameOfLocation.Substring(0, nameOfLocation.IndexOf("||")); } returnString += this.Formatter.Bold($"Location Details - {nameOfLocation.Replace(".",", ")}:", 1); returnString += this.Formatter.Italic(this.RoomDescription, 2); // Add the people within the location returnString += this.GetPeopleDetails(smc); // Add the NPCs within the location returnString += this.GetNPCDetails(); returnString += this.Formatter.GetNewLines(1); // Add the exits to the room so that someone can leave. returnString += this.GetExitDetails(smc); returnString += this.Formatter.GetNewLines(1); // Show all the items within the room that can be returned. returnString += this.GetItemDetails(); // Return the string to the calling method. return(returnString); }
/// <summary> /// Character "EMOTE" method /// </summary> /// <param name="emoting">What the character is "Emoting"</param> /// <param name="charSpeaking">The character who is emoting</param> public void ChatEmote(string speech, SMCharacter charSpeaking, SMNPC charNPCSpeak = null) { // Construct the message // Precursor items for generic NPCs string precursor = ""; if ((charNPCSpeak != null) && (charNPCSpeak.IsGeneric)) { precursor = charNPCSpeak.PronounSingular.ToUpper() + " "; } // Output the message string message = this.Formatter.Italic(precursor + charSpeaking.GetFullName() + " " + speech, 0); // Send the message to all people connected to the room foreach (SMCharacter smc in this.GetPeople()) { this.ChatSendMessage(smc, message); } }
/// <summary> /// Gets a character and also loads the character to memory if it isn't already there. /// </summary> /// <param name="userID">The id of the character you want to load</param> /// <returns>A character</returns> public SMCharacter GetCharacter(string userID, string userName = null, string password = null) { // Get the room file if it exists List <SMCharacter> smcs = (List <SMCharacter>)HttpContext.Current.Application["SMCharacters"]; SMCharacter charInMem = smcs.FirstOrDefault(smc => smc.UserID == userID); if (charInMem == null) { // Get the right path, and work out if the file exists. string path = FilePathSystem.GetFilePath("Characters", "Char" + userID); // Check if the character exists.. if (File.Exists(path)) { using (StreamReader r = new StreamReader(path)) { // Get the character from the json string string json = r.ReadToEnd(); charInMem = JsonConvert.DeserializeObject <SMCharacter>(json); bool canLogin = true; if (password != null) { canLogin = (Crypto.DecryptStringAES(charInMem.Password, "ProvinceMUD") == password); } if ((canLogin) && (password != null)) { canLogin = (Crypto.DecryptStringAES(charInMem.Password, "ProvinceMUD") == password); } if (canLogin) { // Add the character to the application memory smcs.Add(charInMem); HttpContext.Current.Application["SMCharacters"] = smcs; } } } } return(charInMem); }