예제 #1
0
파일: Console.cs 프로젝트: Xileck/tibiaapi
 /// <summary>
 /// Create a default message.
 /// </summary>
 /// <param name="text"></param>
 public ChatMessage(string text)
 {
     this.Text = text;
     this.Recipient = "";
     this.Channel = ChatChannel.None;
     this.Type = SpeechType.Say;
 }
예제 #2
0
 public static bool Send(Objects.Client client, ChatChannel channel, string name)
 {
     ChannelOpenPacket p = new ChannelOpenPacket(client);
     p.ChannelId = channel;
     p.ChannelName = name;
     return p.Send();
 }
예제 #3
0
 public ChatSendPacket(string _World, ChatChannel _Channel, string PlayerName, string Chat)
     : base()
 {
     World = _World;
     Channel = _Channel;
     Name = PlayerName;
     Text = Chat;
 }
예제 #4
0
파일: Console.cs 프로젝트: Xileck/tibiaapi
 /// <summary>
 /// Create a channel message.
 /// </summary>
 /// <param name="text"></param>
 /// <param name="channel"></param>
 public static ChatMessage CreateChannelMessage(string text, ChatChannel channel)
 {
     ChatMessage cm = new ChatMessage(text);
     cm.Recipient = "";
     cm.Channel = channel;
     cm.Type = SpeechType.ChannelYellow;
     return cm;
 }
예제 #5
0
		private ChatData ParseChat( JsonObject jsonObject, ChatChannel chatChannel)
		{
		    var data = SimpleJson.DeserializeObject<ChatData>(jsonObject.ToString());

		    data.ChatChannel = chatChannel;

		    return data;
		}
예제 #6
0
        public static bool Send(Objects.Client client, SpeechType type, string receiver, string message, ChatChannel channel)
        {
            PlayerSpeechPacket p = new PlayerSpeechPacket(client);

            p.SpeechType = type;
            p.Receiver = receiver;
            p.Message = message;
            p.ChannelId = channel;

            return p.Send();
        }
예제 #7
0
        public override bool ParseMessage(NetworkMessage msg, PacketDestination destination)
        {
            if (msg.GetByte() != (byte)OutgoingPacketType.ChannelClose)
                return false;

            Destination = destination;
            Type = OutgoingPacketType.ChannelClose;

            ChannelId = (ChatChannel)msg.GetUInt16();

            return true;
        }
예제 #8
0
        public Form1()
        {
            InitializeComponent();
            _inputChannel = ChatChannel.Global;

            _chatEntries = new List<ChatEntry>();

            _ffcm = new FFCManager("127.0.0.1", 1255);
            _ffcm.OnChatChannels += _ffcm_OnChatChannels;
            _ffcm.OnChatMessage += _ffcm_OnChatMessage;

            tbEmail.Text = "*****@*****.**";
            tbPassword.Text = "test";
        }
예제 #9
0
파일: MyBot.cs 프로젝트: Yonom/ByteChannel
        public void On(JoinCompleteEvent e)
        {
            var bp = new ByteProtocol<Player>(this._byteChannel);
            var cc = new ChatChannel(new CompressionChannel<Player>(bp.RegisterProtocol("EE Chat")));

            ThreadPool.QueueUserWorkItem(o =>
            {
                while (true)
                {
                    cc.Send(Console.ReadLine());
                }
            });

            cc.Receive += this.Cc_Receive;
        }
예제 #10
0
        public static void Add(
            NetworkMessage message,
            string senderName,
            ushort senderLevel,
            SpeechType speechType,
            string text,
            Location location,
            ChatChannel channelId,
            uint time
            )
        {
            message.AddByte((byte)ServerPacketType.CreatureSpeech);

            message.AddUInt32(0x00000000);
            message.AddString(senderName);
            message.AddUInt16(senderLevel);
            message.AddByte((byte)speechType);

            switch (speechType)
            {
                case SpeechType.Say:
                case SpeechType.Whisper:
                case SpeechType.Yell:
                case SpeechType.MonsterSay:
                case SpeechType.MonsterYell:
                case SpeechType.PrivateNPCToPlayer:
                    message.AddLocation(location);
                    break;
                case SpeechType.ChannelRed:
                case SpeechType.ChannelRedAnonymous:
                case SpeechType.ChannelOrange:
                case SpeechType.ChannelYellow:
                case SpeechType.ChannelWhite:
                    message.AddUInt16((ushort)channelId);
                    break;
                case SpeechType.RuleViolationReport:
                    message.AddUInt32(time);
                    break;
                default:
                    break;

            }

            message.AddString(text);
        }
예제 #11
0
        public static bool Send(Objects.Client client, ChatChannel channel, string name, string[] participants, string[] invitees)
        {
            ChannelOpenPacket p = new ChannelOpenPacket(client);
            p.ChannelId = channel;
            p.ChannelName = name;

            if (client.VersionNumber >= 872)
            {
                p.NumberOfParticipants = (ushort)(participants.Length);
                for (ushort n = 0; n < p.NumberOfParticipants; n++)
                {
                    p.Participants[n] = participants[n];
                }
                p.NumberOfInvitees = (ushort)(invitees.Length);
                for (ushort i = 0; i < p.NumberOfInvitees; i++)
                {
                    p.Invitees[i] = invitees[i];
                }
            }

            return p.Send();
        }
