{c#} Use a Runebook in Stealth

[epsilon2]

Any Direction You want to drive me through?

regards,

[rwo001]

Code: [Select]

using System;
using ScriptSDK.Items;
using ScriptSDK.API;
using ScriptSDK.Data;
using ScriptSDK.Engines;
using ScriptSDK.Gumps;

namespace ScriptSDK.Items
{
    [QuerySearch(new ushort[] { 0x22C5 })]
    public class RuneBook : Item
    {
        private ushort _point;

        public RuneBook(Serial serial)
            : base(serial)
        {
            this.UpdateLocalizedProperties();
            this._point = 0;
        }

        public RuneBook(uint ObjectID) : base(ObjectID)
        {
            this.UpdateLocalizedProperties();
            this._point = 0;
        }

        public string Name
        {
            get
            {

                var n = ClilocHelper.GetParams(this.Properties, 1070722);
                if (n.Count > 0)
                    return n[0];
                else
                    return "";
            }
        }

        public bool Exceptional
        {
            get
            {
                if (ClilocHelper.GetIndex(this.Properties, 1060636) > -1)
                    return true;
                else
                    return false;

            }
        }

        public string CraftedBy
        {
            get
            {
                var n = ClilocHelper.GetParams(this.Properties, 1050043);
                if (n.Count > 0) return n[0]; else return "";
            }
        }

        public bool Open(double MaxDelay = 2000)
        {
            DateTime dateTime = DateTime.UtcNow.AddMilliseconds(MaxDelay);
            this.DoubleClick();
            Stealth.Client.Wait(1000);
            do
            {
                for (ushort i = 0; i < GumpHelper.Count(); i++)
                {
                    if (Stealth.Client.GetGumpSerial(i).Equals(this.Serial.Value))
                    {
                        return true;
                    }
                }


            } while (DateTime.UtcNow < dateTime);
            return false;
        }

        public bool Next()
        {
            this._point = (ushort)(this._point + 1);
            if (this._point > 16) { this._point = 1; }
            Console.WriteLine("Go to Point " + this._point);
            return this.Recall(this._point);
        }

        public bool Recall(ushort Point, double MaxDelay = 5000)
        {
            DateTime dateTime = DateTime.UtcNow.AddMilliseconds(MaxDelay);

            int CurX = Stealth.Client.GetX(Stealth.Client.GetSelfID());
            int CurY = Stealth.Client.GetY(Stealth.Client.GetSelfID());

            if (this.Open() == false) { return false; }

            GumpHelper.SendClick(this.Serial, 49 + Point); // Start From 50
            do
            {
                Console.WriteLine("Going...");
                Stealth.Client.Wait(500);
                if (dateTime < DateTime.UtcNow) { return false; }
            } while (Stealth.Client.GetX(Stealth.Client.GetSelfID()) == CurX &&
                     Stealth.Client.GetY(Stealth.Client.GetSelfID()) == CurY);

            return true;
        }
    }
}


Not completed...just do for what i need...

[Crome969]

Code: [Select]


//*******************************************************************
//* Class           : Runebook.cs
//* Author          : Jan Siems
//* Last Update     : 01.10.15
//*******************************************************************

using System;
using System.Collections.Generic;
using System.Linq;
using ScriptSDK;
using ScriptSDK.API;
using ScriptSDK.Data;
using ScriptSDK.Engines;
using ScriptSDK.Gumps;
using ScriptSDK.Items;
using XScript.Extensions;
using XScript.Interfaces;

namespace XScript.Items
{

    public class RunebookEntry
    {
        public Runebook _owner { get; private set; }

        public string Name { get; private set; }
        public string Location { get; private set; }
        public uint Hue { get; private set; }
        public int DefaultButton { get; private set; }
        public int DropButton { get; private set; }
        public int Gatebutton { get; private set; }
        public int SacredButton { get; private set; }
        public int RecallButton { get; private set; }
        public int ScrollButton { get; private set; }

        public RunebookEntry(Runebook owner, string name, string position, uint color, int def, int drop, int gate, int sacred, int recall, int scroll)
        {
            _owner = owner;
            Name = name;
            Location = position;
            Hue = color;
            DefaultButton = def;
            DropButton = drop;
            Gatebutton = gate;
            SacredButton = sacred;
            RecallButton = recall;
            ScrollButton = scroll;
        }
    }

    [QuerySearch(0x22C5)]
    public class Runebook : Item, ICraftable
    {
        #region Vars
        private Gump _lastparsedgump;
        public int DefaultRune { get; protected set; }

        private int _renamebutton;
        #endregion

        #region Triggers

        public override int DefaultLabelNumber
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 1041267;
                    case ShardEngine.RebirthUO:
                        return 1041267;
                }
                return 0;
            }
        }

        public uint GumpType
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 0x0059;
                    case ShardEngine.RebirthUO:
                        return 0x554B87F3;
                }
                return 0;
            }
        }

        public int BaseScrollOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 10;
                    case ShardEngine.RebirthUO:
                        return 2;
                }
                return 0;
            }
        }

        public int BaseDropOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 200;
                    case ShardEngine.RebirthUO:
                        return 3;
                }
                return 0;
            }
        }

        public int BaseSetDefaultOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 300;
                    case ShardEngine.RebirthUO:
                        return 4;
                }
                return 0;
            }
        }

        public int BaseRecallOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 50;
                    case ShardEngine.RebirthUO:
                        return 5;
                }
                return 0;
            }
        }

        public int BaseGateOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 100;
                    case ShardEngine.RebirthUO:
                        return 6;
                }
                return 0;
            }
        }

        public int BaseSacredOffset
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 75;
                    case ShardEngine.RebirthUO:
                        return 7;
                }
                return 0;
            }
        }

        public int Jumper
        {
            get
            {
                switch (XConfig.Engine)
                {
                    case ShardEngine.Broadsword:
                        return 1;
                    case ShardEngine.RebirthUO:
                        return 6;
                }
                return 0;
            }
        }
        #endregion

        #region Constructors
        public Runebook(Serial serial)
            : base(serial)
        {
            CurCharges = -1;
            MaxCharges = -1;
        }
        public Runebook(uint objectID)
            : this(new Serial(objectID))
        {
        }
        #endregion

        #region Properties
        public bool Exceptional
        {
            get { return this.ReadIsExceptionalState(Properties); }
        }

        public string Crafter
        {
            get { return this.ReadCrafterName(Properties); }
        }

        public string Description
        {
            get { return this.ReadDescription(Properties); }
        }

        public List<RunebookEntry> Entries { get; private set; }

        public int CurCharges { get; private set; }

        public int MaxCharges { get; private set; }
        #endregion

        #region Functions

        protected virtual bool ParseGump(Gump g)
        {
            CurCharges = -1;
            MaxCharges = -1;
            Entries = new List<RunebookEntry>();
            _renamebutton = -1;
            DefaultRune = -1;
            _lastparsedgump = null;
            if (g.GumpType.Equals(GumpType))
            {
                _lastparsedgump = g;
                //Charges
                int Value;
                int.TryParse(g.HTMLTexts[0].Text, out Value);
                CurCharges = Value;
                int.TryParse(g.HTMLTexts[1].Text, out Value);
                MaxCharges = Value;


                var rButton = g.Buttons.First(e => e.Graphic.Released.Equals(2472) || e.Graphic.Pressed.Equals(2473));
                if (rButton != null)
                {
                    //Rename Button
                    _renamebutton = g.Buttons.First(e => e.Graphic.Released.Equals(2472) || e.Graphic.Pressed.Equals(2473)).PacketValue;
                }

                rButton = g.Buttons.FirstOrDefault(e => e.Graphic.Released.Equals(2360) || e.Graphic.Pressed.Equals(2360));
                if (rButton != null)
                {
                    // Highlighted Rune :
                    DefaultRune = (rButton.PacketValue / BaseSetDefaultOffset) + 1;
                }



                //Entries
                for (var i = 0; i < 15; i++)
                {
                    var PacketSetDefault = BaseSetDefaultOffset + (i * Jumper);
                    var PacketDropRune = BaseDropOffset + (i * Jumper);
                    var PacketUseGate = BaseGateOffset + (i * Jumper);
                    var PacketUseSacred = BaseSacredOffset + (i * Jumper);
                    var PacketUseRecall = BaseRecallOffset + (i * Jumper);
                    var PacketUseScroll = BaseScrollOffset + (i * Jumper);
                    var title = g.Labels[i].Text;
                    var Hue = g.Labels[i].Color;
                    var position = "Nowhere";
                    var add = false;

                    switch (XConfig.Engine)
                    {
                        case ShardEngine.Broadsword:
                            {

                                if (2 + i < g.HTMLTexts.Count)
                                {
                                    position = g.HTMLTexts[2 + i].Text;
                                    add = true;
                                }
                                break;
                            }
                        case ShardEngine.RebirthUO:
                            {
                                if ((2 * i) + 1 < g.Labels.Count)
                                {
                                    position = g.Labels[(2 * i)].Text + g.Labels[(2 * i) + 1].Text;
                                    add = true;
                                }
                                break;
                            }
                    }
                    if (add)
                        Entries.Add(new RunebookEntry(this, title, position, (uint)Hue, PacketSetDefault, PacketDropRune, PacketUseGate, PacketUseSacred, PacketUseRecall, PacketUseScroll));
                }
                return true;
            }
            return false;
        }


        public bool Close()
        {
            _lastparsedgump.Close();
            return _lastparsedgump.WaitForGumpClose(1000);
        }


        public bool Open()
        {
            Close();
            if (DoubleClick() && Gump.WaitForGump(GumpType, 1000))
            {
                var gump = Gump.GetGump(GumpType);
                _lastparsedgump = gump;
                return gump.Serial.Value > 0;
            }
            return false;
        }

        public bool Parse()
        {
            return Open() && ParseGump(_lastparsedgump) && Close();
        }

        public bool Recall()
        {
            return Stealth.Client.CastSpellToObj("Recall", Serial.Value);
        }
        public bool Sacred()
        {
            return Stealth.Client.CastSpellToObj("Sacred Journey", Serial.Value);
        }
        public bool Gate()
        {
            return Stealth.Client.CastSpellToObj("Gate Travel", Serial.Value);
        }

        public bool Recall(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.RecallButton));
            return Open() && button != null && button.Click();
        }
        public bool Sacred(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.SacredButton));
            return Open() && button != null && button.Click();
        }
        public bool Gate(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.Gatebutton));
            return Open() && button != null && button.Click();
        }
        public bool UseScroll(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.ScrollButton));
            return Open() && button != null && button.Click();
        }
        public bool DropRune(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.DropButton));
            return Open() && button != null && button.Click();
        }
        public bool SetDefault(RunebookEntry entry)
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(entry.DefaultButton));
            return Open() && button != null && button.Click();
        }
        public bool Rename()
        {
            var button = _lastparsedgump.Buttons.First(e => e.PacketValue.Equals(_renamebutton));
            return Open() && button != null && button.Click();
        }

        public bool Active()
        {
            return _lastparsedgump.Index > -1;
        }
        #endregion
    }

    public static class RunebookExtensions
    {
        public static string ReadDescription(this Runebook rb, List<ClilocItemRec> attrib)
        {
            uint ClilocID = 0;
            switch (XConfig.Engine)
            {
                case ShardEngine.Broadsword:
                    ClilocID = 1070722;
                    break;
                case ShardEngine.RebirthUO:
                    ClilocID = 1042971;
                    break;
            }
            return !ClilocHelper.Contains(attrib, ClilocID) ? String.Empty : ClilocHelper.GetParams(attrib, ClilocID)[0];
        }
    }
}

