示例#1
0
        //Breath First Search for finding flask root.
        private Element FindFlaskRoot()
        {
            Element           current = null;
            InventoryItemIcon itm     = null;
            Entity            item    = null;

            while (eleQueue.Count > 0)
            {
                current = eleQueue.Dequeue();
                if (current == null)
                {
                    continue;
                }
                foreach (var child in current.Children)
                {
                    eleQueue.Enqueue(child);
                }

                itm = current.AsObject <InventoryItemIcon>();

                if (itm.ToolTipType == ToolTipType.InventoryItem)
                {
                    item = itm.Item;
                    if (item != null && item.HasComponent <Flask>())
                    {
                        eleQueue.Clear();
                        return(current.Parent);
                    }
                }
            }
            return(null);
        }
        private static Element GetTooltip(InventoryItemIcon inventoryItemIcon)
        {
            Element tooltip = inventoryItemIcon.Tooltip;
            Element child   = tooltip?.GetChildAtIndex(0);

            return(child?.GetChildAtIndex(1));
        }
示例#3
0
        private static Element GetTooltip(InventoryItemIcon inventoryItemIcon)
        {
            Element tooltip = inventoryItemIcon.Tooltip;

            if (tooltip == null)
            {
                return(null);
            }

            Element child = tooltip.GetChildAtIndex(0);

            return(child == null ? null : child.GetChildAtIndex(1));
        }
示例#4
0
        public override void Render()
        {
            base.Render();
            if (!GameController.Game.IngameState.IngameUi.OpenLeftPanel.IsVisible)
            {
                return;
            }

            CurrentHoverItem = GameController.Game.IngameState.UIHover.AsObject <InventoryItemIcon>();

            if (CurrentHoverItem.ToolTipType == ToolTipType.InventoryItem && CurrentHoverItem.Item != null)
            {
                CurInventRoot = CurrentHoverItem.Parent.Parent;
                Graphics.DrawBox(CurrentHoverItem.Parent.GetClientRect(), Color.Yellow);
            }
            return;
        }
