warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reorganizes Project (#41)

Browse source
This commit is contained in:
Kamron Batman 2019-08-02 18:13:40 -07:00 • committed by GitHub
parent 08bf44af9a
commit 3614a66aee
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3499 changed files with 79 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

448
Projects/Scripts/Engines/Chat/Channel.cs Normal file
View file

@ -0,0 +1,448 @@
using System.Collections.Generic;
namespace Server.Engines.Chat
{
public class Channel
{
private string m_Name;
private string m_Password;
private List<ChatUser> m_Users, m_Banned, m_Moderators, m_Voices;
private bool m_VoiceRestricted;
public Channel(string name)
{
m_Name = name;
m_Users = new List<ChatUser>();
m_Banned = new List<ChatUser>();
m_Moderators = new List<ChatUser>();
m_Voices = new List<ChatUser>();
}
public Channel(string name, string password) : this(name)
{
m_Password = password;
}
public string Name
{
get => m_Name;
set
{
SendCommand(ChatCommand.RemoveChannel, m_Name);
m_Name = value;
SendCommand(ChatCommand.AddChannel, m_Name);
SendCommand(ChatCommand.JoinedChannel, m_Name);
}
}
public string Password
{
get => m_Password;
set
{
string newValue = null;
if (value != null)
{
newValue = value.Trim();
if (string.IsNullOrEmpty(newValue))
newValue = null;
}
m_Password = newValue;
}
}
public bool VoiceRestricted
{
get => m_VoiceRestricted;
set
{
m_VoiceRestricted = value;
if (value)
SendMessage(56); // From now on, only moderators will have speaking privileges in this conference by default.
else
SendMessage(55); // From now on, everyone in the conference will have speaking privileges by default.
}
}
public bool AlwaysAvailable{ get; set; }
public static List<Channel> Channels{ get; } = new List<Channel>();
public bool Contains(ChatUser user)
{
return m_Users.Contains(user);
}
public bool IsBanned(ChatUser user)
{
return m_Banned.Contains(user);
}
public bool CanTalk(ChatUser user)
{
return !m_VoiceRestricted || m_Voices.Contains(user) || m_Moderators.Contains(user);
}
public bool IsModerator(ChatUser user)
{
return m_Moderators.Contains(user);
}
public bool IsVoiced(ChatUser user)
{
return m_Voices.Contains(user);
}
public bool ValidatePassword(string password)
{
return m_Password == null || Insensitive.Equals(m_Password, password);
}
public bool ValidateModerator(ChatUser user)
{
if (user != null && !IsModerator(user))
{
user.SendMessage(29); // You must have operator status to do this.
return false;
}
return true;
}
public bool ValidateAccess(ChatUser from, ChatUser target)
{
if (from == null || target == null || from.Mobile.AccessLevel >= target.Mobile.AccessLevel)
return true;
from.Mobile.SendMessage("Your access level is too low to do this.");
return false;
}
public bool AddUser(ChatUser user, string password = null)
{
if (Contains(user))
{
user.SendMessage(46, m_Name); // You are already in the conference '%1'.
return true;
}
if (IsBanned(user))
{
user.SendMessage(64); // You have been banned from this conference.
return false;
}
if (!ValidatePassword(password))
{
user.SendMessage(34); // That is not the correct password.
return false;
}
user.CurrentChannel?.RemoveUser(user); // Remove them from their current channel first
ChatSystem.SendCommandTo(user.Mobile, ChatCommand.JoinedChannel, m_Name);
SendCommand(ChatCommand.AddUserToChannel, user.GetColorCharacter() + user.Username);
m_Users.Add(user);
user.CurrentChannel = this;
if (user.Mobile.AccessLevel >= AccessLevel.GameMaster || !AlwaysAvailable && m_Users.Count == 1)
AddModerator(user);
SendUsersTo(user);
return true;
}
public void RemoveUser(ChatUser user)
{
if (Contains(user))
{
m_Users.Remove(user);
user.CurrentChannel = null;
if (m_Moderators.Contains(user))
m_Moderators.Remove(user);
if (m_Voices.Contains(user))
m_Voices.Remove(user);
SendCommand(ChatCommand.RemoveUserFromChannel, user, user.Username);
ChatSystem.SendCommandTo(user.Mobile, ChatCommand.LeaveChannel);
if (m_Users.Count == 0 && !AlwaysAvailable)
RemoveChannel(this);
}
}
public void AddBan(ChatUser user, ChatUser moderator = null)
{
if (!ValidateModerator(moderator) || !ValidateAccess(moderator, user))
return;
if (!m_Banned.Contains(user))
m_Banned.Add(user);
Kick(user, moderator, true);
}
public void RemoveBan(ChatUser user)
{
if (m_Banned.Contains(user))
m_Banned.Remove(user);
}
public void Kick(ChatUser user, ChatUser moderator = null)
{
Kick(user, moderator, false);
}
public void Kick(ChatUser user, ChatUser moderator, bool wasBanned)
{
if (!ValidateModerator(moderator) || !ValidateAccess(moderator, user))
return;
if (Contains(user))
{
if (moderator != null)
{
if (wasBanned)
user.SendMessage(63,
moderator.Username); // %1, a conference moderator, has banned you from the conference.
else
user.SendMessage(45,
moderator.Username); // %1, a conference moderator, has kicked you out of the conference.
}
RemoveUser(user);
ChatSystem.SendCommandTo(user.Mobile, ChatCommand.AddUserToChannel,
user.GetColorCharacter() + user.Username);
SendMessage(44, user.Username); // %1 has been kicked out of the conference.
}
if (wasBanned)
moderator?.SendMessage(62, user.Username); // You are banning %1 from this conference.
}
public void AddVoiced(ChatUser user, ChatUser moderator = null)
{
if (!ValidateModerator(moderator))
return;
if (!IsBanned(user) && !IsModerator(user) && !IsVoiced(user))
{
m_Voices.Add(user);
if (moderator != null)
user.SendMessage(54,
moderator
.Username); // %1, a conference moderator, has granted you speaking privileges in this conference.
SendMessage(52, user, user.Username); // %1 now has speaking privileges in this conference.
SendCommand(ChatCommand.AddUserToChannel, user, user.GetColorCharacter() + user.Username);
}
}
public void RemoveVoiced(ChatUser user, ChatUser moderator)
{
if (!ValidateModerator(moderator) || !ValidateAccess(moderator, user))
return;
if (!IsModerator(user) && IsVoiced(user))
{
m_Voices.Remove(user);
if (moderator != null)
user.SendMessage(53,
moderator
.Username); // %1, a conference moderator, has removed your speaking privileges for this conference.
SendMessage(51, user, user.Username); // %1 no longer has speaking privileges in this conference.
SendCommand(ChatCommand.AddUserToChannel, user, user.GetColorCharacter() + user.Username);
}
}
public void AddModerator(ChatUser user, ChatUser moderator = null)
{
if (!ValidateModerator(moderator))
return;
if (IsBanned(user) || IsModerator(user))
return;
if (IsVoiced(user))
m_Voices.Remove(user);
m_Moderators.Add(user);
if (moderator != null)
user.SendMessage(50, moderator.Username); // %1 has made you a conference moderator.
SendMessage(48, user, user.Username); // %1 is now a conference moderator.
SendCommand(ChatCommand.AddUserToChannel, user.GetColorCharacter() + user.Username);
}
public void RemoveModerator(ChatUser user, ChatUser moderator = null)
{
if (!ValidateModerator(moderator) || !ValidateAccess(moderator, user))
return;
if (IsModerator(user))
{
m_Moderators.Remove(user);
if (moderator != null)
user.SendMessage(49, moderator.Username); // %1 has removed you from the list of conference moderators.
SendMessage(47, user, user.Username); // %1 is no longer a conference moderator.
SendCommand(ChatCommand.AddUserToChannel, user.GetColorCharacter() + user.Username);
}
}
public void SendMessage(int number, string param1 = null)
{
SendMessage(number, null, param1);
}
public void SendMessage(int number, ChatUser initiator, string param1 = null, string param2 = null)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
if (user == initiator)
continue;
if (user.CheckOnline())
user.SendMessage(number, param1, param2);
else if (!Contains(user))
--i;
}
}
public void SendIgnorableMessage(int number, ChatUser from, string param1, string param2)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
if (user.IsIgnored(from))
continue;
if (user.CheckOnline())
user.SendMessage(number, from.Mobile, param1, param2);
else if (!Contains(user))
--i;
}
}
public void SendCommand(ChatCommand command, string param1 = null, string param2 = null)
{
SendCommand(command, null, param1, param2);
}
public void SendCommand(ChatCommand command, ChatUser initiator, string param1 = null, string param2 = null)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
if (user == initiator)
continue;
if (user.CheckOnline())
ChatSystem.SendCommandTo(user.Mobile, command, param1, param2);
else if (!Contains(user))
--i;
}
}
public void SendUsersTo(ChatUser to)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
ChatSystem.SendCommandTo(to.Mobile, ChatCommand.AddUserToChannel, user.GetColorCharacter() + user.Username);
}
}
public static void SendChannelsTo(ChatUser user)
{
for (int i = 0; i < Channels.Count; ++i)
{
Channel channel = Channels[i];
if (!channel.IsBanned(user))
ChatSystem.SendCommandTo(user.Mobile, ChatCommand.AddChannel, channel.Name, "0");
}
}
public static Channel AddChannel(string name, string password = null)
{
Channel channel = FindChannelByName(name);
if (channel == null)
{
channel = new Channel(name, password);
Channels.Add(channel);
}
ChatUser.GlobalSendCommand(ChatCommand.AddChannel, name, "0");
return channel;
}
public static void RemoveChannel(string name)
{
RemoveChannel(FindChannelByName(name));
}
public static void RemoveChannel(Channel channel)
{
if (channel == null)
return;
if (Channels.Contains(channel) && channel.m_Users.Count == 0)
{
ChatUser.GlobalSendCommand(ChatCommand.RemoveChannel, channel.Name);
channel.m_Moderators.Clear();
channel.m_Voices.Clear();
Channels.Remove(channel);
}
}
public static Channel FindChannelByName(string name)
{
for (int i = 0; i < Channels.Count; ++i)
{
Channel channel = Channels[i];
if (channel.m_Name == name)
return channel;
}
return null;
}
public static void Initialize()
{
AddStaticChannel("Newbie Help");
}
public static void AddStaticChannel(string name)
{
AddChannel(name).AlwaysAvailable = true;
}
}
}