May not compatible with current SDK version and next update (i do a huge gump update) wont work for me anymore as well
But it may gives you an impression how it could work.

[Crome969]

A working Sample for upcoming update 0.9.2 :

Code: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using ScriptSDK;
using ScriptSDK.API;
using ScriptSDK.Data;
using ScriptSDK.Engines;
using ScriptSDK.Gumps;
using ScriptSDK.Items;
using ScriptSDK.Utils;

namespace SmartScript
{
    public struct RuneBookConfig
    {
        public int ScrollOffset { get; set; }
        public int DropOffset { get; set; }
        public int DefaultOffset { get; set; }
        public int RecallOffset { get; set; }
        public int GateOffset { get; set; }
        public int SacredOffset { get; set; }
        public int Jumper { get; set; }
    }

    public class RunebookEntry
    {
        private readonly Runebook _owner;
        private readonly GumpButton _recall;
        private readonly GumpButton _gate;
        private readonly GumpButton _sacred;
        private readonly GumpButton _scroll;
        private readonly GumpButton _default;
        private readonly GumpButton _drop;
        public string Name { get; private set; }
        public string Location { get; private set; }
        public Map Map { get; private set; }
        public Point3D Position { get; private set; }

        internal RunebookEntry(Runebook owner, GumpButton recall, GumpButton gate, GumpButton sacred, GumpButton scroll, GumpButton def, GumpButton drop, string location, string name, int color)
        {
            _owner = owner;
            _recall = recall;
            _gate = gate;
            _sacred = sacred;
            _scroll = scroll;
            _default = def;
            _drop = drop;
            Name = name;
            Location = location;
            Map = Map.Internal;
            switch (color)
            {
                case 1102:
                    Map = Map.Malas;
                    break;
                case 81:
                    Map = Map.Felucca;
                    break;
                case 10:
                    Map = Map.Trammel;
                    break;
                case 1154:
                    Map = Map.Tokuno;
                    break;
                case 0:
                    Map = Map.TerMur;
                    break;
            }
            Position = Geometry.CoordsToPoint(Location,Map);
        }

