コード例 #1
0
        void c_ClientChatMessageInfo(object sender, ClientChatMessageEventArgs e)
        {
            Client          c   = (Client)sender;
            ChatMessageInfo cmi = e.Info;

            Client[] nearbyClients = GetNearByClients(c);
            Client   target        = null;

            if (cmi.Type == ChatType.Whisper)
            {
                if (cmi.TargetName != "")
                {
                    target = GetClientByName(cmi.TargetName);
                }
                else
                {
                    target = GetClientByCharacterID(cmi.TargetID);
                }

                if (target != null)
                {
                    cmi.TargetID = target.MyCharacter.CharacterId;
                    byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                    target.Send(bufferSendMessage);
                }
                else
                {
                    cmi.TargetID = 0;
                }

                byte[] bufferSendMessage2 = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                c.Send(bufferSendMessage2);
            }
            else
            {
                if (cmi.Message.StartsWith("!"))
                {
                    cmi.Type    = ChatType.Notice;
                    cmi.Message = cmi.Message.Substring(1);
                }
                byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                SendSpecific(nearbyClients, bufferSendMessage);
            }
        }
コード例 #2
0
        void c_ClientChatMessageInfo(object sender, ClientChatMessageEventArgs e)
        {
            Client c = (Client)sender;
            ChatMessageInfo cmi = e.Info;

            Client[] nearbyClients = GetNearByClients(c);
            Client target = null;

            if (cmi.Type == ChatType.Whisper)
            {
                if (cmi.TargetName != "")
                    target = GetClientByName(cmi.TargetName);
                else
                    target = GetClientByCharacterID(cmi.TargetID);

                if (target != null)
                {
                    cmi.TargetID = target.MyCharacter.CharacterId;
                    byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                    target.Send(bufferSendMessage);
                }
                else
                {
                    cmi.TargetID = 0;
                }

                byte[] bufferSendMessage2 = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                c.Send(bufferSendMessage2);
            }
            else
            {
                if (cmi.Message.StartsWith("!"))
                {
                    cmi.Type = ChatType.Notice;
                    cmi.Message = cmi.Message.Substring(1);
                }
                byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                SendSpecific(nearbyClients, bufferSendMessage);
            }
        }
