Example #1
0
        public static void OpenStatusBar()
        {
            Client.Game.Scene.Audio.StopWarMusic();

            if (StatusGumpBase.GetStatusGump() == null)
            {
                UIManager.Add(StatusGumpBase.AddStatusGump(100, 100));
            }
        }
Example #2
0
        public List <Gump> ReadGumps(string path)
        {
            List <Gump> gumps = new List <Gump>();


            // #########################################################
            // [FILE_FIX]
            // TODO: this code is a workaround to port old macros to the new xml system.
            string skillsGroupsPath = Path.Combine(path, "skillsgroups.bin");

            if (File.Exists(skillsGroupsPath))
            {
                try
                {
                    using (BinaryReader reader = new BinaryReader(File.OpenRead(skillsGroupsPath)))
                    {
                        int version = reader.ReadInt32();

                        int groupCount = reader.ReadInt32();

                        for (int i = 0; i < groupCount; i++)
                        {
                            int    entriesCount = reader.ReadInt32();
                            string groupName    = reader.ReadUTF8String(reader.ReadInt32());

                            SkillsGroup g = new SkillsGroup();
                            g.Name = groupName;

                            for (int j = 0; j < entriesCount; j++)
                            {
                                byte idx = (byte)reader.ReadInt32();
                                g.Add(idx);
                            }

                            g.Sort();

                            SkillsGroupManager.Add(g);
                        }
                    }
                }
                catch (Exception e)
                {
                    SkillsGroupManager.MakeDefault();
                    Log.Error(e.StackTrace);
                }


                SkillsGroupManager.Save();

                try
                {
                    File.Delete(skillsGroupsPath);
                }
                catch
                {
                }
            }

            string binpath = Path.Combine(path, "gumps.bin");

            if (File.Exists(binpath))
            {
                using (BinaryReader reader = new BinaryReader(File.OpenRead(binpath)))
                {
                    if (reader.BaseStream.Position + 12 < reader.BaseStream.Length)
                    {
                        GumpsVersion = reader.ReadUInt32();
                        uint empty = reader.ReadUInt32();

                        int count = reader.ReadInt32();

                        for (int i = 0; i < count; i++)
                        {
                            try
                            {
                                int    typeLen  = reader.ReadUInt16();
                                string typeName = reader.ReadUTF8String(typeLen);
                                int    x        = reader.ReadInt32();
                                int    y        = reader.ReadInt32();

                                Type type = Type.GetType(typeName, true);
                                Gump gump = (Gump)Activator.CreateInstance(type);
                                gump.Restore(reader);
                                gump.X = x;
                                gump.Y = y;

                                //gump.SetInScreen();

                                if (gump.LocalSerial != 0)
                                {
                                    UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
                                }

                                if (!gump.IsDisposed)
                                {
                                    gumps.Add(gump);
                                }
                            }
                            catch (Exception e)
                            {
                                Log.Error(e.StackTrace);
                            }
                        }
                    }
                }

                SaveGumps(path);

                gumps.Clear();

                try
                {
                    File.Delete(binpath);
                }
                catch
                {
                }
            }
            // #########################################################


            // load skillsgroup
            //SkillsGroupManager.Load();
            SkillsGroupManager.Load();

            // load gumps
            string gumpsXmlPath = Path.Combine(path, "gumps.xml");

            if (File.Exists(gumpsXmlPath))
            {
                XmlDocument doc = new XmlDocument();

                try
                {
                    doc.Load(gumpsXmlPath);
                }
                catch (Exception ex)
                {
                    Log.Error(ex.ToString());

                    return(gumps);
                }

                XmlElement root = doc["gumps"];

                if (root != null)
                {
                    foreach (XmlElement xml in root.ChildNodes /*.GetElementsByTagName("gump")*/)
                    {
                        if (xml.Name != "gump")
                        {
                            continue;
                        }

                        try
                        {
                            GumpType type   = (GumpType)int.Parse(xml.GetAttribute(nameof(type)));
                            int      x      = int.Parse(xml.GetAttribute(nameof(x)));
                            int      y      = int.Parse(xml.GetAttribute(nameof(y)));
                            uint     serial = uint.Parse(xml.GetAttribute(nameof(serial)));

                            Gump gump = null;

                            switch (type)
                            {
                            case GumpType.Buff:
                                gump = new BuffGump();

                                break;

                            case GumpType.Container:
                                gump = new ContainerGump();

                                break;

                            case GumpType.CounterBar:
                                gump = new CounterBarGump();

                                break;

                            case GumpType.HealthBar:
                                if (CustomBarsToggled)
                                {
                                    gump = new HealthBarGumpCustom();
                                }
                                else
                                {
                                    gump = new HealthBarGump();
                                }

                                break;

                            case GumpType.InfoBar:
                                gump = new InfoBarGump();

                                break;

                            case GumpType.Journal:
                                gump = new JournalGump();

                                break;

                            case GumpType.MacroButton:
                                gump = new MacroButtonGump();

                                break;

                            case GumpType.MiniMap:
                                gump = new MiniMapGump();

                                break;

                            case GumpType.PaperDoll:
                                gump = new PaperDollGump();

                                break;

                            case GumpType.SkillMenu:
                                if (StandardSkillsGump)
                                {
                                    gump = new StandardSkillsGump();
                                }
                                else
                                {
                                    gump = new SkillGumpAdvanced();
                                }

                                break;

                            case GumpType.SpellBook:
                                gump = new SpellbookGump();

                                break;

                            case GumpType.StatusGump:
                                gump = StatusGumpBase.AddStatusGump(0, 0);

                                break;

                            //case GumpType.TipNotice:
                            //    gump = new TipNoticeGump();
                            //    break;
                            case GumpType.AbilityButton:
                                gump = new UseAbilityButtonGump();

                                break;

                            case GumpType.SpellButton:
                                gump = new UseSpellButtonGump();

                                break;

                            case GumpType.SkillButton:
                                gump = new SkillButtonGump();

                                break;

                            case GumpType.RacialButton:
                                gump = new RacialAbilityButton();

                                break;

                            case GumpType.WorldMap:
                                gump = new WorldMapGump();

                                break;

                            case GumpType.Debug:
                                gump = new DebugGump(100, 100);

                                break;

                            case GumpType.NetStats:
                                gump = new NetworkStatsGump(100, 100);

                                break;
                            }

                            if (gump == null)
                            {
                                continue;
                            }

                            gump.LocalSerial = serial;
                            gump.Restore(xml);
                            gump.X = x;
                            gump.Y = y;

                            if (gump.LocalSerial != 0)
                            {
                                UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
                            }

                            if (!gump.IsDisposed)
                            {
                                gumps.Add(gump);
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Error(ex.ToString());
                        }
                    }

                    foreach (XmlElement group in root.GetElementsByTagName("anchored_group_gump"))
                    {
                        int matrix_width  = int.Parse(group.GetAttribute("matrix_w"));
                        int matrix_height = int.Parse(group.GetAttribute("matrix_h"));

                        AnchorManager.AnchorGroup ancoGroup = new AnchorManager.AnchorGroup();
                        ancoGroup.ResizeMatrix(matrix_width, matrix_height, 0, 0);

                        foreach (XmlElement xml in group.GetElementsByTagName("gump"))
                        {
                            try
                            {
                                GumpType type   = (GumpType)int.Parse(xml.GetAttribute("type"));
                                int      x      = int.Parse(xml.GetAttribute("x"));
                                int      y      = int.Parse(xml.GetAttribute("y"));
                                uint     serial = uint.Parse(xml.GetAttribute("serial"));

                                int matrix_x = int.Parse(xml.GetAttribute("matrix_x"));
                                int matrix_y = int.Parse(xml.GetAttribute("matrix_y"));

                                AnchorableGump gump = null;

                                switch (type)
                                {
                                case GumpType.SpellButton:
                                    gump = new UseSpellButtonGump();

                                    break;

                                case GumpType.SkillButton:
                                    gump = new SkillButtonGump();

                                    break;

                                case GumpType.HealthBar:
                                    if (CustomBarsToggled)
                                    {
                                        gump = new HealthBarGumpCustom();
                                    }
                                    else
                                    {
                                        gump = new HealthBarGump();
                                    }

                                    break;

                                case GumpType.AbilityButton:
                                    gump = new UseAbilityButtonGump();

                                    break;

                                case GumpType.MacroButton:
                                    gump = new MacroButtonGump();

                                    break;
                                }

                                if (gump != null)
                                {
                                    gump.LocalSerial = serial;
                                    gump.Restore(xml);
                                    gump.X = x;
                                    gump.Y = y;

                                    if (!gump.IsDisposed)
                                    {
                                        if (UIManager.AnchorManager[gump] == null && ancoGroup.IsEmptyDirection(matrix_x, matrix_y))
                                        {
                                            gumps.Add(gump);
                                            UIManager.AnchorManager[gump] = ancoGroup;
                                            ancoGroup.AddControlToMatrix(matrix_x, matrix_y, gump);
                                        }
                                        else
                                        {
                                            gump.Dispose();
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.Error(ex.ToString());
                            }
                        }
                    }
                }
            }

            return(gumps);
        }
Example #3
0
        public List <Gump> ReadGumps(string path)
        {
            List <Gump> gumps = new List <Gump>();

            // load skillsgroup
            SkillsGroupManager.Load();

            // load gumps
            string gumpsXmlPath = Path.Combine(path, "gumps.xml");

            if (File.Exists(gumpsXmlPath))
            {
                XmlDocument doc = new XmlDocument();

                try
                {
                    doc.Load(gumpsXmlPath);
                }
                catch (Exception ex)
                {
                    Log.Error(ex.ToString());

                    return(gumps);
                }

                XmlElement root = doc["gumps"];

                if (root != null)
                {
                    foreach (XmlElement xml in root.ChildNodes /*.GetElementsByTagName("gump")*/)
                    {
                        if (xml.Name != "gump")
                        {
                            continue;
                        }

                        try
                        {
                            GumpType type   = (GumpType)int.Parse(xml.GetAttribute(nameof(type)));
                            int      x      = int.Parse(xml.GetAttribute(nameof(x)));
                            int      y      = int.Parse(xml.GetAttribute(nameof(y)));
                            uint     serial = uint.Parse(xml.GetAttribute(nameof(serial)));

                            Gump gump = null;

                            switch (type)
                            {
                            case GumpType.Buff:
                                gump = new BuffGump();

                                break;

                            case GumpType.Container:
                                gump = new ContainerGump();

                                break;

                            case GumpType.CounterBar:
                                gump = new CounterBarGump();

                                break;

                            case GumpType.HealthBar:
                                if (CustomBarsToggled)
                                {
                                    gump = new HealthBarGumpCustom();
                                }
                                else
                                {
                                    gump = new HealthBarGump();
                                }

                                break;

                            case GumpType.InfoBar:
                                gump = new InfoBarGump();

                                break;

                            case GumpType.Journal:
                                gump = new JournalGump();

                                break;

                            case GumpType.MacroButton:
                                gump = new MacroButtonGump();

                                break;

                            case GumpType.MiniMap:
                                gump = new MiniMapGump();

                                break;

                            case GumpType.PaperDoll:
                                gump = new PaperDollGump();

                                break;

                            case GumpType.SkillMenu:
                                if (StandardSkillsGump)
                                {
                                    gump = new StandardSkillsGump();
                                }
                                else
                                {
                                    gump = new SkillGumpAdvanced();
                                }

                                break;

                            case GumpType.SpellBook:
                                gump = new SpellbookGump();

                                break;

                            case GumpType.StatusGump:
                                gump = StatusGumpBase.AddStatusGump(0, 0);

                                break;

                            //case GumpType.TipNotice:
                            //    gump = new TipNoticeGump();
                            //    break;
                            case GumpType.AbilityButton:
                                gump = new UseAbilityButtonGump();

                                break;

                            case GumpType.SpellButton:
                                gump = new UseSpellButtonGump();

                                break;

                            case GumpType.SkillButton:
                                gump = new SkillButtonGump();

                                break;

                            case GumpType.RacialButton:
                                gump = new RacialAbilityButton();

                                break;

                            case GumpType.WorldMap:
                                gump = new WorldMapGump();

                                break;

                            case GumpType.Debug:
                                gump = new DebugGump(100, 100);

                                break;

                            case GumpType.NetStats:
                                gump = new NetworkStatsGump(100, 100);

                                break;
                            }

                            if (gump == null)
                            {
                                continue;
                            }

                            gump.LocalSerial = serial;
                            gump.Restore(xml);
                            gump.X = x;
                            gump.Y = y;

                            if (gump.LocalSerial != 0)
                            {
                                UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
                            }

                            if (!gump.IsDisposed)
                            {
                                gumps.Add(gump);
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Error(ex.ToString());
                        }
                    }

                    foreach (XmlElement group in root.GetElementsByTagName("anchored_group_gump"))
                    {
                        int matrix_width  = int.Parse(group.GetAttribute("matrix_w"));
                        int matrix_height = int.Parse(group.GetAttribute("matrix_h"));

                        AnchorManager.AnchorGroup ancoGroup = new AnchorManager.AnchorGroup();
                        ancoGroup.ResizeMatrix(matrix_width, matrix_height, 0, 0);

                        foreach (XmlElement xml in group.GetElementsByTagName("gump"))
                        {
                            try
                            {
                                GumpType type   = (GumpType)int.Parse(xml.GetAttribute("type"));
                                int      x      = int.Parse(xml.GetAttribute("x"));
                                int      y      = int.Parse(xml.GetAttribute("y"));
                                uint     serial = uint.Parse(xml.GetAttribute("serial"));

                                int matrix_x = int.Parse(xml.GetAttribute("matrix_x"));
                                int matrix_y = int.Parse(xml.GetAttribute("matrix_y"));

                                AnchorableGump gump = null;

                                switch (type)
                                {
                                case GumpType.SpellButton:
                                    gump = new UseSpellButtonGump();

                                    break;

                                case GumpType.SkillButton:
                                    gump = new SkillButtonGump();

                                    break;

                                case GumpType.HealthBar:
                                    if (CustomBarsToggled)
                                    {
                                        gump = new HealthBarGumpCustom();
                                    }
                                    else
                                    {
                                        gump = new HealthBarGump();
                                    }

                                    break;

                                case GumpType.AbilityButton:
                                    gump = new UseAbilityButtonGump();

                                    break;

                                case GumpType.MacroButton:
                                    gump = new MacroButtonGump();

                                    break;
                                }

                                if (gump != null)
                                {
                                    gump.LocalSerial = serial;
                                    gump.Restore(xml);
                                    gump.X = x;
                                    gump.Y = y;

                                    if (!gump.IsDisposed)
                                    {
                                        if (UIManager.AnchorManager[gump] == null && ancoGroup.IsEmptyDirection(matrix_x, matrix_y))
                                        {
                                            gumps.Add(gump);
                                            UIManager.AnchorManager[gump] = ancoGroup;
                                            ancoGroup.AddControlToMatrix(matrix_x, matrix_y, gump);
                                        }
                                        else
                                        {
                                            gump.Dispose();
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.Error(ex.ToString());
                            }
                        }
                    }
                }
            }

            return(gumps);
        }
Example #4
0
        private int Process(MacroObject macro)
        {
            if (macro == null)
            {
                return(0);
            }

            int result = 0;

            switch (macro.Code)
            {
            case MacroType.Say:
            case MacroType.Emote:
            case MacroType.Whisper:
            case MacroType.Yell:

                MacroObjectString mos = (MacroObjectString)macro;

                if (!string.IsNullOrEmpty(mos.Text))
                {
                    MessageType type = MessageType.Regular;
                    ushort      hue  = Engine.Profile.Current.SpeechHue;

                    switch (macro.Code)
                    {
                    case MacroType.Emote:
                        type = MessageType.Emote;
                        hue  = Engine.Profile.Current.EmoteHue;

                        break;

                    case MacroType.Whisper:
                        type = MessageType.Whisper;
                        hue  = Engine.Profile.Current.WhisperHue;

                        break;

                    case MacroType.Yell:
                        type = MessageType.Yell;

                        break;
                    }

                    GameActions.Say(mos.Text, hue, type);
                }

                break;

            case MacroType.Walk:
                byte dt = (byte)Direction.Up;

                if (macro.SubCode != MacroSubType.NW)
                {
                    dt = (byte)(macro.SubCode - 2);

                    if (dt > 7)
                    {
                        dt = 0;
                    }
                }

                if (!Pathfinder.AutoWalking)
                {
                    World.Player.Walk((Direction)dt, false);
                }

                break;

            case MacroType.WarPeace:
                GameActions.ChangeWarMode();

                break;

            case MacroType.Paste:

                if (SDL.SDL_HasClipboardText() != SDL.SDL_bool.SDL_FALSE)
                {
                    string s = SDL.SDL_GetClipboardText();

                    if (!string.IsNullOrEmpty(s))
                    {
                        Engine.UI.SystemChat.textBox.Text += s;
                    }
                }

                break;

            case MacroType.Open:
            case MacroType.Close:
            case MacroType.Minimize:
            case MacroType.Maximize:

                switch (macro.Code)
                {
                case MacroType.Open:

                    switch (macro.SubCode)
                    {
                    case MacroSubType.Configuration:
                        OptionsGump opt = Engine.UI.GetGump <OptionsGump>();

                        if (opt == null)
                        {
                            Engine.UI.Add(opt = new OptionsGump());
                            opt.SetInScreen();
                        }
                        else
                        {
                            opt.SetInScreen();
                            opt.BringOnTop();
                        }

                        break;

                    case MacroSubType.Paperdoll:
                        GameActions.OpenPaperdoll(World.Player);

                        break;

                    case MacroSubType.Status:

                        if (StatusGumpBase.GetStatusGump() == null)
                        {
                            StatusGumpBase.AddStatusGump(100, 100);
                        }

                        break;

                    case MacroSubType.Journal:
                        JournalGump journalGump = Engine.UI.GetGump <JournalGump>();

                        if (journalGump == null)
                        {
                            Engine.UI.Add(new JournalGump
                            {
                                X = 64, Y = 64
                            });
                        }
                        else
                        {
                            journalGump.SetInScreen();
                            journalGump.BringOnTop();
                        }

                        break;

                    case MacroSubType.Skills:
                        World.SkillsRequested = true;
                        NetClient.Socket.Send(new PSkillsRequest(World.Player));

                        break;

                    case MacroSubType.MageSpellbook:
                    case MacroSubType.NecroSpellbook:
                    case MacroSubType.PaladinSpellbook:
                    case MacroSubType.BushidoSpellbook:
                    case MacroSubType.NinjitsuSpellbook:
                    case MacroSubType.SpellWeavingSpellbook:
                    case MacroSubType.MysticismSpellbook:

                        SpellBookType type = SpellBookType.Magery;

                        switch (macro.SubCode)
                        {
                        case MacroSubType.NecroSpellbook:
                            type = SpellBookType.Necromancy;

                            break;

                        case MacroSubType.PaladinSpellbook:
                            type = SpellBookType.Chivalry;

                            break;

                        case MacroSubType.BushidoSpellbook:
                            type = SpellBookType.Bushido;

                            break;

                        case MacroSubType.NinjitsuSpellbook:
                            type = SpellBookType.Ninjitsu;

                            break;

                        case MacroSubType.SpellWeavingSpellbook:
                            type = SpellBookType.Spellweaving;

                            break;

                        case MacroSubType.MysticismSpellbook:
                            type = SpellBookType.Mysticism;

                            break;

                        case MacroSubType.BardSpellbook:
                            type = SpellBookType.Bardic;

                            break;
                        }

                        NetClient.Socket.Send(new POpenSpellBook((byte)type));

                        break;

                    case MacroSubType.Chat:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;

                    case MacroSubType.Backpack:
                        Item backpack = World.Player.Equipment[(int)Layer.Backpack];

                        if (backpack != null)
                        {
                            GameActions.DoubleClick(backpack);
                        }

                        break;

                    case MacroSubType.Overview:
                        MiniMapGump miniMapGump = Engine.UI.GetGump <MiniMapGump>();

                        if (miniMapGump == null)
                        {
                            Engine.UI.Add(new MiniMapGump());
                        }
                        else
                        {
                            miniMapGump.ToggleSize();
                            miniMapGump.SetInScreen();
                            miniMapGump.BringOnTop();
                        }

                        break;

                    case MacroSubType.WorldMap:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;

                    case MacroSubType.Mail:
                    case MacroSubType.PartyManifest:
                        var party = Engine.UI.GetGump <PartyGumpAdvanced>();

                        if (party == null)
                        {
                            Engine.UI.Add(new PartyGumpAdvanced());
                        }
                        else
                        {
                            party.BringOnTop();
                        }

                        break;

                    case MacroSubType.Guild:
                        GameActions.OpenGuildGump();

                        break;

                    case MacroSubType.QuestLog:
                        GameActions.RequestQuestMenu();

                        break;

                    case MacroSubType.PartyChat:
                    case MacroSubType.CombatBook:
                    case MacroSubType.RacialAbilitiesBook:
                    case MacroSubType.BardSpellbook:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;
                    }

                    break;

                case MacroType.Close:
                case MacroType.Minimize:         // TODO: miniminze/maximize
                case MacroType.Maximize:

                    switch (macro.SubCode)
                    {
                    case MacroSubType.Configuration:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <OptionsGump>()?.Dispose();
                        }

                        break;

                    case MacroSubType.Paperdoll:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <PaperDollGump>()?.Dispose();
                        }

                        break;

                    case MacroSubType.Status:

                        if (macro.Code == MacroType.Close)
                        {
                            StatusGumpBase.GetStatusGump()?.Dispose();
                        }

                        break;

                    case MacroSubType.Journal:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <JournalGump>()?.Dispose();
                        }

                        break;

                    case MacroSubType.Skills:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <SkillGumpAdvanced>()?.Dispose();
                        }

                        break;

                    case MacroSubType.MageSpellbook:
                    case MacroSubType.NecroSpellbook:
                    case MacroSubType.PaladinSpellbook:
                    case MacroSubType.BushidoSpellbook:
                    case MacroSubType.NinjitsuSpellbook:
                    case MacroSubType.SpellWeavingSpellbook:
                    case MacroSubType.MysticismSpellbook:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <SpellbookGump>()?.Dispose();
                        }

                        break;

                    case MacroSubType.Chat:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;

                    case MacroSubType.Overview:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <MiniMapGump>()?.Dispose();
                        }

                        break;

                    case MacroSubType.Mail:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;

                    case MacroSubType.PartyManifest:

                        if (macro.Code == MacroType.Close)
                        {
                            Engine.UI.GetGump <PartyGumpAdvanced>()?.Dispose();
                        }

                        break;

                    case MacroSubType.PartyChat:
                    case MacroSubType.CombatBook:
                    case MacroSubType.RacialAbilitiesBook:
                    case MacroSubType.BardSpellbook:
                        Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");

                        break;
                    }

                    break;
                }

                break;

            case MacroType.OpenDoor:
                GameActions.OpenDoor();

                break;

            case MacroType.UseSkill:
                int skill = macro.SubCode - MacroSubType.Anatomy;

                if (skill >= 0 && skill < 24)
                {
                    skill = _skillTable[skill];

                    if (skill != 0xFF)
                    {
                        GameActions.UseSkill(skill);
                    }
                }

                break;

            case MacroType.LastSkill:
                GameActions.UseSkill(GameActions.LastSkillIndex);

                break;

            case MacroType.CastSpell:
                int spell = macro.SubCode - MacroSubType.Clumsy + 1;

                if (spell > 0 && spell <= 151)
                {
                    int totalCount = 0;
                    int spellType  = 0;

                    for (spellType = 0; spellType < 7; spellType++)
                    {
                        totalCount += _spellsCountTable[spellType];

                        if (spell < totalCount)
                        {
                            break;
                        }
                    }

                    if (spellType < 7)
                    {
                        spell += spellType * 100;

                        if (spellType > 2)
                        {
                            spell += 100;
                        }

                        GameActions.CastSpell(spell);
                    }
                }

                break;

            case MacroType.LastSpell:
                GameActions.CastSpell(GameActions.LastSpellIndex);

                break;

            case MacroType.Bow:
            case MacroType.Salute:
                int index = macro.Code - MacroType.Bow;

                const string BOW    = "bow";
                const string SALUTE = "salute";

                GameActions.EmoteAction(index == 0 ? BOW : SALUTE);

                break;

            case MacroType.QuitGame:
                Engine.SceneManager.GetScene <GameScene>()?.RequestQuitGame();

                break;

            case MacroType.AllNames:
                GameActions.AllNames();

                break;

            case MacroType.LastObject:

                if (World.Get(GameActions.LastObject) != null)
                {
                    GameActions.DoubleClick(GameActions.LastObject);
                }

                break;

            case MacroType.UseItemInHand:
                Item itemInLeftHand = World.Player.Equipment[(int)Layer.OneHanded];
                if (itemInLeftHand != null)
                {
                    GameActions.DoubleClick(itemInLeftHand.Serial);
                }
                else
                {
                    Item itemInRightHand = World.Player.Equipment[(int)Layer.TwoHanded];
                    if (itemInRightHand != null)
                    {
                        GameActions.DoubleClick(itemInRightHand.Serial);
                    }
                }

                break;

            case MacroType.LastTarget:

                //if (WaitForTargetTimer == 0)
                //    WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;

                if (TargetManager.IsTargeting)
                {
                    //if (TargetManager.TargetingState != TargetType.Object)
                    //{
                    //    TargetManager.TargetGameObject(TargetManager.LastGameObject);
                    //}
                    //else
                    TargetManager.TargetGameObject(World.Get(TargetManager.LastTarget));

                    WaitForTargetTimer = 0;
                }
                else if (WaitForTargetTimer < Engine.Ticks)
                {
                    WaitForTargetTimer = 0;
                }
                else
                {
                    result = 1;
                }

                break;

            case MacroType.TargetSelf:

                //if (WaitForTargetTimer == 0)
                //    WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;

                if (TargetManager.IsTargeting)
                {
                    TargetManager.TargetGameObject(World.Player);
                    WaitForTargetTimer = 0;
                }
                else if (WaitForTargetTimer < Engine.Ticks)
                {
                    WaitForTargetTimer = 0;
                }
                else
                {
                    result = 1;
                }

                break;

            case MacroType.ArmDisarm:
                int       handIndex = 1 - (macro.SubCode - MacroSubType.LeftHand);
                GameScene gs        = Engine.SceneManager.GetScene <GameScene>();

                if (handIndex < 0 || handIndex > 1 || gs.IsHoldingItem)
                {
                    break;
                }

                if (_itemsInHand[handIndex] != 0)
                {
                    Item item = World.Items.Get(_itemsInHand[handIndex]);

                    if (item != null)
                    {
                        GameActions.PickUp(item, 1);
                        gs.WearHeldItem(World.Player);
                    }

                    _itemsInHand[handIndex] = 0;
                }
                else
                {
                    Item backpack = World.Player.Equipment[(int)Layer.Backpack];

                    if (backpack == null)
                    {
                        break;
                    }

                    Item item = World.Player.Equipment[(int)Layer.OneHanded + handIndex];

                    if (item != null)
                    {
                        _itemsInHand[handIndex] = item.Serial;

                        GameActions.PickUp(item, 1);
                        GameActions.DropItem(item, Position.INVALID, backpack);
                    }
                }

                break;

            case MacroType.WaitForTarget:

                if (WaitForTargetTimer == 0)
                {
                    WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
                }

                if (TargetManager.IsTargeting || WaitForTargetTimer < Engine.Ticks)
                {
                    WaitForTargetTimer = 0;
                }
                else
                {
                    result = 1;
                }

                break;

            case MacroType.TargetNext:

                if (TargetManager.LastTarget.IsMobile)
                {
                    Mobile mob = World.Mobiles.Get(TargetManager.LastTarget);

                    if (mob == null)
                    {
                        break;
                    }

                    if (mob.HitsMax == 0)
                    {
                        NetClient.Socket.Send(new PStatusRequest(mob));
                    }

                    TargetManager.LastAttack = mob.Serial;
                }

                break;

            case MacroType.AttackLast:
                GameActions.Attack(TargetManager.LastTarget);

                break;

            case MacroType.Delay:
                MacroObjectString mosss = (MacroObjectString)macro;
                string            str   = mosss.Text;

                if (!string.IsNullOrEmpty(str) && int.TryParse(str, out int rr))
                {
                    _nextTimer = Engine.Ticks + rr;
                }

                break;

            case MacroType.CircleTrans:
                Engine.Profile.Current.UseCircleOfTransparency = !Engine.Profile.Current.UseCircleOfTransparency;

                break;

            case MacroType.CloseGump:

                Engine.UI.Gumps
                .Where(s => !(s is TopBarGump) && !(s is BuffGump) && !(s is WorldViewportGump))
                .ToList()
                .ForEach(s => s.Dispose());

                break;

            case MacroType.AlwaysRun:
                Engine.Profile.Current.AlwaysRun = !Engine.Profile.Current.AlwaysRun;
                GameActions.Print($"Always run is now {(Engine.Profile.Current.AlwaysRun ? "on" : "off")}.");

                break;

            case MacroType.SaveDesktop:
                Engine.Profile.Current?.Save(Engine.UI.Gumps.OfType <Gump>().Where(s => s.CanBeSaved).Reverse().ToList());

                break;

            case MacroType.EnableRangeColor:
                Engine.Profile.Current.NoColorObjectsOutOfRange = true;

                break;

            case MacroType.DisableRangeColor:
                Engine.Profile.Current.NoColorObjectsOutOfRange = false;

                break;

            case MacroType.ToggleRangeColor:
                Engine.Profile.Current.NoColorObjectsOutOfRange = !Engine.Profile.Current.NoColorObjectsOutOfRange;

                break;

            case MacroType.AttackSelectedTarget:

                // TODO:
                break;

            case MacroType.UseSelectedTarget:

                // TODO:
                break;

            case MacroType.CurrentTarget:

                // TODO:
                break;

            case MacroType.TargetSystemOnOff:

                // TODO:
                break;

            case MacroType.BandageSelf:
            case MacroType.BandageTarget:

                if (FileManager.ClientVersion < ClientVersions.CV_5020 || Engine.Profile.Current.BandageSelfOld)
                {
                    if (WaitingBandageTarget)
                    {
                        if (WaitForTargetTimer == 0)
                        {
                            WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
                        }

                        if (TargetManager.IsTargeting)
                        {
                            TargetManager.TargetGameObject(macro.Code == MacroType.BandageSelf ? World.Player : World.Mobiles.Get(TargetManager.LastTarget));
                        }
                        else
                        {
                            result = 1;
                        }

                        WaitingBandageTarget = false;
                        WaitForTargetTimer   = 0;
                    }
                    else
                    {
                        var bandage = World.Player.FindBandage();

                        if (bandage != null)
                        {
                            WaitingBandageTarget = true;
                            GameActions.DoubleClick(bandage);
                            result = 1;
                        }
                    }
                }
                else
                {
                    var bandage = World.Player.FindBandage();

                    if (bandage != null)
                    {
                        if (macro.Code == MacroType.BandageSelf)
                        {
                            NetClient.Socket.Send(new PTargetSelectedObject(bandage.Serial, World.Player.Serial));
                        }
                        else
                        {
                            // TODO: NewTargetSystem
                            Log.Message(LogTypes.Warning, "BandageTarget (NewTargetSystem) not implemented yet.");
                        }
                    }
                }

                break;

            case MacroType.SetUpdateRange:
            case MacroType.ModifyUpdateRange:

                if (macro is MacroObjectString moss && !string.IsNullOrEmpty(moss.Text) && byte.TryParse(moss.Text, out byte res))
                {
                    if (res < Constants.MIN_VIEW_RANGE)
                    {
                        res = Constants.MIN_VIEW_RANGE;
                    }
                    else if (res > Constants.MAX_VIEW_RANGE)
                    {
                        res = Constants.MAX_VIEW_RANGE;
                    }

                    World.ClientViewRange = res;

                    GameActions.Print($"ClientViewRange is now {res}.");
                }

                break;

            case MacroType.IncreaseUpdateRange:
                World.ClientViewRange++;

                if (World.ClientViewRange > Constants.MAX_VIEW_RANGE)
                {
                    World.ClientViewRange = Constants.MAX_VIEW_RANGE;
                }

                GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");

                break;

            case MacroType.DecreaseUpdateRange:
                World.ClientViewRange--;

                if (World.ClientViewRange < Constants.MIN_VIEW_RANGE)
                {
                    World.ClientViewRange = Constants.MIN_VIEW_RANGE;
                }
                GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");

                break;

            case MacroType.MaxUpdateRange:
                World.ClientViewRange = Constants.MAX_VIEW_RANGE;
                GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");

                break;

            case MacroType.MinUpdateRange:
                World.ClientViewRange = Constants.MIN_VIEW_RANGE;
                GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");

                break;

            case MacroType.DefaultUpdateRange:
                World.ClientViewRange = Constants.MAX_VIEW_RANGE;
                GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");

                break;

            case MacroType.SelectNext:
            case MacroType.SelectPrevious:
            case MacroType.SelectNearest:
                // TODO:
                int scantype  = macro.SubCode - MacroSubType.Hostile;
                int scanRange = macro.Code - MacroType.SelectNext;


                switch (scanRange)
                {
                case 0:

                    break;

                case 1:

                    break;

                case 2:

                    break;
                }


                break;

            case MacroType.ToggleBuffIconGump:
                BuffGump buff = Engine.UI.GetGump <BuffGump>();

                if (buff != null)
                {
                    buff.Dispose();
                }
                else
                {
                    Engine.UI.Add(new BuffGump(100, 100));
                }

                break;

            case MacroType.InvokeVirtue:
                byte id = (byte)(macro.SubCode - MacroSubType.Honor + 31);
                NetClient.Socket.Send(new PInvokeVirtueRequest(id));

                break;

            case MacroType.PrimaryAbility:
                GameActions.UsePrimaryAbility();

                break;

            case MacroType.SecondaryAbility:
                GameActions.UseSecondaryAbility();

                break;

            case MacroType.ToggleGargoyleFly:

                if (World.Player.Race == RaceType.GARGOYLE)
                {
                    NetClient.Socket.Send(new PToggleGargoyleFlying());
                }

                break;

            case MacroType.EquipLastWeapon:
                NetClient.Socket.Send(new PEquipLastWeapon());

                break;

            case MacroType.KillGumpOpen:
                // TODO:

                break;

            case MacroType.DefaultScale:
                Engine.SceneManager.GetScene <GameScene>().Scale = 1;

                break;

            case MacroType.ToggleChatVisibility:
                Engine.UI.SystemChat?.ToggleChatVisibility();

                break;

            case MacroType.MovePlayer:
                switch (macro.SubCode)
                {
                case MacroSubType.Top:
                    break;

                case MacroSubType.Right:
                    break;

                case MacroSubType.Down:
                    break;

                case MacroSubType.Left:
                    break;
                }

                break;

            case MacroType.Aura:
                // hold to draw
                break;

            case MacroType.AuraOnOff:
                Engine.AuraManager.ToggleVisibility();

                break;

            case MacroType.Grab:
                GameActions.Print("Target an Item to grab it.");
                TargetManager.SetTargeting(CursorTarget.Grab, Serial.INVALID, TargetType.Neutral);

                break;

            case MacroType.SetGrabBag:
                GameActions.Print("Target the container to Grab items into.");
                TargetManager.SetTargeting(CursorTarget.SetGrabBag, Serial.INVALID, TargetType.Neutral);

                break;

            case MacroType.NamesOnOff:
                NameOverHeadManager.ToggleOverheads();

                break;

            case MacroType.UsePotion:
                scantype = macro.SubCode - MacroSubType.ConfusionBlastPotion;

                ushort start = (ushort)(0x0F06 + scantype);

                Item potion = World.Player.FindItemByGraphic(start);
                if (potion != null)
                {
                    GameActions.DoubleClick(potion);
                }

                break;
            }


            return(result);
        }