        public bool SetDefault()
        {
            return _owner.Open() && _default.Click();
        }

        public bool Recall()
        {
            return _owner.Open() && _recall.Click();
        }

        public bool Sacred()
        {
            return _owner.Open() && _sacred.Click();
        }

        public bool Gate()
        {
            return _owner.Open() && _gate.Click();
        }

        public bool UseScroll()
        {
            return _owner.Open() && _scroll.Click();
        }
        public bool DropRune()
        {
            return _owner.Open() && _drop.Click();
        }

    }
    
    [QuerySearch(0x22C5)]
    public class Runebook : Item
    {
        public override int DefaultLabelNumber
        {
            get { return 1041267; }
        }
        public int DefaultRune { get; private set; }
        public List<RunebookEntry> Entries { get; private set; }
        public Range Uses { get; private set; }
        public string Description
        {
            get
            {
                return !ClilocHelper.Contains(Properties, 1042971) ? string.Empty : ClilocHelper.GetParams(Properties, 1042971)[0];
            }
        }
        public string Crafter
        {
            get
            {
                return !ClilocHelper.Contains(Properties, 1050043) ? string.Empty : ClilocHelper.GetParams(Properties, 1050043)[0];
            }
        }
        public bool Exceptional
        {
            get
            {
                return (ClilocHelper.Contains(Properties, 1060636));
            }
        }
        public RuneBookConfig Configuration { get; set; }
        private uint GumpType { get; set; }
        private ushort GumpDelay { get; set; }
        private GumpButton RenameButton { get; set; }

