private static void Font(AresClient client, TCPPacketReader packet)
        {
            if (packet.Remaining < 2)
            {
                client.Font = new AresFont();
                return;
            }

            AresFont font = new AresFont();

            font.Enabled  = true;
            font.size     = packet;
            font.FontName = packet.ReadString(client);
            font.oldN     = packet;
            font.oldT     = packet;

            if (packet.Remaining > 0)
            {
                font.NameColor = packet.ReadString(client);
            }

            if (packet.Remaining > 0)
            {
                font.TextColor = packet.ReadString(client);
            }

            if (String.IsNullOrEmpty(font.NameColor))
            {
                font.NameColor = Helpers.AresColorToHTMLColor(font.oldN);
            }

            if (String.IsNullOrEmpty(font.TextColor))
            {
                font.TextColor = Helpers.AresColorToHTMLColor(font.oldT);
            }

            // fonts cannot be bigger than 18
            if (font.size > 18)
            {
                font.size = 18;
            }

            if (!Settings.Get <bool>("fonts_enabled"))
            {
                return;
            }

            client.Font = font;

            if (!client.Quarantined)
            {
                UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.CustomFont(x, client)),
                                             x => x.IsCbot && !x.Quarantined && x.LoggedIn && x.Vroom == client.Vroom);
                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(ib0t.WebOutbound.FontTo(x, client.Name, font.oldN, font.oldT)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);
            }
        }