コード例 #3
0
        void c_ClientChatMessageInfo(object sender, ClientChatMessageEventArgs e)
        {
            Client c = (Client)sender;
            ChatMessageInfo cmi = e.Info;

            MapEngine mapEngine = GetMapEngine(c.MyCharacter.MapId);
            Client[] Clients = GetClientsForChars(mapEngine.GetCharactersInRange(c.MyCharacter.Position, 150).ToArray());
            Client target = null;

            if (cmi.Type == ChatType.Whisper)
            {
                if (cmi.TargetName != "")
                    target = GetClientByName(cmi.TargetName);
                else
                    target = GetClientByCharacterID(cmi.TargetID);

                if (target != null)
                {
                    cmi.TargetID = target.MyCharacter.CharacterId;
                    byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                    target.Send(bufferSendMessage);
                }
                else
                {
                    cmi.TargetID = 0;
                }

                byte[] bufferSendMessage2 = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                c.Send(bufferSendMessage2);
            }
            if (cmi.Type == ChatType.Party)
            {
                if (c.MyCharacter.Party != null)
                {
                    byte[] bufferSendPartyMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                    foreach (Character ch in c.MyCharacter.Party.Members)
                    {
                        Client member = GetClientByCharacterID(ch.CharacterId);
                        if (member != null)
                        {
                            member.Send(bufferSendPartyMessage);
                        }
                    }
                }
            }
            if (cmi.Type == ChatType.General)
            {
                bool send = true;

                // COMMANDS FOR EVERYONE
                if (cmi.Message.StartsWith("."))
                {
                    string command = cmi.Message.Substring(1).ToLower();
                    string[] commands = command.Split(' ');

                    switch (commands[0])
                    {
                        case "add":
                            #region Add stats command
                            send = false;
                            if (commands.Length < 3)
                            {
                                SendCommandHelp("Usage: .add <stat> <amount>", c);
                                SendCommandHelp("Example: .add str 50", c);
                            }
                            else
                            {
                                try
                                {
                                    string stat = commands[1];
                                    short amount = Convert.ToInt16(commands[2]);
                                    if (amount < 0)
                                    {
                                        SendCommandHelp("Cannot input negative values", c);
                                        return;
                                    }
                                    if (amount > c.MyCharacter.StatPoint)
                                    {
                                        SendCommandHelp("Not enought stat points", c);
                                        return;
                                    }

                                    switch (stat)
                                    {
                                        case "str":
                                            c.MyCharacter.Strength += amount;
                                            c.MyCharacter.StatPoint -= amount;
                                            break;

                                        case "dex":
                                            c.MyCharacter.Dexterity += amount;
                                            c.MyCharacter.StatPoint -= amount;
                                            break;

                                        case "sta":
                                            c.MyCharacter.Stamina += amount;
                                            c.MyCharacter.StatPoint -= amount;
                                            break;

                                        case "ene":
                                            c.MyCharacter.Energy += amount;
                                            c.MyCharacter.StatPoint -= amount;
                                            break;

                                        default:
                                            SendCommandHelp("Stats available: str, dex, sta, ene", c);
                                            break;
                                    }

                                    c.Send(PacketManager.SendStats(c.MyCharacter));
                                    characterManager.UpdateCharacter(c.MyCharacter);
                                }
                                catch
                                {
                                }
                            }
                            #endregion
                            break;
                    }
                }

                // GM COMMANDS
                if (cmi.Message.StartsWith("!") && accountManager.IsGM(c.MyCharacter.AccountId))
                {
                    string command = cmi.Message.Substring(1).ToLower();
                    string[] commands = command.Split(' ');

                    switch (commands[0])
                    {
                        case "help":
                            #region Help Command
                            send = false;
                            SendCommandHelp("Commands:", c);
                            SendCommandHelp("! - sends text to everyone in game after !", c);
                            SendCommandHelp("!help - displays all commands", c);
                            SendCommandHelp("!levelup - gives enought exp to level up", c);
                            SendCommandHelp("!sp <value> - gives the amount of statpoints you enter", c);
                            SendCommandHelp("!tp <value> - gives the amount of trainingpoints you enter", c);
                            SendCommandHelp("!kick <player> - kicks the player", c);
                            SendCommandHelp("!goto <player> - warps next to the player", c);
                            #endregion
                            break;

                        case "levelup":
                            #region Levelup Command
                            send = false;
                            c.MyCharacter.CurrentExp += c.MyCharacter.ExpToLevel;
                            c.Send(PacketManager.SendStats(c.MyCharacter));
                            c.Send(PacketManager.SendExperience(c.MyCharacter, (int)c.MyCharacter.ExpToLevel, 0, false, false));
                            characterManager.UpdateCharacter(c.MyCharacter);
                            SendCommandHelp("Kill monster to level up!", c);
                            #endregion
                            break;

                        case "sp":
                            #region Statpoint Command
                            send = false;
                            if (commands.Length < 2)
                            {
                                SendCommandHelp("Usage: !sp <value>", c);
                            }
                            else
                            {
                                try
                                {
                                    short amount = Convert.ToInt16(commands[1]);
                                    if (c.MyCharacter.StatPoint + amount < 0)
                                        c.MyCharacter.StatPoint = 0;
                                    else
                                        c.MyCharacter.StatPoint += (short)amount;

                                    characterManager.UpdateCharacter(c.MyCharacter);
                                    c.Send(PacketManager.SendStats(c.MyCharacter));
                                }
                                catch
                                {
                                    SendCommandHelp("Too large input, max amount of statpoints is 32 500", c);
                                }
                            }
                            #endregion
                            break;

                        case "tp":
                            #region Tp Command
                            send = false;
                            if (commands.Length < 2)
                            {
                                SendCommandHelp("Usage: !tp <value>", c);
                            }
                            else
                            {
                                try
                                {
                                    short amount = Convert.ToInt16(commands[1]);
                                    if (c.MyCharacter.TrainingPoint + amount < 0)
                                        c.MyCharacter.TrainingPoint = 0;
                                    else
                                        c.MyCharacter.TrainingPoint += (short)amount;

                                    characterManager.UpdateCharacter(c.MyCharacter);
                                    c.Send(PacketManager.SendStats(c.MyCharacter));
                                }
                                catch
                                {
                                    SendCommandHelp("Too large input, max amount of tps is 32 500", c);
                                }
                            }
                            #endregion
                            break;

                        case "kick":
                            #region Kick Player Command
                            send = false;
                            if (commands.Length < 2)
                            {
                                SendCommandHelp("Usage: !kick <player>", c);
                            }
                            else
                            {
                                try
                                {
                                    Client tobeKicked = GetClientByName(commands[1]);
                                    if (tobeKicked == null)
                                        SendCommandHelp(string.Format("Player {0} does not exist", commands[1]), c);
                                    else
                                    {
                                        KickPlayer(tobeKicked.MyCharacter.Name);
                                        SendCommandHelp(string.Format("Player {0} has been kicked", commands[1]), c);
                                    }
                                }
                                catch
                                {
                                }
                            }
                            #endregion
                            break;

                        case "goto":
                            #region Goto Command
                            send = false;
                            if (commands.Length < 2)
                            {
                                SendCommandHelp("Usage: !goto <player>", c);
                            }
                            else
                            {
                                try
                                {
                                    Map tomap = null;
                                    Client player = GetClientByName(commands[1]);
                                    if (player != null)
                                    {
                                        if (player.MyCharacter.MapId != 0)
                                            tomap = GetMapEngine(player.MyCharacter.MapId).Map; // its real bead which has mapid etc
                                        else
                                            tomap = GetMapEngine(c.MyCharacter.MapId).Map; // its either town portal scroll or bugged so its win/win for us

                                        Portal tempPort = new Portal
                                        {
                                            ToMapID = tomap.MapID,
                                            ToX = (short)player.MyCharacter.Position.X,
                                            ToY = (short)player.MyCharacter.Position.Y
                                        };

                                        byte[] SendRemoveCharacter = PacketManager.SendRemoveCharacter(c.MyCharacter, RemoveCharacterEffect.Bead);
                                        SendToClients(SendRemoveCharacter, Clients);

                                        c.MyCharacter.Position.X = (short)tempPort.ToX;
                                        c.MyCharacter.Position.Y = (short)tempPort.ToY;
                                        c.MyCharacter.OldMapId = c.MyCharacter.MapId;
                                        c.MyCharacter.MapId = tomap.MapID;

                                        c.MyCharacter.Map = mapEngine.Map;
                                        characterManager.UpdateCharacter(c.MyCharacter);

                                        byte[] SendPortal = PacketManager.SendPortal(tempPort);
                                        c.Send(SendPortal);
                                    }
                                    else
                                        SendCommandHelp(string.Format("Player {0} is not online", commands[1]), c);
                                }
                                catch
                                {
                                }
                            }
                            #endregion
                            break;

                        case "money":
                            #region Money Command
                            send = false;
                            if (commands.Length < 2)
                            {
                                SendCommandHelp("Usage: !money <value>", c);
                            }
                            else
                            {
                                try
                                {
                                    int amount = Convert.ToInt32(commands[1]);
                                    if (c.MyCharacter.Money + amount < 0)
                                        c.MyCharacter.Money = 0;
                                    else
                                        c.MyCharacter.Money += amount;

                                    characterManager.UpdateCharacter(c.MyCharacter);
                                    c.Send(PacketManager.SendMoneyLeft(c.MyCharacter.Money));
                                }
                                catch
                                {
                                    SendCommandHelp("Too large input, max amount of money is 2,000,000,000", c);
                                }
                            }
                            #endregion
                            break;

                        case "random":
                            send = false;
                            SendCommandHelp(string.Format("Random test {0} {1}", XiahRandom.Next(0, 100), XiahRandom.Next(500, 900)), c);
                            break;

                        default:
                            cmi.Type = ChatType.Notice;
                            cmi.Message = string.Format("{0}: {1}", c.MyCharacter.Name, cmi.Message.Substring(1)); break;
                    }
                }

                if (send)
                {
                    byte[] bufferSendMessage = PacketManager.SendChatMessage(c.MyCharacter, cmi);
                    SendToClients(bufferSendMessage, clients.ToArray());
                }
            }
        }