        public Runebook(Serial serial,RuneBookConfig config) : base(serial)
        {
            GumpType = 0x554B87F3;
            GumpDelay = 1000;
            Entries = new List<RunebookEntry>();
            Uses = new Range(0, 0);
            DefaultRune = -1;
            Configuration = config;
        }
        public Runebook(uint value, RuneBookConfig config) : this(new Serial(value), config)
        { }

        public bool Parse()
        {
            if (!Close() || !Open())
                return false;

            var g = Gump.GetGump(GumpType);

            UpdateLocalizedProperties();

            int scrolloffset = Configuration.ScrollOffset;
            int dropoffset = Configuration.DropOffset;
            int defaultoffset = Configuration.DefaultOffset;
            int recalloffset = Configuration.RecallOffset;
            int gateoffset = Configuration.GateOffset;
            int sacredoffset = Configuration.SacredOffset;
            int jumper = Configuration.Jumper;

            dynamic min = string.Empty;
            dynamic max = string.Empty;

            if (g.HTMLTexts.Count > 0)
                min = g.HTMLTexts[0].Text;
            if (g.HTMLTexts.Count > 1)
                max = g.HTMLTexts[1].Text;

            int imin;
            if (!int.TryParse(min, out imin))
                imin = -1;
            int imax;
            if (!int.TryParse(max, out imax))
                imax = -1;

            Uses = new Range(imin, imax);

            int eamt = 0;
            for (var i = 0; i < 15; i++)
            {
                if (g.Buttons.Any(e => e.PacketValue.Equals(recalloffset + (i * jumper)) &&
                                       e.Graphic.Released.Equals(2103) &&
                                       e.Graphic.Pressed.Equals(2104)))
                    eamt++;
            }

            var namepos = (eamt * 2);

            GumpButton defaultbtn = g.Buttons.First(e => e.Graphic.Released.Equals(2360) && e.Graphic.Pressed.Equals(2360));
            if (defaultbtn != null)
            {
                var value = ((defaultbtn.PacketValue - defaultoffset) / jumper) + 1;
                DefaultRune = value;
            }

            var rButton = g.Buttons.First(e => e.Graphic.Released.Equals(2472) || e.Graphic.Pressed.Equals(2473));
            RenameButton = rButton;

            for (var i = 0; i < 15; i++)
            {
                var valid = g.Buttons.Any(e => e.PacketValue.Equals(recalloffset + (i * jumper)) && e.Graphic.Released.Equals(2103) && e.Graphic.Pressed.Equals(2104));

                if (valid)
                {
                    var recallButton = g.Buttons.First(e => e.PacketValue.Equals(recalloffset + (i * jumper)));
                    var gateButton = g.Buttons.First(e => e.PacketValue.Equals(gateoffset + (i * jumper)));
                    var sacredButton = g.Buttons.First(e => e.PacketValue.Equals(sacredoffset + (i * jumper)));
                    var dropButton = g.Buttons.First(e => e.PacketValue.Equals(dropoffset + (i * jumper)));
                    var scrollButton = g.Buttons.First(e => e.PacketValue.Equals(scrolloffset + (i * jumper)));
                    var defaultButton = g.Buttons.First(e => e.PacketValue.Equals(defaultoffset + (i * jumper)));

                    var a = g.Labels[i + (i * 1)].Text;
                    var b = g.Labels[i + (i * 1) + 1].Text;
                    var full = a + " " + b;
                    var name = g.Labels[namepos + i].Text;
                    var color = g.Labels[namepos + i].Color;

                    Entries.Add(new RunebookEntry(this, recallButton, gateButton, sacredButton, scrollButton, defaultButton, dropButton, full, name, color));
                }
            }

            return true;

        }
        public bool Rename()
        {
            return Open() && RenameButton != null && RenameButton.Click();
        }
        public bool Recall()
        {
            return Stealth.Client.CastSpellToObj("Recall", Serial.Value);
        }
        public bool Sacred()
        {
            return Stealth.Client.CastSpellToObj("Sacred Journey", Serial.Value);
        }
        public bool Gate()
        {
            return Stealth.Client.CastSpellToObj("Gate Travel", Serial.Value);
        }
        public bool Close()
        {
            Gump g = Gump.GetGump(GumpType);
            if (g != null)
                if (!g.Serial.Equals(0))
                    g.Close();

            if (!Gump.WaitForGumpClose(GumpType, GumpDelay))
                return false;
            return true;
        }
        public bool Open()
        {
            if (!Close())
                return false;

            if (!DoubleClick() || !Gump.WaitForGump(GumpType, GumpDelay))
                return false;
            return true;
        }
    }