150
Projects/Scripts/Engines/Chat/Chat.cs Normal file
View file

@ -0,0 +1,150 @@
using System;
using System.IO;
using Server.Accounting;
using Server.Misc;
using Server.Network;
namespace Server.Engines.Chat
{
public class ChatSystem
{
public static bool Enabled{ get; set; } = true;
public static void Initialize()
{
PacketHandlers.Register(0xB5, 0x40, true, OpenChatWindowRequest);
PacketHandlers.Register(0xB3, 0, true, ChatAction);
}
public static void SendCommandTo(Mobile to, ChatCommand type, string param1 = null, string param2 = null)
{
to?.Send(new ChatMessagePacket(null, (int)type + 20, param1, param2));
}
public static void OpenChatWindowRequest(NetState state, PacketReader pvSrc)
{
Mobile from = state.Mobile;
if (!Enabled)
{
from.SendMessage("The chat system has been disabled.");
return;
}
pvSrc.Seek(2, SeekOrigin.Begin);
string chatName = pvSrc.ReadUnicodeStringSafe((0x40 - 2) >> 1).Trim();
Account acct = state.Account as Account;
string accountChatName = null;
if (acct != null)
accountChatName = acct.GetTag("ChatName");
accountChatName = accountChatName?.Trim();
if (!string.IsNullOrEmpty(accountChatName))
{
if (chatName.Length > 0 && chatName != accountChatName)
from.SendMessage("You cannot change chat nickname once it has been set.");
}
else
{
if (chatName.Length == 0)
{
SendCommandTo(from, ChatCommand.AskNewNickname);
return;
}
if (NameVerification.Validate(chatName, 2, 31, true, true, true, 0, NameVerification.SpaceDashPeriodQuote) &&
chatName.ToLower().IndexOf("system") == -1)
{
// TODO: Optimize this search
foreach (Account checkAccount in Accounts.GetAccounts())
{
string existingName = checkAccount.GetTag("ChatName");
if (existingName != null)
{
existingName = existingName.Trim();
if (Insensitive.Equals(existingName, chatName))
{
from.SendMessage("Nickname already in use.");
SendCommandTo(from, ChatCommand.AskNewNickname);
return;
}
}
}
accountChatName = chatName;
acct?.AddTag("ChatName", chatName);
}
else
{
from.SendLocalizedMessage(501173); // That name is disallowed.
SendCommandTo(from, ChatCommand.AskNewNickname);
return;
}
}
SendCommandTo(from, ChatCommand.OpenChatWindow, accountChatName);
ChatUser.AddChatUser(from);
}
public static ChatUser SearchForUser(ChatUser from, string name)
{
ChatUser user = ChatUser.GetChatUser(name);
if (user == null)
from.SendMessage(32, name); // There is no player named '%1'.
return user;
}
public static void ChatAction(NetState state, PacketReader pvSrc)
{
if (!Enabled)
return;
try
{
Mobile from = state.Mobile;
ChatUser user = ChatUser.GetChatUser(from);
if (user == null)
return;
string lang = pvSrc.ReadStringSafe(4);
int actionID = pvSrc.ReadInt16();
string param = pvSrc.ReadUnicodeString();
ChatActionHandler handler = ChatActionHandlers.GetHandler(actionID);
if (handler != null)
{
Channel channel = user.CurrentChannel;
if (handler.RequireConference && channel == null)
user.SendMessage(31); /* You must be in a conference to do this.
* To join a conference, select one from the Conference menu.
*/
else if (handler.RequireModerator && !user.IsModerator)
user.SendMessage(29); // You must have operator status to do this.
else
handler.Callback(user, channel, param);
}
else
{
Console.WriteLine("Client: {0}: Unknown chat action 0x{1:X}: {2}", state, actionID, param);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}

20
Projects/Scripts/Engines/Chat/ChatActionHandler.cs Normal file
View file

@ -0,0 +1,20 @@
namespace Server.Engines.Chat
{
public delegate void OnChatAction(ChatUser from, Channel channel, string param);
public class ChatActionHandler
{
public ChatActionHandler(bool requireModerator, bool requireConference, OnChatAction callback)
{
RequireModerator = requireModerator;
RequireConference = requireConference;
Callback = callback;
}
public bool RequireModerator{ get; }
public bool RequireConference{ get; }
public OnChatAction Callback{ get; }
}
}

358
Projects/Scripts/Engines/Chat/ChatActionHandlers.cs Normal file
View file

@ -0,0 +1,358 @@
namespace Server.Engines.Chat
{
public class ChatActionHandlers
{
private static ChatActionHandler[] m_Handlers;
static ChatActionHandlers()
{
m_Handlers = new ChatActionHandler[0x100];
Register(0x41, true, true, ChangeChannelPassword);
Register(0x58, false, false, LeaveChat);
Register(0x61, false, true, ChannelMessage);
Register(0x62, false, false, JoinChannel);
Register(0x63, false, false, JoinNewChannel);
Register(0x64, true, true, RenameChannel);
Register(0x65, false, false, PrivateMessage);
Register(0x66, false, false, AddIgnore);
Register(0x67, false, false, RemoveIgnore);
Register(0x68, false, false, ToggleIgnore);
Register(0x69, true, true, AddVoice);
Register(0x6A, true, true, RemoveVoice);
Register(0x6B, true, true, ToggleVoice);
Register(0x6C, true, true, AddModerator);
Register(0x6D, true, true, RemoveModerator);
Register(0x6E, true, true, ToggleModerator);
Register(0x6F, false, false, AllowPrivateMessages);
Register(0x70, false, false, DisallowPrivateMessages);
Register(0x71, false, false, TogglePrivateMessages);
Register(0x72, false, false, ShowCharacterName);
Register(0x73, false, false, HideCharacterName);
Register(0x74, false, false, ToggleCharacterName);
Register(0x75, false, false, QueryWhoIs);
Register(0x76, true, true, Kick);
Register(0x77, true, true, EnableDefaultVoice);
Register(0x78, true, true, DisableDefaultVoice);
Register(0x79, true, true, ToggleDefaultVoice);
Register(0x7A, false, true, EmoteMessage);
}
public static void Register(int actionID, bool requireModerator, bool requireConference, OnChatAction callback)
{
if (actionID >= 0 && actionID < m_Handlers.Length)
m_Handlers[actionID] = new ChatActionHandler(requireModerator, requireConference, callback);
}
public static ChatActionHandler GetHandler(int actionID)
{
if (actionID >= 0 && actionID < m_Handlers.Length)
return m_Handlers[actionID];
return null;
}
public static void ChannelMessage(ChatUser from, Channel channel, string param)
{
if (channel.CanTalk(from))
channel.SendIgnorableMessage(57, from, from.GetColorCharacter() + from.Username, param); // %1: %2
else
from.SendMessage(36); // The moderator of this conference has not given you speaking privileges.
}
public static void EmoteMessage(ChatUser from, Channel channel, string param)
{
if (channel.CanTalk(from))
channel.SendIgnorableMessage(58, from, from.GetColorCharacter() + from.Username, param); // %1 %2
else
from.SendMessage(36); // The moderator of this conference has not given you speaking privileges.
}
public static void PrivateMessage(ChatUser from, Channel channel, string param)
{
int indexOf = param.IndexOf(' ');
string name = param.Substring(0, indexOf);
string text = param.Substring(indexOf + 1);
ChatUser target = ChatSystem.SearchForUser(from, name);
if (target == null)
return;
if (target.IsIgnored(from))
from.SendMessage(35,
target.Username); // %1 has chosen to ignore you. None of your messages to them will get through.
else if (target.IgnorePrivateMessage)
from.SendMessage(42, target.Username); // %1 has chosen to not receive private messages at the moment.
else
target.SendMessage(59, from.Mobile, from.GetColorCharacter() + from.Username, text); // [%1]: %2
}
public static void LeaveChat(ChatUser from, Channel channel, string param)
{
ChatUser.RemoveChatUser(from);
}
public static void ChangeChannelPassword(ChatUser from, Channel channel, string param)
{
channel.Password = param;
from.SendMessage(60); // The password to the conference has been changed.
}
public static void AllowPrivateMessages(ChatUser from, Channel channel, string param)
{
from.IgnorePrivateMessage = false;
from.SendMessage(37); // You can now receive private messages.
}
public static void DisallowPrivateMessages(ChatUser from, Channel channel, string param)
{
from.IgnorePrivateMessage = true;
from.SendMessage(38); /* You will no longer receive private messages.
* Those who send you a message will be notified that you are blocking incoming messages.
*/
}
public static void TogglePrivateMessages(ChatUser from, Channel channel, string param)
{
from.IgnorePrivateMessage = !from.IgnorePrivateMessage;
from.SendMessage(from.IgnorePrivateMessage ? 38 : 37); // See above for messages
}
public static void ShowCharacterName(ChatUser from, Channel channel, string param)
{
from.Anonymous = false;
from.SendMessage(
39); // You are now showing your character name to any players who inquire with the whois command.
}
public static void HideCharacterName(ChatUser from, Channel channel, string param)
{
from.Anonymous = true;
from.SendMessage(
40); // You are no longer showing your character name to any players who inquire with the whois command.
}
public static void ToggleCharacterName(ChatUser from, Channel channel, string param)
{
from.Anonymous = !from.Anonymous;
from.SendMessage(from.Anonymous ? 40 : 39); // See above for messages
}
public static void JoinChannel(ChatUser from, Channel channel, string param)
{
string name;
string password = null;
int start = param.IndexOf('\"');
if (start >= 0)
{
int end = param.IndexOf('\"', ++start);
if (end >= 0)
{
name = param.Substring(start, end - start);
password = param.Substring(++end);
}
else
{
name = param.Substring(start);
}
}
else
{
int indexOf = param.IndexOf(' ');
if (indexOf >= 0)
{
name = param.Substring(0, indexOf++);
password = param.Substring(indexOf);
}
else
{
name = param;
}
}
password = password?.Trim();
if (password?.Length == 0)
password = null;
Channel joined = Channel.FindChannelByName(name);
if (joined == null)
from.SendMessage(33, name); // There is no conference named '%1'.
else
joined.AddUser(from, password);
}
public static void JoinNewChannel(ChatUser from, Channel channel, string param)
{
if ((param = param.Trim()).Length == 0)
return;
string name;
string password = null;
int start = param.IndexOf('{');
if (start >= 0)
{
name = param.Substring(0, start++);
int end = param.IndexOf('}', start);
if (end >= start)
password = param.Substring(start, end - start);
}
else
{
name = param;
}
password = password?.Trim();
if (password?.Length == 0)
password = null;
Channel.AddChannel(name, password).AddUser(from, password);
}
public static void AddIgnore(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
from.AddIgnored(target);
}
public static void RemoveIgnore(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
from.RemoveIgnored(target);
}
public static void ToggleIgnore(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
if (from.IsIgnored(target))
from.RemoveIgnored(target);
else
from.AddIgnored(target);
}
public static void AddVoice(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target != null)
channel.AddVoiced(target, from);
}
public static void RemoveVoice(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target != null)
channel.RemoveVoiced(target, from);
}
public static void ToggleVoice(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
if (channel.IsVoiced(target))
channel.RemoveVoiced(target, from);
else
channel.AddVoiced(target, from);
}
public static void AddModerator(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target != null)
channel.AddModerator(target, from);
}
public static void RemoveModerator(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target != null)
channel.RemoveModerator(target, from);
}
public static void ToggleModerator(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
if (channel.IsModerator(target))
channel.RemoveModerator(target, from);
else
channel.AddModerator(target, from);
}
public static void RenameChannel(ChatUser from, Channel channel, string param)
{
channel.Name = param;
}
public static void QueryWhoIs(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target == null)
return;
if (target.Anonymous)
from.SendMessage(41, target.Username); // %1 is remaining anonymous.
else
from.SendMessage(43, target.Username, target.Mobile.Name); // %2 is known in the lands of Britannia as %2.
}
public static void Kick(ChatUser from, Channel channel, string param)
{
ChatUser target = ChatSystem.SearchForUser(from, param);
if (target != null)
channel.Kick(target, from);
}
public static void EnableDefaultVoice(ChatUser from, Channel channel, string param)
{
channel.VoiceRestricted = false;
}
public static void DisableDefaultVoice(ChatUser from, Channel channel, string param)
{
channel.VoiceRestricted = true;
}
public static void ToggleDefaultVoice(ChatUser from, Channel channel, string param)
{
channel.VoiceRestricted = !channel.VoiceRestricted;
}
}
}