示例#2
0
        public static byte[] CustomFont(AresClient client, AresClient target)
        {
            TCPPacketWriter packet = new TCPPacketWriter();
            AresFont        f      = (AresFont)target.Font;

            packet.WriteString(client, target.Name);          // user's name + null
            packet.WriteByte(f.size);
            packet.WriteString(client, target.Font.FontName); // null terminated
            packet.WriteByte(f.oldN);
            packet.WriteByte(f.oldT);
            packet.WriteString(client, target.Font.NameColor);
            packet.WriteString(client, target.Font.TextColor);

            byte[] buf = packet.ToAresPacket(TCPMsg.MSG_CHAT_SERVER_CUSTOM_FONT); // id = 204
            packet = new TCPPacketWriter();
            packet.WriteBytes(buf);
            return(packet.ToAresPacket(TCPMsg.MSG_CHAT_ADVANCED_FEATURES_PROTOCOL));
        }
        public static void UncloakedSequence(AresClient client)
        {
            UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.Join(x, client)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

            UserPool.WUsers.ForEachWhere(x => x.QueuePacket(ib0t.WebOutbound.JoinTo(x, client.Name, client.Level)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

            if (client.Avatar.Length > 0)
            {
                UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.Avatar(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.AvatarTo(x, client.Name, client.Avatar)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);
            }

            if (client.PersonalMessage.Length > 0)
            {
                UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.PersonalMessage(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.PersMsgTo(x, client.Name, client.PersonalMessage)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);
            }

            if (client.Font.Enabled)
            {
                UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.CustomFont(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.IsCbot);

                AresFont f = (AresFont)client.Font;
                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.FontTo(x, client.Name, f.oldN, f.oldT)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);
            }

            if (client.VoiceChatPrivate || client.VoiceChatPublic)
            {
                UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.VoiceChatUserSupport(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && (x.VoiceChatPrivate || x.VoiceChatPublic) && !x.Quarantined);
            }
        }
示例#4
0
        public static byte[] Font(AresFont f)
        {
            StringBuilder sb = new StringBuilder("{");

            sb.Append("\"isEmote\":" + f.IsEmote.ToString().ToLower());

            if (!String.IsNullOrEmpty(f.NameColor))
            {
                sb.Append(",\"nc\":\"" + f.NameColor + "\"");
            }
            else
            {
                sb.Append(",\"nc\":\"\"");
            }

            if (!String.IsNullOrEmpty(f.TextColor))
            {
                sb.Append(",\"tc\":\"" + f.TextColor + "\"");
            }
            else
            {
                sb.Append(",\"tc\":\"\"");
            }

            if (!String.IsNullOrEmpty(f.FontName))
            {
                sb.Append(",\"ff\":\"" + f.FontName + "\"");
            }
            else
            {
                sb.Append(",\"ff\":\"\"");
            }

            sb.Append("}");

            String html = "<input type=\"hidden\" value=\"" + Uri.EscapeDataString(sb.ToString()) + "\" />";

            return(HTML(html));
        }
        public static void FakeRejoinSequence(ib0t.ib0tClient client, bool features)
        {
            if (!client.Cloaked)
            {
                LinkLeaf.LinkUser other = null;

                if (ServerCore.Linker.Busy)
                {
                    foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                    {
                        other = leaf.Users.Find(x => x.Vroom == client.Vroom && x.Name == client.Name && x.Link.Visible);

                        if (other != null)
                        {
                            other.LinkCredentials.Visible = false;
                            break;
                        }
                    }
                }

                UserPool.AUsers.ForEachWhere(x => x.SendPacket(other == null ? TCPOutbound.Join(x, client) : TCPOutbound.UpdateUserStatus(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(other == null ? ib0t.WebOutbound.JoinTo(x, client.Name, client.Level) : ib0t.WebOutbound.UpdateTo(x, client.Name, client.Level)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);
            }

            client.LoggedIn = true;
            client.QueuePacket(WebOutbound.AckTo(client, client.Name));
            client.QueuePacket(WebOutbound.UserlistItemTo(client, Settings.Get <String>("bot"), ILevel.Host));

            UserPool.AUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.UserlistItemTo(client, x.Name, x.Level)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            UserPool.WUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.UserlistItemTo(client, x.Name, x.Level)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            UserPool.AUsers.ForEachWhere(x =>
            {
                AresFont f = (AresFont)x.Font;
                client.QueuePacket(ib0t.WebOutbound.FontTo(client, x.Name, f.oldN, f.oldT));
            }, x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Font.Enabled);

            if (ServerCore.Linker.Busy)
            {
                foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                {
                    leaf.Users.ForEachWhere(x => client.QueuePacket(WebOutbound.UserlistItemTo(client, x.Name, x.Level)),
                                            x => x.Vroom == client.Vroom && x.Link.Visible);
                }
            }

            client.QueuePacket(WebOutbound.UserlistEndTo(client));

            if (features)
            {
                client.QueuePacket(WebOutbound.UrlTo(client, Settings.Get <String>("link", "url"), Settings.Get <String>("text", "url")));
            }

            if (client.Extended)
            {
                client.QueuePacket(WebOutbound.PerMsgBotTo(client));
                client.QueuePacket(Avatars.Server(client));

                UserPool.AUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.AvatarTo(client, x.Name, x.Avatar)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && x.Avatar.Length > 0 && !x.Cloaked && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.AvatarTo(client, x.Name, x.Avatar)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

                if (ServerCore.Linker.Busy)
                {
                    foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                    {
                        leaf.Users.ForEachWhere(x => client.QueuePacket(WebOutbound.AvatarTo(client, x.Name, x.Avatar)),
                                                x => x.Vroom == client.Vroom && x.Link.Visible && x.Avatar.Length > 0);
                    }
                }

                UserPool.AUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.PersMsgTo(client, x.Name, x.PersonalMessage)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && x.PersonalMessage.Length > 0 && !x.Cloaked && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => client.QueuePacket(WebOutbound.PersMsgTo(client, x.Name, x.PersonalMessage)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

                if (ServerCore.Linker.Busy)
                {
                    foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                    {
                        leaf.Users.ForEachWhere(x => client.QueuePacket(WebOutbound.PersMsgTo(client, x.Name, x.PersonalMessage)),
                                                x => x.Vroom == client.Vroom && x.Link.Visible && x.PersonalMessage.Length > 0);
                    }
                }
            }

            if (client.Avatar.Length > 0)
            {
                if (!client.Cloaked)
                {
                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.Avatar(x, client)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.AvatarTo(x, client.Name, client.Avatar)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);

                    if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                    {
                        ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafAvatar(ServerCore.Linker, client));
                    }
                }
            }

            if (!String.IsNullOrEmpty(client.PersonalMessage))
            {
                if (!client.Cloaked)
                {
                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.PersonalMessage(x, client)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.PersMsgTo(x, client.Name, client.PersonalMessage)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);

                    if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                    {
                        ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafPersonalMessage(ServerCore.Linker, client));
                    }
                }
            }

            if (features)
            {
                if (client.SocketConnected)
                {
                    IdleManager.Set(client);
                }

                Events.Joined(client);
            }
        }
        public static void FakeRejoinSequence(AresClient client, bool features)
        {
            if (!client.Cloaked)
            {
                LinkLeaf.LinkUser other = null;

                if (ServerCore.Linker.Busy)
                {
                    foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                    {
                        other = leaf.Users.Find(x => x.Vroom == client.Vroom && x.Name == client.Name && x.Link.Visible);

                        if (other != null)
                        {
                            other.LinkCredentials.Visible = false;
                            break;
                        }
                    }
                }

                UserPool.AUsers.ForEachWhere(x => x.SendPacket(other == null ? TCPOutbound.Join(x, client) : TCPOutbound.UpdateUserStatus(x, client)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                UserPool.WUsers.ForEachWhere(x => x.QueuePacket(other == null ? ib0t.WebOutbound.JoinTo(x, client.Name, client.Level) : ib0t.WebOutbound.UpdateTo(x, client.Name, client.Level)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);
            }

            client.SharedFiles.Clear();
            client.LoggedIn = true;
            client.SendPacket(TCPOutbound.Ack(client));

            if (features)
            {
                client.SendPacket(TCPOutbound.MyFeatures(client));
                client.SendPacket(TCPOutbound.FavIcon());
            }

            client.SendPacket(TCPOutbound.UserlistBot(client));

            UserPool.AUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.Userlist(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            UserPool.WUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.Userlist(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            if (ServerCore.Linker.Busy)
            {
                foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                {
                    leaf.Users.ForEachWhere(x => client.SendPacket(TCPOutbound.Userlist(client, x)),
                                            x => x.Vroom == client.Vroom && x.Link.Visible);
                }
            }

            client.SendPacket(TCPOutbound.UserListEnd());
            client.SendPacket(TCPOutbound.OpChange(client));

            if (features)
            {
                client.SendPacket(TCPOutbound.SupportsVoiceClips());
                client.SendPacket(TCPOutbound.Url(client, Settings.Get <String>("link", "url"), Settings.Get <String>("text", "url")));
            }

            client.SendPacket(Avatars.Server(client));
            client.SendPacket(TCPOutbound.PersonalMessageBot(client));

            if (client.CustomClient)
            {
                UserPool.AUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.VoiceChatUserSupport(client, x)),
                                             x => (x.VoiceChatPrivate || x.VoiceChatPublic) && !x.Cloaked && !x.Quarantined);
            }

            UserPool.AUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.Avatar(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && x.Avatar.Length > 0 && !x.Cloaked && !x.Quarantined);

            UserPool.WUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.Avatar(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            if (ServerCore.Linker.Busy)
            {
                foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                {
                    leaf.Users.ForEachWhere(x => client.SendPacket(TCPOutbound.Avatar(client, x)),
                                            x => x.Vroom == client.Vroom && x.Link.Visible && x.Avatar.Length > 0);
                }
            }

            UserPool.AUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.PersonalMessage(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && x.PersonalMessage.Length > 0 && !x.Cloaked && !x.Quarantined);

            UserPool.WUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.PersonalMessage(client, x)),
                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.Cloaked && !x.Quarantined);

            if (client.IsCbot)
            {
                UserPool.AUsers.ForEachWhere(x => client.SendPacket(TCPOutbound.CustomFont(client, x)),
                                             x => x.LoggedIn && x.Vroom == client.Vroom && x.Font.Enabled);
            }

            if (ServerCore.Linker.Busy)
            {
                foreach (LinkLeaf.Leaf leaf in ServerCore.Linker.Leaves)
                {
                    leaf.Users.ForEachWhere(x => client.SendPacket(TCPOutbound.PersonalMessage(client, x)),
                                            x => x.Vroom == client.Vroom && x.Link.Visible && x.PersonalMessage.Length > 0);
                }
            }

            if (client.Avatar.Length > 0)
            {
                if (!client.Cloaked)
                {
                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.Avatar(x, client)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.AvatarTo(x, client.Name, client.Avatar)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);

                    if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                    {
                        ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafAvatar(ServerCore.Linker, client));
                    }
                }
            }

            if (!String.IsNullOrEmpty(client.PersonalMessage))
            {
                if (!client.Cloaked)
                {
                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.PersonalMessage(x, client)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);

                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.PersMsgTo(x, client.Name, client.PersonalMessage)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.Extended);

                    if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                    {
                        ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafPersonalMessage(ServerCore.Linker, client));
                    }
                }
            }

            if (client.Font.Enabled)
            {
                if (!client.Cloaked)
                {
                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.CustomFont(x, client)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined && x.IsCbot);

                    AresFont f = (AresFont)client.Font;
                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(WebOutbound.FontTo(x, client.Name, f.oldN, f.oldT)),
                                                 x => x.LoggedIn && x.Vroom == client.Vroom && !x.Quarantined);
                }
            }

            if (features)
            {
                if (client.SocketConnected)
                {
                    IdleManager.Set(client);
                }

                Events.Joined(client);
            }
        }