    internal class Program
    {
        [STAThread]
        private static void Main()
        {
            RuneBookConfig config = new RuneBookConfig()
            {
                ScrollOffset = 2,
                DropOffset = 3,
                DefaultOffset = 4,
                RecallOffset = 5,
                GateOffset = 6,
                SacredOffset = 7,
                Jumper = 6
            };
            
            Runebook rb = new Runebook(0x4027F04A, config);
            rb.Parse();

            rb.Entries[0].Recall();

            Console.WriteLine(@"Press any key....");
            Console.ReadKey();
        }
    }
}

Tested on RebirthUO

[epsilon2]

hi

GumpHelper.SendClick(this.Serial, 49 + Point); // Start From 50

I found no Gumphelper in the script sdk.
Please give me a  example how to write a command like this for a Gump.

regards

[Crome969]

hi

GumpHelper.SendClick(this.Serial, 49 + Point); // Start From 50

I found no Gumphelper in the script sdk.
Please give me a  example how to write a command like this for a Gump.

regards

no longer required since you can perform click onto GumpButton control directly and it will handle this.Serial itself.

check my last snippet before your latest post, i posted a working snippet with new gump system

[Tidus]

Updated:  This works with OSI and with RebirthUO

You will need to modify the Variables in Main in order to get it to work.  