50
Projects/Scripts/Engines/Chat/ChatCommand.cs Normal file
View file

@ -0,0 +1,50 @@
namespace Server.Engines.Chat
{
public enum ChatCommand
{
/// <summary>
/// Add a channel to top list.
/// </summary>
AddChannel = 0x3E8,
/// <summary>
/// Remove channel from top list.
/// </summary>
RemoveChannel = 0x3E9,
/// <summary>
/// Queries for a new chat nickname.
/// </summary>
AskNewNickname = 0x3EB,
/// <summary>
/// Closes the chat window.
/// </summary>
CloseChatWindow = 0x3EC,
/// <summary>
/// Opens the chat window.
/// </summary>
OpenChatWindow = 0x3ED,
/// <summary>
/// Add a user to current channel.
/// </summary>
AddUserToChannel = 0x3EE,
/// <summary>
/// Remove a user from current channel.
/// </summary>
RemoveUserFromChannel = 0x3EF,
/// <summary>
/// Send a message putting generic conference name at top when player leaves a channel.
/// </summary>
LeaveChannel = 0x3F0,
/// <summary>
/// Send a message putting Channel name at top and telling player he joined the channel.
/// </summary>
JoinedChannel = 0x3F1
}
}

212
Projects/Scripts/Engines/Chat/ChatUser.cs Normal file
View file