예제 #12
0
        public void SendChatMessage(ChatChannel channel, string text, string name, int? entityId)
        {
            string fullmsg = text;
            if (!string.IsNullOrEmpty(name) && channel == ChatChannel.Emote)
                fullmsg = text; //Emote already has name in it probably...
            else if (channel == ChatChannel.Ingame || channel == ChatChannel.OOC || channel == ChatChannel.Radio ||
                     channel == ChatChannel.Lobby)
                fullmsg = name + ": " + text;

            NetOutgoingMessage message = IoCManager.Resolve<ISS13NetServer>().CreateMessage();

            message.Write((byte) NetMessage.ChatMessage);
            message.Write((byte) channel);
            message.Write(fullmsg);
            if(entityId == null)
                message.Write(-1);
            else
                message.Write((int)entityId);

            switch (channel)
            {
                case ChatChannel.Server:
                case ChatChannel.OOC:
                case ChatChannel.Radio:
                case ChatChannel.Player:
                case ChatChannel.Default:
                    IoCManager.Resolve<ISS13NetServer>().SendToAll(message);
                    break;
                case ChatChannel.Damage:
                case ChatChannel.Ingame:
                case ChatChannel.Visual:
                case ChatChannel.Emote:
                    SendToPlayersInRange(message, entityId);
                    break;
                case ChatChannel.Lobby:
                    SendToLobby(message);
                    break;
            }
        }
예제 #13
0
        public static void AtStartup(RuleEngine GlobalRules)
        {
            GlobalRules.DeclareCheckRuleBook<MudObject, MudObject>("can access channel?", "[Client, Channel] : Can the client access the chat channel?", "actor", "channel");

            GlobalRules.Check<MudObject, MudObject>("can access channel?")
                .Do((client, channel) => CheckResult.Allow)
                .Name("Default allow channel access rule.");

            GlobalRules.Perform<Actor>("player joined")
                .Do(player =>
                {
                    foreach (var c in ChatChannel.ChatChannels.Where(c => c.Short == "OOC"))
                        c.Subscribers.Add(player);
                    return PerformResult.Continue;
                })
                .Name("Subscribe new players to OOC rule.");

            GlobalRules.Perform<Actor>("player left")
                .Do(player =>
                {
                    ChatChannel.RemoveFromAllChannels(player);
                    return PerformResult.Continue;
                })
                .Name("Unsubscribe players from all channels when they leave rule.");

            ChatChannel.ChatChannels.Clear();
            ChatChannel.ChatChannels.Add(new ChatChannel("OOC"));

            var senate = new ChatChannel("SENATE");
            senate.Check<MudObject, MudObject>("can access channel?")
                .When((actor, channel) => !(actor is Actor) || (actor as Actor).Rank < 100)
                .Do((actor, channel) =>
                {
                    MudObject.SendMessage(actor, "You must have a rank of 100 or greater to access this channel.");
                    return CheckResult.Disallow;
                });
            ChatChannel.ChatChannels.Add(senate);
        }
예제 #14
0
        public override bool ParseMessage(NetworkMessage msg, PacketDestination destination)
        {
            if (msg.GetByte() != (byte)OutgoingPacketType.PlayerSpeech)
                return false;

            Destination = destination;
            Type = OutgoingPacketType.PlayerSpeech;

            SpeechTypeInfo info = Enums.GetSpeechTypeInfo(Client.GetVersionNumber(), msg.GetByte());
            SpeechType = info.SpeechType;

            if (SpeechType == SpeechType.Private)
            {
                Receiver = msg.GetString();
            }
            else if (info.AdditionalSpeechData == AdditionalSpeechData.ChannelId)
            {
                ChannelId = (ChatChannel)msg.GetUInt16();
            }

            Message = msg.GetString();

            return true;
        }
예제 #15
0
 /// <summary>Send owner changed message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (to check the ignore list)</param>
 /// <param name="newOwner">new owner</param>
 public static void SendOwnerChangedToEveryone(ChatChannel chan, EntityId sender, EntityId newOwner)
 {
 }
예제 #16
0
 /// <summary>Send the name of current of the channel</summary>
 /// <param name="client">the client the outdoing packet belongs to</param>
 /// <param name="chan">the channel</param>
 public static void SendCurrentOwner(IPacketReceiver client, ChatChannel chan)
 {
 }
예제 #17
0
        public void AddLine(string message, ChatChannel channel)
        {
            if (_disposing) return;

            IEnumerable<string> messageSplit = CheckInboundMessage(message);

            foreach (Label label in messageSplit.Select(part => new Label(part, "CALIBRI", _resourceManager)
                                                                    {
                                                                        Text =
                                                                            {
                                                                                Size =
                                                                                    new Size(ClientArea.Width - 10, 12),
                                                                                Color = _chatColors[channel]
                                                                            }
                                                                    }))
            {
                _entries.Add(label);
            }

            DrawLines();
        }
예제 #18
0
 public void Start()
 {
     namelessChannels = ChatChannel.Examine | ChatChannel.Local | ChatChannel.None | ChatChannel.System | ChatChannel.Combat;
 }
예제 #19
0
 /// <summary>
 /// Send a generic message.
 /// </summary>
 /// <param name="client"></param>
 /// <param name="senderName"></param>
 /// <param name="senderLevel"></param>
 /// <param name="speechType"></param>
 /// <param name="channelId"></param>
 /// <param name="position"></param>
 /// <param name="time"></param>
 /// <returns></returns>
 public static bool Send(Objects.Client client, string senderName, ushort senderLevel, string message, SpeechType speechType, ChatChannel channelId, Objects.Location position, uint time)
 {
     CreatureSpeechPacket p = new CreatureSpeechPacket(client);
     p.SenderName = senderName;
     p.SenderLevel = senderLevel;
     p.Message = message;
     p.SpeechType = speechType;
     p.ChannelId = channelId;
     p.Position = position;
     p.Time = time;
     return p.Send();
 }
예제 #20
0
 /// <summary>Send the password changed message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (to check the ignore list)</param>
 public static void SendPasswordChangedToEveryone(ChatChannel chan, EntityId sender)
 {
 }
예제 #21
0
 /// <summary>Send the "name has joined channel" reply to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (to check the ignore list)</param>
 public static void SendJoinedReplyToEveryone(ChatChannel chan, ChannelMember sender)
 {
 }