Code: [Select]

using System.Collections.Generic;
using System.Linq;
using ScriptSDK;
using ScriptSDK.Data;
using ScriptSDK.Engines;
using ScriptSDK.Gumps;
using ScriptSDK.Items;
using ScriptSDK.Utils;
using StealthAPI;

namespace TLumberjack
{
    public struct RuneBookConfig
    {
        public int ScrollOffset { get; set; }
        public int DropOffset { get; set; }
        public int DefaultOffset { get; set; }
        public int RecallOffset { get; set; }
        public int GateOffset { get; set; }
        public int SacredOffset { get; set; }
        public int Jumper { get; set; }
    }

    public class RunebookEntry
    {
        private readonly Runebook _owner;
        private readonly GumpButton _recall;
        private readonly GumpButton _gate;
        private readonly GumpButton _sacred;
        private readonly GumpButton _scroll;
        private readonly GumpButton _default;
        private readonly GumpButton _drop;
        public string Name { get; private set; }
        public string Location { get; private set; }
        public Map Map { get; private set; }
        public Point3D Position { get; private set; }

        internal RunebookEntry(Runebook owner, GumpButton recall, GumpButton gate, GumpButton sacred, GumpButton scroll, GumpButton def, GumpButton drop, string location, string name, int color)
        {
            _owner = owner;
            _recall = recall;
            _gate = gate;
            _sacred = sacred;
            _scroll = scroll;
            _default = def;
            _drop = drop;
            Name = name;
            Location = location;
            Map = Map.Internal;
            switch (color)
            {
                case 1102:
                    Map = Map.Malas;
                    break;
                case 81:
                    Map = Map.Felucca;
                    break;
                case 10:
                    Map = Map.Trammel;
                    break;
                case 1154:
                    Map = Map.Tokuno;
                    break;
                case 0:
                    Map = Map.TerMur;
                    break;
            }
            Position = Geometry.CoordsToPoint(Location, Map);
        }
        internal RunebookEntry(Runebook owner, GumpButton recall, GumpButton gate, GumpButton sacred, GumpButton scroll, GumpButton def, GumpButton drop, string name)
        {
            _owner = owner;
            _recall = recall;
            _gate = gate;
            _sacred = sacred;
            _scroll = scroll;
            _default = def;
            _drop = drop;
            Name = name;
        }

        public bool SetDefault()
        {
            return _owner.Open() && _default.Click();
        }

        public bool Recall()
        {
            return _owner.Open() && _recall.Click();
        }

        public bool Sacred()
        {
            return _owner.Open() && _sacred.Click();
        }

        public bool Gate()
        {
            return _owner.Open() && _gate.Click();
        }

        public bool UseScroll()
        {
            return _owner.Open() && _scroll.Click();
        }
        public bool DropRune()
        {
            return _owner.Open() && _drop.Click();
        }

    }

    [QuerySearch(0x22C5)]
    public class Runebook : Item
    {
        public override int DefaultLabelNumber
        {
            get { return 1041267; }
        }
        public int DefaultRune { get; private set; }
        public List<RunebookEntry> Entries { get; private set; }
        public Range Uses { get; private set; }
        public string Description
        {
            get
            {
                return !ClilocHelper.Contains(Properties, 1042971) ? string.Empty : ClilocHelper.GetParams(Properties, 1042971)[0];
            }
        }
        public string Crafter
        {
            get
            {
                return !ClilocHelper.Contains(Properties, 1050043) ? string.Empty : ClilocHelper.GetParams(Properties, 1050043)[0];
            }
        }
        public bool Exceptional
        {
            get
            {
                return (ClilocHelper.Contains(Properties, 1060636));
            }
        }
        public RuneBookConfig Configuration { get; set; }
        private uint GumpType { get; set; }
        private ushort GumpDelay { get; set; }
        private string Shard { get; set;}

        private GumpButton RenameButton { get; set; }

        public Runebook(Serial serial, RuneBookConfig config)
            : base(serial)
        {
            GumpType = 0x554B87F3;
            GumpDelay = 1000;
            Entries = new List<RunebookEntry>();
            Uses = new Range(0, 0);
            DefaultRune = -1;
            Configuration = config;
            Shard = "FS";
        }