示例#7
0
        private static void Emote(AresClient client, TCPPacketReader packet)
        {
            if (!client.Captcha)
            {
                return;
            }

            String text = packet.ReadString(client);

            if (text.Length > 300)
            {
                text = text.Substring(0, 300);
            }

            Events.EmoteReceived(client, text);

            if (client.SocketConnected)
            {
                text = Events.EmoteSending(client, text);

                if (!String.IsNullOrEmpty(text) && client.SocketConnected && !client.Muzzled)
                {
                    if (client.Idled)
                    {
                        uint seconds_away = (uint)((Time.Now - client.IdleStart) / 1000);
                        IdleManager.Remove(client);
                        Events.Unidled(client, seconds_away);
                    }

                    if (client.SocketConnected)
                    {
                        if (text.StartsWith("idles"))
                        {
                            if (!IdleManager.CheckIfCanIdle(client))
                            {
                                return;
                            }
                            IdleManager.Add(client);
                            Events.Idled(client);
                        }

                        if (client.SocketConnected)
                        {
                            byte[]   js_style = null;
                            AresFont font     = (AresFont)client.Font;

                            if (font.Enabled)
                            {
                                font.IsEmote = true;
                                js_style     = TCPOutbound.Font(font);
                            }

                            UserPool.AUsers.ForEachWhere(x =>
                            {
                                if (x.SupportsHTML && x.Ares)
                                {
                                    if (js_style != null)
                                    {
                                        x.SendPacket(js_style);
                                    }
                                }

                                x.SendPacket(TCPOutbound.Emote(x, client.Name, text));
                            },
                                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.IgnoreList.Contains(client.Name) && !x.Quarantined);

                            UserPool.WUsers.ForEachWhere(x => x.QueuePacket(ib0t.WebOutbound.EmoteTo(x, client.Name, text)),
                                                         x => x.LoggedIn && x.Vroom == client.Vroom && !x.IgnoreList.Contains(client.Name) && !x.Quarantined);

                            if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                            {
                                ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafEmoteText(ServerCore.Linker, client.Name, text));
                            }

                            Events.EmoteSent(client, text);
                        }
                    }
                }
            }
        }