예제 #22
0
 public void SendChannelSpeech(string sender, SpeechType type, ChatChannel channelId, string message)
 {
     NetworkMessage outMessage = new NetworkMessage();
     CreatureSpeechPacket.Add(
         outMessage,
         sender,
         1,
         type,
         message,
         null,
         channelId,
         0
     );
     Send(outMessage);
 }
예제 #23
0
 /// <summary>
 /// Send the message about change of muted status of player to everyone
 /// </summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (to check the ignore list)</param>
 /// <param name="target">one who has changed his status</param>
 /// <param name="newStatus">the new status</param>
 public static void SendMuteStatusToEveryone(ChatChannel chan, EntityId sender, EntityId target, bool newStatus)
 {
 }
예제 #24
0
        void HandleMessageChat(InPacket packet)
        {
            var type   = (ChatMessageType)packet.ReadByte();
            var lang   = (Language)packet.ReadInt32();
            var guid   = packet.ReadUInt64();
            var unkInt = packet.ReadInt32();

            switch (type)
            {
            case ChatMessageType.Say:
            case ChatMessageType.Yell:
            case ChatMessageType.Party:
            case ChatMessageType.PartyLeader:
            case ChatMessageType.Raid:
            case ChatMessageType.RaidLeader:
            case ChatMessageType.RaidWarning:
            case ChatMessageType.Guild:
            case ChatMessageType.Officer:
            case ChatMessageType.Emote:
            case ChatMessageType.TextEmote:
            case ChatMessageType.Whisper:
            case ChatMessageType.WhisperInform:
            case ChatMessageType.System:
            case ChatMessageType.Channel:
            case ChatMessageType.Battleground:
            case ChatMessageType.BattlegroundNeutral:
            case ChatMessageType.BattlegroundAlliance:
            case ChatMessageType.BattlegroundHorde:
            case ChatMessageType.BattlegroundLeader:
            case ChatMessageType.Achievement:
            case ChatMessageType.GuildAchievement:
            {
                ChatChannel channel = new ChatChannel();
                channel.Type = type;

                if (type == ChatMessageType.Channel)
                {
                    channel.ChannelName = packet.ReadCString();
                }

                var sender = packet.ReadUInt64();

                ChatMessage message = new ChatMessage();
                var         textLen = packet.ReadInt32();
                message.Message  = packet.ReadCString();
                message.Language = lang;
                message.ChatTag  = (ChatTag)packet.ReadByte();
                message.Sender   = channel;

                //! If we know the name of the sender GUID, use it
                //! For system messages sender GUID is 0, don't need to do anything fancy
                string senderName = null;
                if (type == ChatMessageType.System ||
                    Game.World.PlayerNameLookup.TryGetValue(sender, out senderName))
                {
                    message.Sender.Sender = senderName;
                    Game.UI.PresentChatMessage(message);
                    return;
                }

                //! If not we place the message in the queue,
                //! .. either existent
                Queue <ChatMessage> messageQueue = null;
                if (Game.World.QueuedChatMessages.TryGetValue(sender, out messageQueue))
                {
                    messageQueue.Enqueue(message);
                }
                //! or non existent
                else
                {
                    messageQueue = new Queue <ChatMessage>();
                    messageQueue.Enqueue(message);
                    Game.World.QueuedChatMessages.Add(sender, messageQueue);
                }

                //! Furthermore we send CMSG_NAME_QUERY to the server to retrieve the name of the sender
                OutPacket response = new OutPacket(WorldCommand.CMSG_NAME_QUERY);
                response.Write(sender);
                Game.SendPacket(response);

                //! Enqueued chat will be printed when we receive SMSG_NAME_QUERY_RESPONSE

                break;
            }

            default:
                return;
            }
        }
예제 #25
0
 public static void SendVoiceData(ChatChannel chatChannel)
 {
     using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_VOICE_SESSION_ROSTER_UPDATE))
     {
     }
 }
예제 #26
0
 public void AddToChatLogClient(string message, ChatChannel channels)
 {
     UpdateClientChat(message, channels);
     RefreshLog();
 }
예제 #27
0
    private void UpdateClientChat(string message, ChatChannel channels)
    {
        ChatEvent chatEvent = new ChatEvent(message, channels, true);

        ChatLog.Add(chatEvent);
    }
예제 #28
0
    /// Visualize that channel mask mess
    public static string ListChannels(ChatChannel channels, string separator = ", ")
    {
        string listChannels = string.Join(separator, EncryptionKey.getChannelsByMask(channels));

        return(listChannels == "" ? "None" : listChannels);
    }
예제 #29
0
 private void AddToChatLogClient(string message, ChatChannel channels)
 {
     UpdateClientChat(message, channels);
 }
예제 #30
0
 /// <summary>Send the announce status change message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (status changer)</param>
 /// <param name="newStatus">new announcements status</param>
 public static void SendAnnouncementToEveryone(ChatChannel chan, EntityId sender, bool newStatus)
 {
 }
예제 #31
0
 /// <summary>Send the kick message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (aka kicker)</param>
 /// <param name="kicked">kicked</param>
 public static void SendKickedToEveryone(ChatChannel chan, EntityId sender, EntityId kicked)
 {
 }
예제 #32
0
 /// <summary>Send the moderate status change message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (status changer)</param>
 public static void SendModerateToEveryone(ChatChannel chan, EntityId sender)
 {
 }
예제 #33
0
 public Channel(ChatChannel id, string name)
 {
     Id = id;
     Name = name;
 }
예제 #34
0
 /// <summary>Send the unbanned message to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (aka unbanner)</param>
 /// <param name="unbanned">unbanned</param>
 public static void SendUnbannedToEveryone(ChatChannel chan, EntityId sender, EntityId unbanned)
 {
 }