        public Runebook(Serial serial, RuneBookConfig config, string osi)
            : base(serial)
        {
            GumpType = 0x0059;
            GumpDelay = 1000;
            Entries = new List<RunebookEntry>();
            Uses = new Range(0, 0);
            DefaultRune = -1;
            Configuration = config;
            Shard = osi;
        }
        public Runebook(uint value, RuneBookConfig config)
            : this(new Serial(value), config)
        { }
        public Runebook(uint value, RuneBookConfig config, string osi)
            : this(new Serial(value), config, osi)
        { }

        public bool Parse()
        {
            if (!Close() || !Open())
                return false;

            var g = Gump.GetGump(GumpType);

            UpdateLocalizedProperties();

            int scrolloffset = Configuration.ScrollOffset;
            int dropoffset = Configuration.DropOffset;
            int defaultoffset = Configuration.DefaultOffset;
            int recalloffset = Configuration.RecallOffset;
            int gateoffset = Configuration.GateOffset;
            int sacredoffset = Configuration.SacredOffset;
            int jumper = Configuration.Jumper;

            dynamic min = string.Empty;
            dynamic max = string.Empty;

            if (g.HTMLTexts.Count > 0)
                min = g.HTMLTexts[0].Text;
            if (g.HTMLTexts.Count > 1)
                max = g.HTMLTexts[1].Text;

            int imin;
            if (!int.TryParse(min, out imin))
                imin = -1;
            int imax;
            if (!int.TryParse(max, out imax))
                imax = -1;

            Uses = new Range(imin, imax);
            if (Shard == "OSI")
            {
                int eamt = 0;
                for (var i = 0; i < 15; i++)
                {
                    if (g.Buttons.Any(
                            e =>
                                e.PacketValue.Equals(defaultoffset + (i)) && e.Graphic.Released.Equals(2361) &&
                                e.Graphic.Pressed.Equals(2361)))
                        eamt++;
                }

                var namepos = (eamt);

                var defaultbtn = g.Buttons.First(e => e.Graphic.Released.Equals(2361) && e.Graphic.Pressed.Equals(2361));
                if (defaultbtn != null)
                {
                    var value = ((defaultbtn.PacketValue - defaultoffset) / jumper) + 1;
                    DefaultRune = value;
                }

                var rButton = g.Buttons.First(e => e.Graphic.Released.Equals(2472) || e.Graphic.Pressed.Equals(2473));
                RenameButton = rButton;

                for (var i = 0; i < 15; i++)
                {
                    var valid =
                        g.Buttons.Any(
                            e =>
                                e.PacketValue.Equals(defaultoffset + (i)) && e.Graphic.Released.Equals(2361) &&
                                e.Graphic.Pressed.Equals(2361));

                    if (!valid) continue;
                    var recallButton = g.Buttons.First(e => e.PacketValue.Equals(recalloffset + (i)));
                    var gateButton = g.Buttons.First(e => e.PacketValue.Equals(gateoffset + (i)));
                    var sacredButton = g.Buttons.First(e => e.PacketValue.Equals(sacredoffset + (i)));
                    var dropButton = g.Buttons.First(e => e.PacketValue.Equals(dropoffset + (i)));
                    var scrollButton = g.Buttons.First(e => e.PacketValue.Equals(scrolloffset + (i)));
                    var defaultButton = g.Buttons.First(e => e.PacketValue.Equals(defaultoffset + (i)));
                    var name = g.Labels[namepos].Text;

                    Entries.Add(new RunebookEntry(this, recallButton, gateButton, sacredButton, scrollButton,
                            defaultButton, dropButton, name));
                }
            }
            else
            {
                int eamt = 0;
                for (var i = 0; i < 15; i++)
                {
                    if (g.Buttons.Any(e => e.PacketValue.Equals(recalloffset + (i*jumper)) &&
                                           e.Graphic.Released.Equals(2103) &&
                                           e.Graphic.Pressed.Equals(2104)))
                        eamt++;
                }

                var namepos = (eamt*2);

                var defaultbtn = g.Buttons.First(e => e.Graphic.Released.Equals(2361) && e.Graphic.Pressed.Equals(2361));
                if (defaultbtn != null)
                {
                    var value = ((defaultbtn.PacketValue - defaultoffset) / jumper) + 1;
                    DefaultRune = value;
                }

                var rButton = g.Buttons.First(e => e.Graphic.Released.Equals(2472) || e.Graphic.Pressed.Equals(2473));
                RenameButton = rButton;

                for (var i = 0; i < 15; i++)
                {
                    var valid =
                        g.Buttons.Any(
                            e =>
                                e.PacketValue.Equals(recalloffset + (i*jumper)) && e.Graphic.Released.Equals(2103) &&
                                e.Graphic.Pressed.Equals(2104));

                    if (!valid) continue;
                    var recallButton = g.Buttons.First(e => e.PacketValue.Equals(recalloffset + (i*jumper)));
                    var gateButton = g.Buttons.First(e => e.PacketValue.Equals(gateoffset + (i*jumper)));
                    var sacredButton = g.Buttons.First(e => e.PacketValue.Equals(sacredoffset + (i*jumper)));
                    var dropButton = g.Buttons.First(e => e.PacketValue.Equals(dropoffset + (i*jumper)));
                    var scrollButton = g.Buttons.First(e => e.PacketValue.Equals(scrolloffset + (i*jumper)));
                    var defaultButton = g.Buttons.First(e => e.PacketValue.Equals(defaultoffset + (i*jumper)));

                    var a = g.Labels[i + (i*1)].Text;
                    var b = g.Labels[i + (i*1) + 1].Text;
                    var full = a + " " + b;
                    var name = g.Labels[namepos + i].Text;
                    var color = g.Labels[namepos + i].Color;

                    Entries.Add(new RunebookEntry(this, recallButton, gateButton, sacredButton, scrollButton,
                        defaultButton, dropButton, full, name, color));
                }
            }

            return true;

        }
        public bool Rename()
        {
            return Open() && RenameButton != null && RenameButton.Click();
        }
        public bool Recall()
        {
            return Stealth.Client.CastSpellToObj("Recall", Serial.Value);
        }
        public bool Sacred()
        {
            return Stealth.Client.CastSpellToObj("Sacred Journey", Serial.Value);
        }
        public bool Gate()
        {
            return Stealth.Client.CastSpellToObj("Gate Travel", Serial.Value);
        }
        public bool Close()
        {
            Gump g = Gump.GetGump(GumpType);
            if (g != null)
                if (!g.Serial.Equals(0))
                    g.Close();
            Stealth.Client.Wait(1000);
            if (!Gump.WaitForGumpClose(GumpType, GumpDelay))
                return false;
            return true;
        }
        public bool Open()
        {
            if (!Close())
                return false;

            if (!DoubleClick() || !Gump.WaitForGump(GumpType, GumpDelay))
                return false;
            return true;
        }
    }