示例#8
0
        private static void Public(AresClient client, TCPPacketReader packet)
        {
            String text = packet.ReadString(client);

            if (text.Length > 300)
            {
                text = text.Substring(0, 300);
            }

            if (text.StartsWith("#login") || text.StartsWith("#register"))
            {
                Command(client, text.Substring(1));
                return;
            }

            if (text.StartsWith("#") && client.SocketConnected)
            {
                Command(client, text.Substring(1));
            }

            if (client.SocketConnected)
            {
                if (!client.Captcha)
                {
                    if (String.IsNullOrEmpty(client.CaptchaWord) || (client.CaptchaWord.Length > 0 && client.CaptchaWord.ToUpper() != Helpers.StripColors(text).Trim().ToUpper()))
                    {
                        if (client.CaptchaWord.Length > 0 && client.CaptchaWord.ToUpper() != Helpers.StripColors(text).Trim().ToUpper())
                        {
                            Events.CaptchaReply(client, text);

                            if (!client.SocketConnected)
                            {
                                return;
                            }
                        }

                        CaptchaItem cap = Captcha.Create();
                        client.CaptchaWord = cap.Word;
                        Events.CaptchaSending(client);
                        client.SendPacket(TCPOutbound.NoSuch(client, String.Empty));

                        foreach (String str in cap.Lines)
                        {
                            client.SendPacket(TCPOutbound.NoSuch(client, str));
                        }

                        client.SendPacket(TCPOutbound.NoSuch(client, String.Empty));
                        return;
                    }
                    else
                    {
                        client.Captcha = true;
                        Events.CaptchaReply(client, text);
                        CaptchaManager.AddCaptcha(client);

                        if (client.Quarantined)
                        {
                            client.Unquarantine();
                        }

                        return;
                    }
                }
                else
                {
                    Events.TextReceived(client, text);
                }
            }
            else
            {
                return;
            }

            if (client.SocketConnected)
            {
                text = Events.TextSending(client, text);

                if (!String.IsNullOrEmpty(text) && client.SocketConnected && !client.Muzzled)
                {
                    if (client.Idled)
                    {
                        uint seconds_away = (uint)((Time.Now - client.IdleStart) / 1000);
                        IdleManager.Remove(client);
                        Events.Unidled(client, seconds_away);
                    }

                    if (client.SocketConnected)
                    {
                        byte[]   js_style = null;
                        AresFont font     = (AresFont)client.Font;

                        if (font.Enabled)
                        {
                            font.IsEmote = !String.IsNullOrEmpty(client.CustomName);
                            js_style     = TCPOutbound.Font(font);
                        }

                        UserPool.AUsers.ForEachWhere(x =>
                        {
                            if (x.SupportsHTML && x.Ares)
                            {
                                if (String.IsNullOrEmpty(client.CustomName) || x.BlockCustomNames)
                                {
                                    if (x.SupportsHTML)
                                    {
                                        if (js_style != null)
                                        {
                                            x.SendPacket(js_style);
                                        }
                                    }

                                    x.SendPacket(TCPOutbound.Public(x, client.Name, text));
                                }
                                else
                                {
                                    if (x.SupportsHTML)
                                    {
                                        if (js_style != null)
                                        {
                                            x.SendPacket(js_style);
                                        }
                                    }

                                    x.SendPacket(TCPOutbound.NoSuch(x, client.CustomName + text));
                                }
                            }
                            else
                            {
                                if (String.IsNullOrEmpty(client.CustomName) || x.BlockCustomNames)
                                {
                                    x.SendPacket(TCPOutbound.Public(x, client.Name, text));
                                }
                                else
                                {
                                    x.SendPacket(TCPOutbound.NoSuch(x, client.CustomName + text));
                                }
                            }
                        },
                                                     x => x.LoggedIn && x.Vroom == client.Vroom && !x.IgnoreList.Contains(client.Name) && !x.Quarantined);

                        UserPool.WUsers.ForEachWhere(x => x.QueuePacket(String.IsNullOrEmpty(client.CustomName) ?
                                                                        ib0t.WebOutbound.PublicTo(x, client.Name, text) : ib0t.WebOutbound.NoSuchTo(x, client.CustomName + text)),
                                                     x => x.LoggedIn && x.Vroom == client.Vroom && !x.IgnoreList.Contains(client.Name) && !x.Quarantined);

                        if (ServerCore.Linker.Busy && ServerCore.Linker.LoginPhase == LinkLeaf.LinkLogin.Ready)
                        {
                            ServerCore.Linker.SendPacket(LinkLeaf.LeafOutbound.LeafPublicText(ServerCore.Linker, client.Name, text));
                        }

                        Events.TextSent(client, text);
                    }
                }
            }
        }