예제 #35
0
파일: Chat.cs 프로젝트: Illya9999/HISP
        public static GameClient[] GetRecipiants(User user, ChatChannel channel, string to = null)
        {
            if (channel == ChatChannel.All)
            {
                List <GameClient> recipiants = new List <GameClient>();
                foreach (GameClient client in GameServer.ConnectedClients)
                {
                    if (client.LoggedIn)
                    {
                        if (!client.LoggedinUser.MuteGlobal && !client.LoggedinUser.MuteAll)
                        {
                            if (client.LoggedinUser.Id != user.Id)
                            {
                                if (!client.LoggedinUser.MutePlayer.IsUserMuted(user))
                                {
                                    recipiants.Add(client);
                                }
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Ads)
            {
                List <GameClient> recipiants = new List <GameClient>();
                foreach (GameClient client in GameServer.ConnectedClients)
                {
                    if (client.LoggedIn)
                    {
                        if (!client.LoggedinUser.MuteAds && !client.LoggedinUser.MuteAll)
                        {
                            if (client.LoggedinUser.Id != user.Id)
                            {
                                if (!client.LoggedinUser.MutePlayer.IsUserMuted(user))
                                {
                                    recipiants.Add(client);
                                }
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Buddies)
            {
                List <GameClient> recipiants = new List <GameClient>();
                foreach (GameClient client in GameServer.ConnectedClients)
                {
                    if (client.LoggedIn)
                    {
                        if (!client.LoggedinUser.MuteBuddy && !client.LoggedinUser.MuteAll)
                        {
                            if (client.LoggedinUser.Id != user.Id)
                            {
                                if (client.LoggedinUser.Friends.List.Contains(user.Id))
                                {
                                    if (!client.LoggedinUser.MutePlayer.IsUserMuted(user))
                                    {
                                        recipiants.Add(client);
                                    }
                                }
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Isle)
            {
                List <GameClient> recipiants = new List <GameClient>();
                if (World.InIsle(user.X, user.Y))
                {
                    User[] usersInSile = GameServer.GetUsersInIsle(World.GetIsle(user.X, user.Y), true, false);
                    foreach (User userInIsle in usersInSile)
                    {
                        if (user.Id != userInIsle.Id)
                        {
                            if (!userInIsle.MuteAll && !userInIsle.MuteIsland)
                            {
                                if (!userInIsle.MutePlayer.IsUserMuted(user))
                                {
                                    recipiants.Add(userInIsle.LoggedinClient);
                                }
                            }
                        }
                    }
                    return(recipiants.ToArray());
                }
                else
                {
                    return(new GameClient[0]);
                }
            }

            if (channel == ChatChannel.Here)
            {
                List <GameClient> recipiants = new List <GameClient>();
                User[]            usersHere  = GameServer.GetUsersAt(user.X, user.Y, true, false);
                foreach (User userHere in usersHere)
                {
                    if (user.Id != userHere.Id)
                    {
                        if (!userHere.MuteAll && !userHere.MuteHere)
                        {
                            if (!userHere.MutePlayer.IsUserMuted(user))
                            {
                                recipiants.Add(userHere.LoggedinClient);
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Near)
            {
                List <GameClient> recipiants  = new List <GameClient>();
                User[]            nearbyUsers = GameServer.GetNearbyUsers(user.X, user.Y, true, false);
                foreach (User nearbyUser in nearbyUsers)
                {
                    if (user.Id != nearbyUser.Id)
                    {
                        if (!nearbyUser.MuteAll && !nearbyUser.MuteNear)
                        {
                            if (!nearbyUser.MutePlayer.IsUserMuted(user))
                            {
                                recipiants.Add(nearbyUser.LoggedinClient);
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Mod)
            {
                if (!user.Moderator || !user.Administrator) // No mod chat for non-mods!
                {
                    Logger.WarnPrint(user.Username + " attempted to send in MOD chat, without being a MOD.");
                    return(new GameClient[0]);
                }

                List <GameClient> recipiants = new List <GameClient>();
                foreach (GameClient client in GameServer.ConnectedClients)
                {
                    if (client.LoggedIn)
                    {
                        if (client.LoggedinUser.Moderator)
                        {
                            if (client.LoggedinUser.Id != user.Id)
                            {
                                recipiants.Add(client);
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Admin)
            {
                if (!user.Administrator) // No admin chat for non-admins!
                {
                    Logger.WarnPrint(user.Username + " attempted to send in ADMIN chat, without being an ADMIN.");
                    return(new GameClient[0]);
                }


                List <GameClient> recipiants = new List <GameClient>();
                foreach (GameClient client in GameServer.ConnectedClients)
                {
                    if (client.LoggedIn)
                    {
                        if (client.LoggedinUser.Administrator)
                        {
                            if (client.LoggedinUser.Id != user.Id)
                            {
                                recipiants.Add(client);
                            }
                        }
                    }
                }
                return(recipiants.ToArray());
            }

            if (channel == ChatChannel.Dm)
            {
                if (to != null)
                {
                    List <GameClient> recipiants = new List <GameClient>();
                    foreach (GameClient client in GameServer.ConnectedClients)
                    {
                        if (client.LoggedIn)
                        {
                            if (!client.LoggedinUser.MutePrivateMessage && !client.LoggedinUser.MuteAll)
                            {
                                if (client.LoggedinUser.Username.ToLower() == to.ToLower())
                                {
                                    recipiants.Add(client);
                                }
                            }
                        }
                    }
                    return(recipiants.ToArray());
                }
                else
                {
                    Logger.ErrorPrint("Channel is " + channel + " (DM) BUT no 'to' Paramater was specfied");
                    return(new GameClient[0]);
                }
            }


            Logger.ErrorPrint(user.Username + " Sent message in unknown channel: " + (byte)channel);
            return(new GameClient[0]); // No recipiants
        }
예제 #36
0
 public ChatPacket(string message, ChatChannel chatChannel)
 {
     Message = message;
     ChatChannel = chatChannel;
 }
예제 #37
0
 /// <summary>Send the list of channel members</summary>
 /// <param name="client">the client the outdoing packet belongs to</param>
 /// <param name="chan">channel to be listed</param>
 public static void SendChannelList(IPacketReceiver client, ChatChannel chan)
 {
 }
예제 #38
0
파일: Chat.cs 프로젝트: Illya9999/HISP
        public static string FormatChatForOthers(User user, ChatChannel channel, string message)
        {
            switch (channel)
            {
            case ChatChannel.All:
                if (user.Moderator || user.Administrator)
                {
                    return(Messages.FormatGlobalChatMessageForMod(user.Username, message));
                }
                else
                {
                    return(Messages.FormatGlobalChatMessage(user.Username, message));
                }

            case ChatChannel.Ads:
                return(Messages.FormatAdsChatMessage(user.Username, message));

            case ChatChannel.Buddies:
                return(Messages.FormatBuddyChatMessage(user.Username, message));

            case ChatChannel.Dm:
                if (user.Moderator || user.Administrator)
                {
                    return(Messages.FormatDirectMessageForMod(user.Username, message));
                }
                else
                {
                    return(Messages.FormatDirectMessage(user.Username, message));
                }

            case ChatChannel.Near:
                return(Messages.FormatNearbyChatMessage(user.Username, message));

            case ChatChannel.Isle:
                return(Messages.FormatIsleChatMessage(user.Username, message));

            case ChatChannel.Here:
                return(Messages.FormatHereChatMessage(user.Username, message));

            case ChatChannel.Mod:
                if (user.Moderator || user.Administrator)
                {
                    return(Messages.FormatModChatMessage(user.Username, message));
                }
                else
                {
                    Logger.HackerPrint(user.Username + " Tried to send in mod chat without being a moderator. (Hack/Code Attempt)");
                    return(user.Username + " is a hacker! (Sent in mod channel without being a mod) Maybe ban?");
                }

            case ChatChannel.Admin:
                if (user.Administrator)
                {
                    return(Messages.FormatAdminChatMessage(user.Username, message));
                }
                else
                {
                    Logger.HackerPrint(user.Username + " Tried to send in mod chat without being a moderator. (Hack/Code Attempt)");
                    return(user.Username + " is a hacker! (Sent in admin channel without being a admin) Maybe ban?");
                }

            default:
                Logger.ErrorPrint(user.Username + " is trying to end a message in unknown channel " + channel.ToString("X"));
                return("not implemented yet :(");
            }
        }
예제 #39
0
 public static bool Send(Objects.Client client, ChatChannel channel)
 {
     ChannelClosePacket p = new ChannelClosePacket(client);
     p.ChannelId = channel;
     return p.Send();
 }
예제 #40
0
        public static string ToName(this ChatChannel chatChannel)
        {
            switch (chatChannel)
            {
            case ChatChannel.Say:
                return("Say");

            case ChatChannel.Yell:
                return("Yell");

            case ChatChannel.Shout:
                return("Shout");

            case ChatChannel.Party:
                return("Party");

            case ChatChannel.Alliance:
                return("Alliance");

            case ChatChannel.FreeCompany:
                return("Free Company");

            case ChatChannel.Linkshell1:
                return("Linkshell 1");

            case ChatChannel.Linkshell2:
                return("Linkshell 2");

            case ChatChannel.Linkshell3:
                return("Linkshell 3");

            case ChatChannel.Linkshell4:
                return("Linkshell 4");

            case ChatChannel.Linkshell5:
                return("Linkshell 5");

            case ChatChannel.Linkshell6:
                return("Linkshell 6");

            case ChatChannel.Linkshell7:
                return("Linkshell 7");

            case ChatChannel.Linkshell8:
                return("Linkshell 8");

            case ChatChannel.CrossworldLinkshell1:
                return("Crossworld Linkshell 1");

            case ChatChannel.CrossworldLinkshell2:
                return("Crossworld Linkshell 2");

            case ChatChannel.CrossworldLinkshell3:
                return("Crossworld Linkshell 3");

            case ChatChannel.CrossworldLinkshell4:
                return("Crossworld Linkshell 4");

            case ChatChannel.CrossworldLinkshell5:
                return("Crossworld Linkshell 5");

            case ChatChannel.CrossworldLinkshell6:
                return("Crossworld Linkshell 6");

            case ChatChannel.CrossworldLinkshell7:
                return("Crossworld Linkshell 7");

            case ChatChannel.CrossworldLinkshell8:
                return("Crossworld Linkshell 8");

            case ChatChannel.NoviceNetwork:
                return("Novice Network");

            case ChatChannel.PvPTeam:
                return("PvP Team");
            }

            return("None");
        }
예제 #41
0
        private void ProcessEmote(string text, string name, ChatChannel channel, int? entityId, NetConnection client)
        {
            if (entityId == null)
                return; //No emotes from non-entities!

            var args = new List<string>();

            CommandParsing.ParseArguments(text, args);
            if(_emotes.ContainsKey(args[0]))
            {
                var userText = String.Format(_emotes[args[0]].SelfText, name);//todo user-only channel
                var otherText = String.Format(_emotes[args[0]].OtherText, name, "his"); //todo pronouns, gender
                SendChatMessage(ChatChannel.Emote, otherText, name, entityId);
            }
            else
            {
                //todo Bitch at the user
            }
        }
예제 #42
0
        public static string ToCommand(this ChatChannel chatChannel)
        {
            switch (chatChannel)
            {
            case ChatChannel.Say:
                return("/say");

            case ChatChannel.Yell:
                return("/yell");

            case ChatChannel.Shout:
                return("/shout");

            case ChatChannel.Party:
                return("/party");

            case ChatChannel.Alliance:
                return("/alliance");

            case ChatChannel.FreeCompany:
                return("/freecompany");

            case ChatChannel.Linkshell1:
                return("/linkshell1");

            case ChatChannel.Linkshell2:
                return("/linkshell2");

            case ChatChannel.Linkshell3:
                return("/linkshell3");

            case ChatChannel.Linkshell4:
                return("/linkshell4");

            case ChatChannel.Linkshell5:
                return("/linkshell5");

            case ChatChannel.Linkshell6:
                return("/linkshell6");

            case ChatChannel.Linkshell7:
                return("/linkshell7");

            case ChatChannel.Linkshell8:
                return("/linkshell8");

            case ChatChannel.CrossworldLinkshell1:
                return("/cwlinkshell1");

            case ChatChannel.CrossworldLinkshell2:
                return("/cwlinkshell2");

            case ChatChannel.CrossworldLinkshell3:
                return("/cwlinkshell3");

            case ChatChannel.CrossworldLinkshell4:
                return("/cwlinkshell4");

            case ChatChannel.CrossworldLinkshell5:
                return("/cwlinkshell5");

            case ChatChannel.CrossworldLinkshell6:
                return("/cwlinkshell6");

            case ChatChannel.CrossworldLinkshell7:
                return("/cwlinkshell7");

            case ChatChannel.CrossworldLinkshell8:
                return("/cwlinkshell8");

            case ChatChannel.NoviceNetwork:
                return("/novice");

            case ChatChannel.PvPTeam:
                return("/pvpteam");
            }

            return(string.Empty);
        }
예제 #43
0
        void IncommingChatMessage(ChatChannel channel, string message, string sender)
        {
            if( InvokeRequired )
            {
                Invoke(new MethodInvoker(delegate() { IncommingChatMessage(channel, message, sender); }));
            }
            else
            {
                string formattedMessage = message;
                if( sender != null )
                {
                    formattedMessage = string.Format("[{0}] {1}: {2}", channel.ToString(), sender, message);
                }

                ChatEntry ce = new ChatEntry(channel, formattedMessage);
                _chatEntries.Add(ce);
                FilterChat();
            }
        }
예제 #44
0
    public ChatChannel GetAvailableChannelsMask(bool transmitOnly = true)
    {
        if (IsDeadOrGhost && !IsPlayerSemiGhost)
        {
            ChatChannel ghostTransmitChannels = ChatChannel.Ghost | ChatChannel.OOC;
            ChatChannel ghostReceiveChannels  = ChatChannel.Examine | ChatChannel.System | ChatChannel.Combat |
                                                ChatChannel.Binary | ChatChannel.Command | ChatChannel.Common | ChatChannel.Engineering |
                                                ChatChannel.Medical | ChatChannel.Science | ChatChannel.Security | ChatChannel.Service
                                                | ChatChannel.Supply | ChatChannel.Syndicate;
            if (transmitOnly)
            {
                return(ghostTransmitChannels);
            }
            return(ghostTransmitChannels | ghostReceiveChannels);
        }

        if (IsPlayerSemiGhost)
        {
            ChatChannel blobTransmitChannels = ChatChannel.Blob | ChatChannel.OOC;
            ChatChannel blobReceiveChannels  = ChatChannel.Examine | ChatChannel.System | ChatChannel.Combat;

            if (transmitOnly)
            {
                return(blobTransmitChannels);
            }

            return(blobTransmitChannels | blobReceiveChannels);
        }

        //TODO: Checks if player can speak (is not gagged, unconcious, has no mouth)
        ChatChannel transmitChannels = ChatChannel.OOC | ChatChannel.Local;

        if (CustomNetworkManager.Instance._isServer)
        {
            var playerStorage = gameObject.GetComponent <ItemStorage>();
            if (playerStorage && !playerStorage.GetNamedItemSlot(NamedSlot.ear).IsEmpty)
            {
                Headset headset = playerStorage.GetNamedItemSlot(NamedSlot.ear)?.Item?.GetComponent <Headset>();
                if (headset)
                {
                    EncryptionKeyType key = headset.EncryptionKey;
                    transmitChannels = transmitChannels | EncryptionKey.Permissions[key];
                }
            }
        }
        else
        {
            GameObject earSlotItem = gameObject.GetComponent <ItemStorage>().GetNamedItemSlot(NamedSlot.ear).ItemObject;
            if (earSlotItem)
            {
                Headset headset = earSlotItem.GetComponent <Headset>();
                if (headset)
                {
                    EncryptionKeyType key = headset.EncryptionKey;
                    transmitChannels = transmitChannels | EncryptionKey.Permissions[key];
                }
            }
        }

        ChatChannel receiveChannels = ChatChannel.Examine | ChatChannel.System | ChatChannel.Combat;

        if (transmitOnly)
        {
            return(transmitChannels);
        }

        return(transmitChannels | receiveChannels);
    }
예제 #45
0
 public ChatEntry(ChatChannel channel, string msg)
 {
     Channel = channel;
     Message = msg;
 }
예제 #46
0
    /// For dumb people like me who can't do bitwise. Better cache these
    private static List <ChatChannel> getChannelList(EncryptionKeyType keyType)
    {
        ChatChannel channelMask = Permissions[keyType];

        return(getChannelsByMask(channelMask));
    }
예제 #47
0
 /// <summary>
 /// Send a channel message.
 /// </summary>
 /// <param name="client"></param>
 /// <param name="senderName"></param>
 /// <param name="senderLevel"></param>
 /// <param name="speechType"></param>
 /// <param name="channelId"></param>
 /// <returns></returns>
 public static bool Send(Objects.Client client, string senderName, ushort senderLevel, string message, SpeechType speechType, ChatChannel channelId)
 {
     return Send(client, senderName, senderLevel, message, speechType, channelId, Objects.Location.Invalid, 0);
 }
예제 #48
0
 private bool IsFiltered(ChatChannel channel)
 {
     // _allState works as inverter.
     return(_allState ^ _filteredChannels.HasFlag(channel));
 }
예제 #49
0
 /// <summary>Send the "you have joined channel" reply</summary>
 /// <param name="client">the client the outdoing packet belongs to</param>
 /// <param name="chan">name of channel</param>
 public static void SendYouJoinedReply(IPacketReceiver client, ChatChannel chan)
 {
 }
예제 #50
0
    /// <summary>
    /// Send a Chat Msg from a player to the selected Chat Channels
    /// Server only
    /// </summary>
    public static void AddChatMsgToChat(ConnectedPlayer sentByPlayer, string message, ChatChannel channels)
    {
        message = AutoMod.ProcessChatServer(sentByPlayer, message);
        if (string.IsNullOrWhiteSpace(message))
        {
            return;
        }

        var player = sentByPlayer.Script;

        // The exact words that leave the player's mouth (or that are narrated). Already includes HONKs, stutters, etc.
        // This step is skipped when speaking in the OOC channel.
        (string message, ChatModifier chatModifiers)processedMessage = (string.Empty, ChatModifier.None);          // Placeholder values
        bool isOOC = channels.HasFlag(ChatChannel.OOC);

        if (!isOOC)
        {
            processedMessage = ProcessMessage(sentByPlayer, message);
        }

        var chatEvent = new ChatEvent
        {
            message    = isOOC ? message : processedMessage.message,
            modifiers  = (player == null) ? ChatModifier.None : processedMessage.chatModifiers,
            speaker    = (player == null) ? sentByPlayer.Username : player.name,
            position   = (player == null) ? TransformState.HiddenPos : player.gameObject.AssumedWorldPosServer(),
            channels   = channels,
            originator = sentByPlayer.GameObject
        };

        if (channels.HasFlag(ChatChannel.OOC))
        {
            chatEvent.speaker = sentByPlayer.Username;

            var isAdmin = PlayerList.Instance.IsAdmin(sentByPlayer.UserId);

            if (isAdmin)
            {
                chatEvent.speaker = "<color=red>[Admin]</color> " + chatEvent.speaker;
            }
            else if (PlayerList.Instance.IsMentor(sentByPlayer.UserId))
            {
                chatEvent.speaker = "<color=#6400ff>[Mentor]</color> " + chatEvent.speaker;
            }

            if (Instance.OOCMute && !isAdmin)
            {
                return;
            }

            //http/https links in OOC chat
            if (isAdmin || !GameManager.Instance.AdminOnlyHtml)
            {
                if (htmlRegex.IsMatch(chatEvent.message))
                {
                    var messageParts = chatEvent.message.Split(' ');

                    var builder = new StringBuilder();

                    foreach (var part in messageParts)
                    {
                        if (!htmlRegex.IsMatch(part))
                        {
                            builder.Append(part);
                            builder.Append(" ");
                            continue;
                        }

                        builder.Append($"<link={part}><color=blue>{part}</color></link> ");
                    }

                    chatEvent.message = builder.ToString();

                    //TODO have a config file available to whitelist/blacklist links if all players are allowed to post links
                    //disables client side tag protection to allow <link=></link> tag
                    chatEvent.stripTags = false;
                }
            }

            Instance.addChatLogServer.Invoke(chatEvent);

            //Sends OOC message to a discord webhook
            DiscordWebhookMessage.Instance.AddWebHookMessageToQueue(DiscordWebhookURLs.DiscordWebhookOOCURL, message, chatEvent.speaker, ServerData.ServerConfig.DiscordWebhookOOCMentionsID);

            if (!ServerData.ServerConfig.DiscordWebhookSendOOCToAllChat)
            {
                return;
            }

            //Send it to All chat
            DiscordWebhookMessage.Instance.AddWebHookMessageToQueue(DiscordWebhookURLs.DiscordWebhookAllChatURL, $"[{ChatChannel.OOC}]  {message}\n", chatEvent.speaker);

            return;
        }

        // TODO the following code uses player.playerHealth, but ConciousState would be more appropriate.
        // Check if the player is allowed to talk:
        if (player != null && player.playerHealth != null)
        {
            if (!player.IsDeadOrGhost && player.mind.IsMiming && !processedMessage.chatModifiers.HasFlag(ChatModifier.Emote))
            {
                AddWarningMsgFromServer(sentByPlayer.GameObject, "You can't talk because you made a vow of silence.");
                return;
            }

            if (player.playerHealth.IsCrit || player.playerHealth.IsCardiacArrest)
            {
                if (!player.playerHealth.IsDead)
                {
                    return;
                }
                else
                {
                    chatEvent.channels = ChatChannel.Ghost;
                }
            }
            else if (!player.playerHealth.IsDead && !player.IsGhost)
            {
                //Control the chat bubble
                player.playerNetworkActions.CmdToggleChatIcon(true, processedMessage.message, channels, processedMessage.chatModifiers);
            }
        }

        InvokeChatEvent(chatEvent);
    }
예제 #51
0
    public void PropagateChatToClients(ChatEvent chatEvent)
    {
        List <ConnectedPlayer> players = PlayerList.Instance.AllPlayers;

        //Local chat range checks:
        if (chatEvent.channels.HasFlag(ChatChannel.Local) ||
            chatEvent.channels.HasFlag(ChatChannel.Combat) ||
            chatEvent.channels.HasFlag(ChatChannel.Action))
        {
            for (int i = players.Count - 1; i >= 0; i--)
            {
                if (players[i].Script == null)
                {
                    //joined viewer, don't message them
                    players.RemoveAt(i);
                    continue;
                }

                if (players[i].Script.IsGhost && players[i].Script.IsPlayerSemiGhost == false)
                {
                    //send all to ghosts
                    continue;
                }

                if (chatEvent.position == TransformState.HiddenPos)
                {
                    //show messages with no provided position to everyone
                    continue;
                }

                //Send chat to PlayerChatLocation pos, usually just the player object but for AI is its vessel
                var playerPosition = players[i].Script.PlayerChatLocation.OrNull()?.AssumedWorldPosServer()
                                     ?? players[i].Script.gameObject.AssumedWorldPosServer();

                if (Vector2.Distance(chatEvent.position, playerPosition) > 14f)
                {
                    //Player in the list is too far away for local chat, remove them:
                    players.RemoveAt(i);
                }
                else
                {
                    //within range, but check if they are in another room or hiding behind a wall
                    if (MatrixManager.Linecast(chatEvent.position, LayerTypeSelection.Walls
                                               , layerMask, playerPosition).ItHit)
                    {
                        //if it hit a wall remove that player
                        players.RemoveAt(i);
                    }
                }
            }

            //Get NPCs in vicinity
            var npcs = Physics2D.OverlapCircleAll(chatEvent.position, 14f, npcMask);
            foreach (Collider2D coll in npcs)
            {
                var npcPosition = coll.gameObject.AssumedWorldPosServer();
                if (MatrixManager.Linecast(chatEvent.position, LayerTypeSelection.Walls,
                                           layerMask, npcPosition).ItHit == false)
                {
                    //NPC is in hearing range, pass the message on:
                    var mobAi = coll.GetComponent <MobAI>();
                    if (mobAi != null)
                    {
                        mobAi.LocalChatReceived(chatEvent);
                    }
                }
            }
        }

        for (var i = 0; i < players.Count; i++)
        {
            ChatChannel channels = chatEvent.channels;

            if (channels.HasFlag(ChatChannel.Combat) || channels.HasFlag(ChatChannel.Local) ||
                channels.HasFlag(ChatChannel.System) || channels.HasFlag(ChatChannel.Examine) ||
                channels.HasFlag(ChatChannel.Action))
            {
                //Binary check here to avoid speaking in local when speaking on binary
                if (!channels.HasFlag(ChatChannel.Binary) || (players[i].Script.IsGhost && players[i].Script.IsPlayerSemiGhost == false))
                {
                    UpdateChatMessage.Send(players[i].GameObject, channels, chatEvent.modifiers, chatEvent.message, chatEvent.messageOthers,
                                           chatEvent.originator, chatEvent.speaker, chatEvent.stripTags);

                    continue;
                }
            }

            if (players[i].Script == null)
            {
                channels &= ChatChannel.OOC;
            }
            else
            {
                channels &= players[i].Script.GetAvailableChannelsMask(false);
            }

            //if the mask ends up being a big fat 0 then don't do anything
            if (channels != ChatChannel.None)
            {
                UpdateChatMessage.Send(players[i].GameObject, channels, chatEvent.modifiers, chatEvent.message, chatEvent.messageOthers,
                                       chatEvent.originator, chatEvent.speaker, chatEvent.stripTags);
            }
        }

        if (rconManager != null)
        {
            string name = "";
            if ((namelessChannels & chatEvent.channels) != chatEvent.channels)
            {
                name = "<b>[" + chatEvent.channels + "]</b> ";
            }

            RconManager.AddChatLog(name + chatEvent.message);
        }
    }
예제 #52
0
 /// <summary>Send the "name has left channel" reply to everyone</summary>
 /// <param name="chan">name of channel</param>
 /// <param name="sender">sender (to check the ignore list)</param>
 public static void SendLeftReplyToEveryone(ChatChannel chan, EntityId sender)
 {
 }
예제 #53
0
    /// <summary>
    /// Send a Chat Msg from a player to the selected Chat Channels
    /// Server only
    /// </summary>
    public static void AddChatMsgToChat(ConnectedPlayer sentByPlayer, string message, ChatChannel channels)
    {
        var player = sentByPlayer.Script;


        var chatEvent = new ChatEvent
        {
            message    = message,
            modifiers  = (player == null) ? ChatModifier.None : player.GetCurrentChatModifiers(),
            speaker    = (player == null) ? sentByPlayer.Username : player.name,
            position   = ((player == null) ? Vector2.zero : (Vector2)player.gameObject.transform.position),
            channels   = channels,
            originator = sentByPlayer.GameObject
        };

        if (channels.HasFlag(ChatChannel.OOC))
        {
            chatEvent.speaker = sentByPlayer.Username;
            Instance.addChatLogServer.Invoke(chatEvent);
            return;
        }

        //Check if the player is allowed to talk:
        if (player.playerHealth != null)
        {
            if (player.playerHealth.IsCrit || player.playerHealth.IsCardiacArrest)
            {
                if (!player.playerHealth.IsDead)
                {
                    return;
                }
                else
                {
                    channels = ChatChannel.Ghost;
                }
            }
            else
            {
                if (!player.playerHealth.IsDead && !player.IsGhost)
                {
                    {
                        //Control the chat bubble
                        player.playerNetworkActions.CmdToggleChatIcon(true, message, channels);
                    }
                }
            }
        }

        // There could be multiple channels we need to send a message for each.
        // We do this on the server side that local chans can be determined correctly
        foreach (Enum value in Enum.GetValues(channels.GetType()))
        {
            if (channels.HasFlag((ChatChannel)value))
            {
                //Using HasFlag will always return true for flag at value 0 so skip it
                if ((ChatChannel)value == ChatChannel.None)
                {
                    continue;
                }

                if (IsNamelessChan((ChatChannel)value))
                {
                    continue;
                }

                chatEvent.channels = (ChatChannel)value;
                Instance.addChatLogServer.Invoke(chatEvent);
            }
        }
    }
예제 #54
0
 public override void SendChatMessage(ChatChannel chatChannel, ChatMessage chatMessage) => Logger.LogChatMessage(chatMessage.Sender.Name, chatChannel.Name, chatMessage.Message);