Example #1
0
        private void GetSpellNames(int offset, out string name, out string abbreviature, out string reagents)
        {
            switch (_spellBookType)
            {
            case SpellBookType.Magery:
                SpellDefinition def = SpellsMagery.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = SpellsMagery.SpecialReagentsChars[offset][1];
                reagents     = def.CreateReagentListString("\n");
                break;

            case SpellBookType.Necromancy:
                def          = SpellsNecromancy.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = SpellsNecromancy.SpellsSpecialsName[offset][1];
                reagents     = def.CreateReagentListString("\n");
                break;

            case SpellBookType.Chivalry:
                def          = SpellsChivalry.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = def.PowerWords;
                reagents     = string.Empty;
                break;

            case SpellBookType.Bushido:
                def          = SpellsBushido.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = def.PowerWords;
                reagents     = string.Empty;
                break;

            case SpellBookType.Ninjitsu:
                def          = SpellsNinjitsu.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = def.PowerWords;
                reagents     = string.Empty;
                break;

            case SpellBookType.Spellweaving:
                def          = SpellsSpellweaving.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = def.PowerWords;
                reagents     = string.Empty;
                break;

            case SpellBookType.Mysticism:
                def          = SpellsMysticism.GetSpell(offset + 1);
                name         = def.Name;
                abbreviature = def.PowerWords;
                reagents     = def.CreateReagentListString("\n");
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        void SetActivePage(int page)
        {
            if (page < 1)
            {
                page = 1;
            }
            if (page > m_MaxPage)
            {
                page = m_MaxPage;
            }

            int currentPage           = page;
            int currentSpellCircle    = currentPage * 2 - 2;  // chooses the right spell circle to print on index page
            int currentSpellInfoIndex = currentPage * 2 - 10; // keeps track of which spell info page to print

            for (int currentCol = 0; currentCol < 2; currentCol++)
            {
                bool isRightPage = (currentCol + 1 == 2);
                currentSpellInfoIndex += currentCol;

                // Create Spell Index page
                if (currentPage <= 4)
                {
                    m_Indexes[currentSpellCircle].Text = "";
                    foreach (KeyValuePair <int, int> spell in m_SpellList)
                    {
                        if (spell.Key == currentSpellCircle)
                        {
                            int currentSpellInfoPage = m_SpellList.IndexOf(spell) / 2;
                            m_Indexes[currentSpellCircle].Text += string.Format("<a href='page={1}' color='#532' hovercolor='#800' activecolor='#611' style='font-family=uni0; text-decoration=none;'>{0}</a><br/>",
                                                                                SpellsMagery.GetSpell(currentSpellCircle * 8 + spell.Value).Name,
                                                                                5 + currentSpellInfoPage);
                        }
                    }
                    currentSpellCircle++;
                }
                else
                {
                    // Create Spell Info Page
                    if (currentSpellInfoIndex < m_SpellList.Count)
                    {
                        CreateSpellPage(page, isRightPage, m_SpellList[currentSpellInfoIndex].Key, SpellsMagery.GetSpell(m_SpellList[currentSpellInfoIndex].Key * 8 + m_SpellList[currentSpellInfoIndex].Value));
                    }
                }
            }

            ActivePage = page;
            // hide the page corners if we're at the first or final page.
            m_PageCornerLeft.Page  = (ActivePage != 1) ? 0 : int.MaxValue;
            m_PageCornerRight.Page = (ActivePage != m_MaxPage) ? 0 : int.MaxValue;
        }
Example #3
0
        private SpellDefinition GetSpellDefinition(int idx)
        {
            SpellDefinition def = null;

            switch (_spellBookType)
            {
            case SpellBookType.Magery:
                def = SpellsMagery.GetSpell(idx);

                break;

            case SpellBookType.Necromancy:
                def = SpellsNecromancy.GetSpell(idx);

                break;

            case SpellBookType.Chivalry:
                def = SpellsChivalry.GetSpell(idx);

                break;

            case SpellBookType.Bushido:
                def = SpellsBushido.GetSpell(idx);

                break;

            case SpellBookType.Ninjitsu:
                def = SpellsNinjitsu.GetSpell(idx);

                break;

            case SpellBookType.Spellweaving:
                def = SpellsSpellweaving.GetSpell(idx);

                break;

            case SpellBookType.Mysticism:
                def = SpellsMysticism.GetSpell(idx);

                break;

            case SpellBookType.Bardic:
                def = SpellsBardic.GetSpell(idx);

                break;
            }

            return(def);
        }
Example #4
0
        private SpellDefinition?GetSpellDefinition(object sender)
        {
            Control         ctrl = (Control)sender;
            int             idx  = (int)(ctrl.LocalSerial > 1000 ? ctrl.LocalSerial - 1000 : ctrl.LocalSerial - 100) + 1;
            SpellDefinition?def  = null;

            switch (_spellBookType)
            {
            case SpellBookType.Magery:
                def = SpellsMagery.GetSpell(idx);
                break;

            case SpellBookType.Necromancy:
                def = SpellsNecromancy.GetSpell(idx);
                break;

            case SpellBookType.Chivalry:
                def = SpellsChivalry.GetSpell(idx);
                break;

            case SpellBookType.Bushido:
                def = SpellsBushido.GetSpell(idx);
                break;

            case SpellBookType.Ninjitsu:
                def = SpellsNinjitsu.GetSpell(idx);
                break;

            case SpellBookType.Spellweaving:
                def = SpellsSpellweaving.GetSpell(idx);
                break;

            case SpellBookType.Mysticism:
                def = SpellsMysticism.GetSpell(idx);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            return(def);
        }
Example #5
0
        private void CreateSpellDetailsPage(int page, bool isright, int circle, SpellDefinition spell)
        {
            if (_spellBookType == SpellBookType.Magery)
            {
                AddChildren(new Label(SpellsMagery.CircleNames[circle], false, 0x0288, font: 6)
                {
                    X = isright ? 64 + 162 : 85, Y = 10
                }, page);
            }

            GumpPic spellImage = new GumpPic(isright ? 225 : 62, 40, (Graphic)(spell.GumpIconID - 0x1298), 0)
            {
                LocalSerial = (uint)(Graphic)(spell.GumpIconID - 0x1298), Tag = spell.ID
            };

            spellImage.DragBegin += (sender, e) =>
            {
                GumpControl     ctrl = (GumpControl)sender;
                SpellDefinition def  = SpellsMagery.GetSpell((int)ctrl.Tag);

                UseSpellButtonGump gump = new UseSpellButtonGump(def)
                {
                    X = Mouse.Position.X - 22, Y = Mouse.Position.Y - 22
                };
                UIManager.Add(gump);
                UIManager.AttemptDragControl(gump, Mouse.Position, true);
            };
            AddChildren(spellImage, page);

            Label spellnameLabel = new Label(spell.Name, false, 0x0288, 80, 6)
            {
                X = isright ? 275 : 112, Y = 34
            };

            AddChildren(spellnameLabel, page);

            if (spell.Regs.Length > 0)
            {
                AddChildren(new GumpPicTiled(isright ? 225 : 62, 88, 120, 4, 0x0835), page);

                AddChildren(new Label("Reagents:", false, 0x0288, font: 6)
                {
                    X = isright ? 225 : 62, Y = 92
                }, page);
                string reagList = spell.CreateReagentListString(",\n");

                if (_spellBookType == SpellBookType.Magery)
                {
                    int y = spellnameLabel.Height < 24 ? 31 : 24;
                    y += spellnameLabel.Height;

                    AddChildren(new Label(SpellsMagery.SpecialReagentsChars[spell.ID - 1][1], false, 0x0288, font: 8)
                    {
                        X = isright ? 275 : 112, Y = y
                    }, page);
                }

                AddChildren(new Label(reagList, false, 0x0288, font: 9)
                {
                    X = isright ? 225 : 62, Y = 114
                }, page);
            }
        }
Example #6
0
        private void CreateBook()
        {
            Clear();
            _pageCornerLeft = _pageCornerRight = null;
            GetBookInfo(_spellBookType, out Graphic bookGraphic, out Graphic minimizedGraphic, out Graphic iconStartGraphic, out int maxSpellsCount, out int spellIndexOffset, out int spellsOnPage, out int dictionaryPagesCount);
            AddChildren(new GumpPic(0, 0, bookGraphic, 0));
            AddChildren(_pageCornerLeft        = new GumpPic(50, 8, 0x08BB, 0));
            _pageCornerLeft.LocalSerial        = 0;
            _pageCornerLeft.Page               = int.MaxValue;
            _pageCornerLeft.MouseClick        += PageCornerOnMouseClick;
            _pageCornerLeft.MouseDoubleClick  += PageCornerOnMouseDoubleClick;
            AddChildren(_pageCornerRight       = new GumpPic(321, 8, 0x08BC, 0));
            _pageCornerRight.LocalSerial       = 1;
            _pageCornerRight.Page              = 1;
            _pageCornerRight.MouseClick       += PageCornerOnMouseClick;
            _pageCornerRight.MouseDoubleClick += PageCornerOnMouseDoubleClick;
            int totalSpells = 0;

            for (int circle = 0; circle < 8; circle++)
            {
                for (int i = 1; i <= 8; i++)
                {
                    if (_spellBook.HasSpell(circle, i))
                    {
                        _spells[circle * 8 + i - 1] = 1;
                        totalSpells++;
                    }
                }
            }

            _maxPage = (dictionaryPagesCount >> 1) + ((totalSpells + 1) >> 1);
            int  offs            = 0;
            bool isMageSpellbook = false;

            if (_spellBookType == SpellBookType.Magery)
            {
                isMageSpellbook = true;

                AddChildren(new Button((int)ButtonCircle.Circle_1_2, 0x08B1, 0x08B1)
                {
                    X = 58, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 1
                });

                AddChildren(new Button((int)ButtonCircle.Circle_1_2, 0x08B2, 0x08B2)
                {
                    X = 93, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 1
                });

                AddChildren(new Button((int)ButtonCircle.Circle_3_4, 0x08B3, 0x08B3)
                {
                    X = 130, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 2
                });

                AddChildren(new Button((int)ButtonCircle.Circle_3_4, 0x08B4, 0x08B4)
                {
                    X = 164, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 2
                });

                AddChildren(new Button((int)ButtonCircle.Circle_5_6, 0x08B5, 0x08B5)
                {
                    X = 227, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 3
                });

                AddChildren(new Button((int)ButtonCircle.Circle_5_6, 0x08B6, 0x08B6)
                {
                    X = 260, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 3
                });

                AddChildren(new Button((int)ButtonCircle.Circle_7_8, 0x08B7, 0x08B7)
                {
                    X = 297, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 4
                });

                AddChildren(new Button((int)ButtonCircle.Circle_7_8, 0x08B8, 0x08B8)
                {
                    X = 332, Y = 175, ButtonAction = ButtonAction.Activate, ToPage = 4
                });
            }

            for (int i = 1; i <= (dictionaryPagesCount >> 1); i++)
            {
                int page = i;

                for (int j = 0; j < 2; j++)
                {
                    if (page == 1 && _spellBookType == SpellBookType.Chivalry)
                    {
                        Label label = new Label("Tithing points\nAvailable: " + World.Player.TithingPoints, false, 0x0288, font: 6)
                        {
                            X = 62, Y = 162
                        };
                        AddChildren(label, page);
                    }

                    int  indexX      = 106;
                    int  dataX       = 62;
                    int  y           = 0;
                    uint spellSerial = 100;

                    if (j % 2 != 0)
                    {
                        indexX      = 269;
                        dataX       = 225;
                        spellSerial = 1000;
                    }

                    Label text = new Label("INDEX", false, 0x0288, font: 6)
                    {
                        X = indexX, Y = 10
                    };
                    AddChildren(text, page);

                    if (isMageSpellbook)
                    {
                        text = new Label(SpellsMagery.CircleNames[(i - 1) * 2 + j % 2], false, 0x0288, font: 6)
                        {
                            X = dataX, Y = 30
                        };
                        AddChildren(text, page);
                    }

                    for (int k = 0; k < spellsOnPage; k++)
                    {
                        if (_spells[offs] > 0)
                        {
                            GetSpellNames(offs, out string name, out string abbreviature, out string reagents);

                            text = new HoveredLabel(name, false, 0x0288, 0x33, font: 9)
                            {
                                X = dataX, Y = 52 + y, LocalSerial = (uint)((dictionaryPagesCount >> 1) + (offs >> 1) + 1), AcceptMouseInput = true
                            };

                            text.MouseClick += (sender, e) =>
                            {
                                HoveredLabel l = (HoveredLabel)sender;
                                SetActivePage((int)l.LocalSerial.Value);
                            };
                            AddChildren(text, page);
                            y += 15;
                        }

                        offs++;
                    }
                }
            }

            int  page1            = (dictionaryPagesCount >> 1) + 1;
            int  topTextY         = _spellBookType == SpellBookType.Magery ? 10 : 6;
            bool haveReagents     = _spellBookType <= SpellBookType.Necromancy;
            bool haveAbbreviature = _spellBookType != SpellBookType.Bushido && _spellBookType != SpellBookType.Ninjitsu;

            for (int i = 0; i < maxSpellsCount; i++)
            {
                if (_spells[i] <= 0)
                {
                    continue;
                }

                int  iconX      = 62;
                int  topTextX   = 87;
                int  iconTextX  = 112;
                uint iconSerial = 100 + (uint)i;


                if (i > 0)
                {
                    if (i % 2 != 0)
                    {
                        iconX      = 225;
                        topTextX   = 244 - 20;
                        iconTextX  = 275;
                        iconSerial = 1000 + (uint)(i);
                    }
                    else
                    {
                        page1++;
                    }
                }

                GetSpellNames(i, out string name, out string abbreviature, out string reagents);

                if (isMageSpellbook)
                {
                    Label text = new Label(SpellsMagery.CircleNames[i >> 3], false, 0x0288, font: 6)
                    {
                        X = topTextX, Y = topTextY
                    };
                    AddChildren(text, page1);

                    text = new Label(name, false, 0x0288, 80, 6)
                    {
                        X = iconTextX, Y = 34
                    };
                    AddChildren(text, page1);
                    int abbreviatureY = 26;

                    if (text.Height < 24)
                    {
                        abbreviatureY = 31;
                    }
                    abbreviatureY += text.Height;

                    text = new Label(abbreviature, false, 0x0288, font: 8)
                    {
                        X = iconTextX, Y = abbreviatureY
                    };
                    AddChildren(text, page1);
                }
                else
                {
                    Label text = new Label(name, false, 0x0288, font: 6)
                    {
                        X = topTextX, Y = topTextY
                    };
                    AddChildren(text, page1);

                    if (haveAbbreviature)
                    {
                        text = new Label(abbreviature, false, 0x0288, 80, 6)
                        {
                            X = iconTextX, Y = 34
                        };
                        AddChildren(text, page1);
                    }
                }

                GumpPic icon = new GumpPic(iconX, 40, (Graphic)(iconStartGraphic + i), 0)
                {
                    X = iconX, Y = 40, LocalSerial = iconSerial
                };

                icon.DragBegin += (sender, e) =>
                {
                    GumpControl     ctrl = (GumpControl)sender;
                    int             idx  = (int)(ctrl.LocalSerial > 1000 ? ctrl.LocalSerial - 1000 : ctrl.LocalSerial - 100) + 1;
                    SpellDefinition?def  = null;

                    switch (_spellBookType)
                    {
                    case SpellBookType.Magery:
                        def = SpellsMagery.GetSpell(idx);

                        break;

                    case SpellBookType.Necromancy:
                        def = SpellsNecromancy.GetSpell(idx);

                        break;

                    case SpellBookType.Chivalry:
                        def = SpellsChivalry.GetSpell(idx);

                        break;

                    case SpellBookType.Bushido:
                        def = SpellsBushido.GetSpell(idx);

                        break;

                    case SpellBookType.Ninjitsu:
                        def = SpellsNinjitsu.GetSpell(idx);

                        break;

                    case SpellBookType.Spellweaving:
                        def = SpellsSpellweaving.GetSpell(idx);

                        break;

                    case SpellBookType.Mysticism:
                        def = SpellsMysticism.GetSpell(idx);

                        break;

                    default:

                        throw new ArgumentOutOfRangeException();
                    }

                    UseSpellButtonGump gump = new UseSpellButtonGump(def.Value)
                    {
                        X = Mouse.Position.X - 22, Y = Mouse.Position.Y - 22
                    };
                    UIManager.Add(gump);
                    UIManager.AttemptDragControl(gump, Mouse.Position, true);
                };
                AddChildren(icon, page1);

                if (haveReagents)
                {
                    AddChildren(new GumpPicTiled(iconX, 88, 120, 5, 0x0835), page1);

                    Label text = new Label("Reagents:", false, 0x0288, font: 6)
                    {
                        X = iconX, Y = 92
                    };
                    AddChildren(text, page1);

                    text = new Label(reagents, false, 0x0288, font: 9)
                    {
                        X = iconX, Y = 114
                    };
                    AddChildren(text, page1);
                }

                if (!isMageSpellbook)
                {
                    GetSpellRequires(i, out int requiriesY, out string requires);

                    Label text = new Label(requires, false, 0x0288, font: 6)
                    {
                        X = iconX, Y = requiriesY
                    };
                    AddChildren(text, page1);
                }
            }

            SetActivePage(1);
        }
 public override void OnHtmlInputEvent(string href, MouseEvent e)
 {
     if (e == MouseEvent.DoubleClick)
     {
         string[] hrefs = href.Split('=');
         if (hrefs.Length != 2)
         {
             return;
         }
         else if (hrefs[0] == "page")
         {
             int page;
             if (int.TryParse(hrefs[1], out page))
             {
                 m_World.Interaction.CastSpell(page - 4);
             }
         }
         else if (hrefs[0] == "spell")
         {
             int spell;
             if (int.TryParse(hrefs[1], out spell))
             {
                 m_World.Interaction.CastSpell(spell);
             }
         }
         else if (hrefs[0] == "spellicon")
         {
             int spell;
             if (int.TryParse(hrefs[1], out spell))
             {
                 m_World.Interaction.CastSpell(spell);
             }
         }
     }
     else if (e == MouseEvent.Click)
     {
         string[] hrefs = href.Split('=');
         if (hrefs.Length != 2)
         {
             return;
         }
         if (hrefs[0] == "page")
         {
             int page;
             if (int.TryParse(hrefs[1], out page))
             {
                 SetActivePage(page);
             }
         }
     }
     else if (e == MouseEvent.DragBegin)
     {
         string[] hrefs = href.Split('=');
         if (hrefs.Length != 2)
         {
             return;
         }
         if (hrefs[0] == "spellicon")
         {
             int spellIndex;
             if (!int.TryParse(hrefs[1], out spellIndex))
             {
                 return;
             }
             SpellDefinition spell = SpellsMagery.GetSpell(spellIndex);
             if (spell.ID == spellIndex)
             {
                 IInputService      input = Service.Get <IInputService>();
                 UseSpellButtonGump gump  = new UseSpellButtonGump(spell);
                 UserInterface.AddControl(gump, input.MousePosition.X - 22, input.MousePosition.Y - 22);
                 UserInterface.AttemptDragControl(gump, input.MousePosition, true);
             }
         }
     }
 }