@ -0,0 +1,212 @@
using System.Collections.Generic;
using Server.Accounting;
namespace Server.Engines.Chat
{
public class ChatUser
{
public const char NormalColorCharacter = '0';
public const char ModeratorColorCharacter = '1';
public const char VoicedColorCharacter = '2';
private static List<ChatUser> m_Users = new List<ChatUser>();
private static Dictionary<Mobile, ChatUser> m_Table = new Dictionary<Mobile, ChatUser>();
public ChatUser(Mobile m)
{
Mobile = m;
Ignored = new List<ChatUser>();
Ignoring = new List<ChatUser>();
}
public Mobile Mobile{ get; }
public List<ChatUser> Ignored{ get; }
public List<ChatUser> Ignoring{ get; }
public string Username
{
get
{
if (Mobile.Account is Account acct)
return acct.GetTag("ChatName");
return null;
}
set
{
if (Mobile.Account is Account acct)
acct.SetTag("ChatName", value);
}
}
public Channel CurrentChannel{ get; set; }
public bool IsOnline => Mobile.NetState != null;
public bool Anonymous{ get; set; }
public bool IgnorePrivateMessage{ get; set; }
public bool IsModerator => CurrentChannel?.IsModerator(this) == true;
public char GetColorCharacter()
{
return IsModerator ? ModeratorColorCharacter :
CurrentChannel?.IsVoiced(this) == true ? VoicedColorCharacter : NormalColorCharacter;
}
public bool CheckOnline()
{
if (IsOnline)
return true;
RemoveChatUser(this);
return false;
}
public void SendMessage(int number, string param1 = null, string param2 = null)
{
if (Mobile.NetState != null)
Mobile.Send(new ChatMessagePacket(Mobile, number, param1, param2));
}
public void SendMessage(int number, Mobile from, string param1, string param2)
{
if (Mobile.NetState != null)
Mobile.Send(new ChatMessagePacket(from, number, param1, param2));
}
public bool IsIgnored(ChatUser check)
{
return Ignored.Contains(check);
}
public void AddIgnored(ChatUser user)
{
if (IsIgnored(user))
{
SendMessage(22, user.Username); // You are already ignoring %1.
}
else
{
Ignored.Add(user);
user.Ignoring.Add(this);
SendMessage(23, user.Username); // You are now ignoring %1.
}
}
public void RemoveIgnored(ChatUser user)
{
if (IsIgnored(user))
{
Ignored.Remove(user);
user.Ignoring.Remove(this);
SendMessage(24, user.Username); // You are no longer ignoring %1.
if (Ignored.Count == 0)
SendMessage(26); // You are no longer ignoring anyone.
}
else
{
SendMessage(25, user.Username); // You are not ignoring %1.
}
}
public static ChatUser AddChatUser(Mobile from)
{
ChatUser user = GetChatUser(from);
if (user != null)
return user;
user = new ChatUser(from);
m_Users.Add(user);
m_Table[from] = user;
Channel.SendChannelsTo(user);
List<Channel> list = Channel.Channels;
for (int i = 0; i < list.Count; ++i)
{
Channel c = list[i];
if (c.AddUser(user))
break;
}
//ChatSystem.SendCommandTo( user.m_Mobile, ChatCommand.AddUserToChannel, user.GetColorCharacter() + user.Username );
return user;
}
public static void RemoveChatUser(ChatUser user)
{
if (user == null)
return;
for (int i = 0; i < user.Ignoring.Count; ++i)
user.Ignoring[i].RemoveIgnored(user);
if (m_Users.Contains(user))
{
ChatSystem.SendCommandTo(user.Mobile, ChatCommand.CloseChatWindow);
user.CurrentChannel?.RemoveUser(user);
m_Users.Remove(user);
m_Table.Remove(user.Mobile);
}
}
public static void RemoveChatUser(Mobile from)
{
ChatUser user = GetChatUser(from);
RemoveChatUser(user);
}
public static ChatUser GetChatUser(Mobile from)
{
m_Table.TryGetValue(from, out ChatUser c);
return c;
}
public static ChatUser GetChatUser(string username)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
if (user.Username == username)
return user;
}
return null;
}
public static void GlobalSendCommand(ChatCommand command, string param1, string param2 = null)
{
GlobalSendCommand(command, null, param1, param2);
}
public static void GlobalSendCommand(ChatCommand command, ChatUser initiator = null, string param1 = null, string param2 = null)
{
for (int i = 0; i < m_Users.Count; ++i)
{
ChatUser user = m_Users[i];
if (user == initiator)
continue;
if (user.CheckOnline())
ChatSystem.SendCommandTo(user.Mobile, command, param1, param2);
}
}
}
}

15
Projects/Scripts/Engines/Chat/Chatold.cs Normal file
View file

@ -0,0 +1,15 @@
namespace Server.Chat
{
public class ChatSystem
{
public static void Initialize()
{
EventSink.ChatRequest += EventSink_ChatRequest;
}
private static void EventSink_ChatRequest(ChatRequestEventArgs e)
{
e.Mobile.SendMessage("Chat is not currently supported.");
}
}
}

28
Projects/Scripts/Engines/Chat/Packets.cs Normal file
View file

@ -0,0 +1,28 @@
using Server.Network;
namespace Server.Engines.Chat
{
public sealed class ChatMessagePacket : Packet
{
public ChatMessagePacket(Mobile who, int number, string param1, string param2) : base(0xB2)
{
if (param1 == null)
param1 = string.Empty;
if (param2 == null)
param2 = string.Empty;
EnsureCapacity(13 + (param1.Length + param2.Length) * 2);
m_Stream.Write((ushort)(number - 20));
if (who != null)
m_Stream.WriteAsciiFixed(who.Language, 4);
else
m_Stream.Write(0);
m_Stream.WriteBigUniNull(param1);
m_Stream.WriteBigUniNull(param2);
}
}
}