示例#5
0
        private bool GettingAllFlaskInfo(Element flaskRoot)
        {
            if (Settings.debugMode.Value)
            {
                LogMessage("Getting Inventory Flasks info.", logmsg_time);
            }
            playerFlaskList.Clear();
            try
            {
                var flasksEquipped = flaskRoot.Children;
                for (int j = 0; j < flasksEquipped.Count; j++)
                {
                    InventoryItemIcon flask        = flasksEquipped[j].AsObject <InventoryItemIcon>();
                    Entity            flaskItem    = flask.Item;
                    Charges           flaskCharges = flaskItem.GetComponent <Charges>();
                    Mods        flaskMods          = flaskItem.GetComponent <Mods>();
                    PlayerFlask newFlask           = new PlayerFlask();

                    newFlask.SetSettings(Settings);
                    newFlask.isInstant      = false;
                    newFlask.Slot           = flask.InventPosX;
                    newFlask.Item           = flaskItem;
                    newFlask.MaxCharges     = flaskCharges.ChargesMax;
                    newFlask.UseCharges     = flaskCharges.ChargesPerUse;
                    newFlask.CurrentCharges = flaskCharges.NumCharges;
                    newFlask.flaskRarity    = flaskMods.ItemRarity;
                    newFlask.FlaskName      = GameController.Files.BaseItemTypes.Translate(flaskItem.Path).BaseName;
                    newFlask.FlaskAction2   = FlaskAction.NONE;
                    newFlask.FlaskAction1   = FlaskAction.NONE;

                    //Checking flask action based on flask name type.
                    if (!flaskInfo.FlaskTypes.TryGetValue(newFlask.FlaskName, out newFlask.FlaskAction1))
                    {
                        LogError("Error: " + newFlask.FlaskName + " name not found. Report this error message.", errmsg_time);
                    }

                    //Checking for unique flasks.
                    if (flaskMods.ItemRarity == ItemRarity.Unique)
                    {
                        newFlask.FlaskName = flaskMods.UniqueName;
                        if (Settings.uniqFlaskEnable.Value)
                        {
                            //Enabling Unique flask action 2.
                            if (!flaskInfo.UniqueFlaskNames.TryGetValue(newFlask.FlaskName, out newFlask.FlaskAction2))
                            {
                                LogError("Error: " + newFlask.FlaskName + " unique name not found. Report this error message.", errmsg_time);
                            }
                        }
                        else
                        {
                            //Disabling Unique Flask actions.
                            newFlask.FlaskAction1 = FlaskAction.NONE;
                            newFlask.FlaskAction2 = FlaskAction.NONE;
                        }
                    }

                    //Checking flask mods.
                    FlaskAction action2 = FlaskAction.NONE;
                    foreach (var mod in flaskMods.ItemMods)
                    {
                        if (mod.Name.ToLower().Contains("flaskchargesused"))
                        {
                            newFlask.UseCharges = (int)Math.Floor(newFlask.UseCharges + ((double)(newFlask.UseCharges) * mod.Value1 / 100));
                        }

                        if (mod.Name.ToLower().Contains("instant"))
                        {
                            newFlask.isInstant = true;
                        }

                        // We have already decided action2 for unique flasks.
                        if (flaskMods.ItemRarity == ItemRarity.Unique)
                        {
                            continue;
                        }

                        if (!flaskInfo.FlaskMods.TryGetValue(mod.Name, out action2))
                        {
                            LogError("Error: " + mod.Name + " mod not found. Is it unique flask? If not, report this error message.", errmsg_time);
                        }
                        else if (action2 != FlaskAction.IGNORE)
                        {
                            newFlask.FlaskAction2 = action2;
                        }
                    }

                    // Speedrun mod on mana/life flask wouldn't work when full mana/life is full respectively,
                    // So we will ignore speedrun mod from mana/life flask. Other mods
                    // on mana/life flasks will work.
                    if (newFlask.FlaskAction2 == FlaskAction.SPEEDRUN &&
                        (newFlask.FlaskAction1 == FlaskAction.LIFE ||
                         newFlask.FlaskAction1 == FlaskAction.MANA ||
                         newFlask.FlaskAction1 == FlaskAction.HYBRID))
                    {
                        newFlask.FlaskAction2 = FlaskAction.NONE;
                        if (_WarnFlaskSpeed)
                        {
                            LogError("Warning: Speed Run mod is ignored on mana/life/hybrid flasks. Use Alt Orbs on those flasks.", errmsg_time);
                            _WarnFlaskSpeed = false;
                        }
                    }

                    if (Settings.disableLifeSecUse.Value)
                    {
                        if (newFlask.FlaskAction1 == FlaskAction.LIFE || newFlask.FlaskAction1 == FlaskAction.HYBRID)
                        {
                            if (newFlask.FlaskAction2 == FlaskAction.OFFENSE || newFlask.FlaskAction2 == FlaskAction.DEFENSE)
                            {
                                newFlask.FlaskAction2 = FlaskAction.NONE;
                            }
                        }
                    }

                    if (Settings.treatOffenAsDef.Value)
                    {
                        if (newFlask.FlaskAction1 == FlaskAction.OFFENSE)
                        {
                            newFlask.FlaskAction1 = FlaskAction.DEFENSE;
                        }
                        if (newFlask.FlaskAction2 == FlaskAction.OFFENSE)
                        {
                            newFlask.FlaskAction2 = FlaskAction.DEFENSE;
                        }
                    }
                    newFlask.EnableDisableFlask();
                    playerFlaskList.Add(newFlask);
                }
            }
            catch (Exception e)
            {
                if (Settings.debugMode.Value)
                {
                    LogError("Warning: Error getting all flask Informations.", errmsg_time);
                    LogError(e.Message + e.StackTrace, errmsg_time);
                }
                playerFlaskList.Clear();
                return(false);
            }
            playerFlaskList.Sort((x, y) => x.Slot.CompareTo(y.Slot));
            return(true);
        }