    //internal class Program
    {
        [STAThread]
        private static void Main()
        {
            var RUOconfig = new RuneBookConfig()
            {
                ScrollOffset = 2,
                DropOffset = 3,
                DefaultOffset = 4,
                RecallOffset = 5,
                GateOffset = 6,
                SacredOffset = 7,
                Jumper = 6
            };
            var OSIconfig = new RuneBookConfig()
            {
                ScrollOffset = 10,
                DropOffset = 200,
                DefaultOffset = 300,
                RecallOffset = 50,
                GateOffset = 100,
                SacredOffset = 75,
                Jumper = 1
            };

            Runebook RUOrb = new Runebook(runebookserial.Serial.Value, RUOconfig);
            Runebook OSIrb = new Runebook(runebookserial.Serial.Value, OSIconfig, "OSI");  

           if (osi)
            {
                OSIrb.Parse();
                if (recalltype == "Recall")
                {
                    OSIrb.Entries[bookspot - 1].Recall();
                }
                else
                {
                    OSIrb.Entries[bookspot - 1].Sacred();
                }
            }
            else
            {
                RUOrb.Parse();
                if (recalltype == "Recall")
                {
                    RUOrb.Entries[bookspot - 1].Recall();
                }
                else
                {
                    RUOrb.Entries[bookspot - 1].Sacred();
                }
            }
           Console.WriteLine(@"Press any key....");
            Console.ReadKey();
        }
    }
}


[smitty]

im super confused on how to use gumps with the newest skd. i been reading the forums all day tehe