示例#9
0
        private void ParseFont()
        {
            try
            {
                String _font = this.current_item.QueryString["f"];
                String _name = this.current_item.QueryString["n"];

                if (!String.IsNullOrEmpty(_font) && !String.IsNullOrEmpty(_name))
                {
                    String[] split = _font.Split(new String[] { "\0" }, StringSplitOptions.RemoveEmptyEntries);

                    if (split.Length >= 2)
                    {
                        String font_family = split[0];
                        String font_color  = split[1];
                        String name        = Encoding.UTF8.GetString(Convert.FromBase64String(_name));
                        name = Uri.UnescapeDataString(name);
                        AresClient target = UserPool.AUsers.Find(x => x.LoggedIn && x.Name.Equals(name) && x.SocketAddr.Equals(this.SocketAddr));

                        if (target != null)
                        {
                            AresFont f = new AresFont();
                            f.size      = 10;
                            f.Enabled   = true;
                            f.FontName  = font_family;
                            f.TextColor = font_color;

                            if (split.Length >= 3)
                            {
                                f.NameColor = split[2];
                            }
                            else
                            {
                                f.NameColor = "#000000";
                            }

                            if (f.FontName.ToUpper().Contains("VERDANA") && f.TextColor.Contains("000000"))
                            {
                                f.Enabled = false;
                            }

                            if (f.Enabled)
                            {
                                f.oldN      = Helpers.HTMLColorToAresColor(f.NameColor);
                                f.oldT      = Helpers.HTMLColorToAresColor(f.TextColor);
                                target.Font = f;

                                if (!target.Quarantined)
                                {
                                    UserPool.AUsers.ForEachWhere(x => x.SendPacket(TCPOutbound.CustomFont(x, target)),
                                                                 x => x.IsCbot && !x.Quarantined && x.LoggedIn && x.Vroom == target.Vroom && !x.Quarantined);
                                    UserPool.WUsers.ForEachWhere(x => x.QueuePacket(ib0t.WebOutbound.FontTo(x, target.Name, f.oldN, f.oldT)),
                                                                 x => x.LoggedIn && x.Vroom == target.Vroom && !x.Quarantined);
                                }
                            }
                        }
                    }
                }
            }
            catch { }
        }