Esempio n. 1
0
        public bool InListUnique(ItemsOnGroundLabelElement ItemEntity)
        {
            var        Item           = ItemEntity.ItemOnGround.GetComponent <WorldItem>().ItemEntity;
            var        ItemEntityName = GameController.Files.BaseItemTypes.Translate(Item.Path).BaseName;
            ItemRarity Rarity         = Item.GetComponent <Mods>().ItemRarity;

            if (Uniques.Contains(ItemEntityName) && Rarity == ItemRarity.Unique)
            {
                return(true);
            }


            return(false);
        }
Esempio n. 2
0
        public CustomItem(ItemsOnGroundLabelElement item)
        {
            CompleteItem = item;
            Entity groundItem = item.ItemOnGround.GetComponent <WorldItem>().ItemEntity;

            GroundItem = groundItem;
            Path       = groundItem.Path;
            BaseItemType baseItemType = BasePlugin.API.GameController.Files.BaseItemTypes.Translate(Path);

            ClassName = baseItemType.ClassName;
            BaseName  = baseItemType.BaseName;
            if (groundItem.HasComponent <Quality>())
            {
                Quality quality = groundItem.GetComponent <Quality>();
                Quality = quality.ItemQuality;
            }

            if (groundItem.HasComponent <Base>())
            {
                Base @base = groundItem.GetComponent <Base>();
                IsElder  = @base.isElder;
                IsShaper = @base.isShaper;
            }

            if (groundItem.HasComponent <Mods>())
            {
                Mods mods = groundItem.GetComponent <Mods>();
                Rarity       = mods.ItemRarity;
                IsIdentified = mods.Identified;
                ItemLevel    = mods.ItemLevel;
            }

            if (groundItem.HasComponent <Sockets>())
            {
                Sockets sockets = groundItem.GetComponent <Sockets>();
                IsRGB       = sockets.IsRGB;
                Sockets     = sockets.NumberOfSockets;
                LargestLink = sockets.LargestLinkSize;
            }

            MapTier = groundItem.HasComponent <Map>() ? groundItem.GetComponent <Map>().Tier : 0;
        }
Esempio n. 3
0
        public void EntityAdded(EntityWrapper entity)
        {
            if (!Settings.Enabled || currentAlerts.ContainsKey(entity))
            {
                return;
            }
            if (!entity.HasComponent <WorldItem>())
            {
                return;
            }

            EntityWrapper        item  = new EntityWrapper(model, entity.GetComponent <WorldItem>().ItemEntity);
            ItemUsefulProperties props = EvaluateItem(item);

            if (!props.IsWorthAlertingPlayer(Settings, currencyNames))
            {
                return;
            }

            AlertDrawStyle drawStyle = props.GetDrawStyle();

            currentAlerts.Add(entity, drawStyle);
            drawStyle.IconForMap = new MapIcon(entity, new HudTexture("minimap_default_icon.png", drawStyle.color), 8)
            {
                Type = MapIcon.IconType.Item
            };

            if (Settings.PlaySound && drawStyle.soundToPlay != null && !playedSoundsCache.Contains(entity.LongId))
            {
                playedSoundsCache.Add(entity.LongId);
                drawStyle.soundToPlay.Play();
            }

            ItemsOnGroundLabelElement labeledItem = model.Internal.IngameState.IngameUi.ItemsOnGroundLabels.FirstOrDefault(z => z.ItemOnGround.Address == entity.Address);

            if (labeledItem != null)
            {
                groundItemLabels.Add(labeledItem);
            }
        }
Esempio n. 4
0
        private void DrawBorder(int entityAddres)
        {
            IngameUIElements ui = GameController.Game.IngameState.IngameUi;

            if (currentLabels.ContainsKey(entityAddres))
            {
                ItemsOnGroundLabelElement entitylabel = currentLabels[entityAddres];
                if (entitylabel.IsVisible)
                {
                    RectangleF rect = entitylabel.Label.GetClientRect();
                    if (ui.OpenLeftPanel.IsVisible && ui.OpenLeftPanel.GetClientRect().Intersects(rect) ||
                        ui.OpenRightPanel.IsVisible && ui.OpenRightPanel.GetClientRect().Intersects(rect))
                    {
                        return;
                    }

                    ColorNode borderColor = Settings.BorderSettings.BorderColor;
                    if (!entitylabel.CanPickUp)
                    {
                        borderColor = Settings.BorderSettings.NotMyItemBorderColor;
                        TimeSpan timeLeft = entitylabel.TimeLeft;
                        if (Settings.BorderSettings.ShowTimer && timeLeft.TotalMilliseconds > 0)
                        {
                            borderColor = Settings.BorderSettings.CantPickUpBorderColor;
                            Graphics.DrawText(timeLeft.ToString(@"mm\:ss"), Settings.BorderSettings.TimerTextSize,
                                              rect.TopRight.Translate(4, 0));
                        }
                    }
                    Graphics.DrawFrame(rect, Settings.BorderSettings.BorderWidth, borderColor);
                }
            }
            else
            {
                currentLabels = ui.ItemsOnGroundLabels.ToDictionary(y => y.ItemOnGround.Address, y => y);
            }
        }
Esempio n. 5
0
        public override void Render(RenderingContext rc, Dictionary <UiMountPoint, Vec2> mountPoints)
        {
            if (!Settings.ShowText && !Settings.ShowBorder)
            {
                return;
            }

            var playerPos = model.Player.GetComponent <Positioned>().GridPos;

            Vec2 rightTopAnchor = mountPoints[UiMountPoint.UnderMinimap];
            int  y                   = rightTopAnchor.Y;
            int  fontSize            = Settings.TextFontSize;
            var  itemsOnGroundLabels = model.Internal.IngameState.IngameUi.ItemsOnGroundLabels;

            const int VMargin = 2;

            foreach (KeyValuePair <EntityWrapper, AlertDrawStyle> kv in currentAlerts.Where(a => a.Key.IsValid))
            {
                string text = GetItemName(kv);
                if (null == text)
                {
                    continue;
                }

                if (Settings.ShowBorder)
                {
                    if (!groundItemLabels.Any(labeledItem => labeledItem.ItemOnGround.Address == kv.Key.Address))
                    {
                        ItemsOnGroundLabelElement labeledItem = model.Internal.IngameState.IngameUi.ItemsOnGroundLabels.FirstOrDefault(z => z.ItemOnGround.Address == kv.Key.Address);
                        if (labeledItem != null)
                        {
                            groundItemLabels.Add(labeledItem);
                        }
                    }
                    if (groundItemLabels.Any(labeledItem => labeledItem.ItemOnGround.Address == kv.Key.Address && labeledItem.Label.IsVisible))
                    {
                        var   rect      = groundItemLabels.First(labeledItem => labeledItem.ItemOnGround.Address == kv.Key.Address).Label.GetClientRect();
                        int   thickness = Settings.ShowBorder.Thickness.Value;
                        Color color     = Settings.ShowBorder.Color.Value;

                        if (Settings.ShowBorder.Customize.Enabled)
                        {
                            Entity e = kv.Key.GetComponent <WorldItem>().ItemEntity;
                            foreach (ShowBorderCustomizeSetting type in Settings.ShowBorder.Customize.GetSettings().Where(t => t.Enabled))
                            {
                                switch (type.BlockName)
                                {
                                case "Uniques":
                                    if (!e.GetComponent <Mods>().ItemRarity.Equals(Game.Rarity.Unique))
                                    {
                                        continue;
                                    }
                                    break;

                                case "Sockets":
                                    if (!new int[] { 0, 3, 4, 5 }.Contains(kv.Value.IconIndex))
                                    {
                                        continue;
                                    }
                                    break;

                                case "RGB":
                                    if (!kv.Value.IconIndex.Equals(1))
                                    {
                                        continue;
                                    }
                                    break;

                                case "CraftingBases":
                                    if (!kv.Value.IconIndex.Equals(2))
                                    {
                                        continue;
                                    }
                                    break;

                                default:
                                    if (!e.Path.Contains(type.BlockName))
                                    {
                                        continue;
                                    }
                                    break;
                                }

                                thickness = type.Thickness.Value;
                                color     = type.Color.Value;
                                break;
                            }
                        }

                        if (thickness > 0 &&
                            (model.Internal.IngameState.IngameUi.InventoryPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.InventoryPanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.CharacterPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.CharacterPanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.SocialPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.SocialPanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.TreePanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.TreePanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.OptionsPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.OptionsPanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.AchievementsPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.AchievementsPanel.GetClientRect()) : true) &&
                            (model.Internal.IngameState.IngameUi.WorldPanel.IsVisible ? !rect.IntersectsWith(model.Internal.IngameState.IngameUi.WorldPanel.GetClientRect()) : true))
                        {
                            rc.AddFrame(rect, color, thickness);
                        }
                    }
                }

                if (Settings.ShowText)
                {
                    Vec2 itemPos = kv.Key.GetComponent <Positioned>().GridPos;
                    var  delta   = itemPos - playerPos;

                    Vec2 vPadding      = new Vec2(5, 2);
                    Vec2 itemDrawnSize = drawItem(rc, kv.Value, delta, rightTopAnchor.X, y, vPadding, text, fontSize);
                    y += itemDrawnSize.Y + VMargin;
                }
            }
        }
Esempio n. 6
0
        public CustomItem(ItemsOnGroundLabelElement item)
        {
            CompleteItem = item;
            var groundItem = item.ItemOnGround.GetComponent <WorldItem>().ItemEntity;

            GroundItem = groundItem;
            Path       = groundItem.Path;
            var baseItemType = BasePlugin.API.GameController.Files.BaseItemTypes.Translate(Path);

            ClassName = baseItemType.ClassName;
            BaseName  = baseItemType.BaseName;
            Width     = baseItemType.Width;
            Height    = baseItemType.Height;
            var WeaponClass = new List <string>
            {
                "One Hand Mace",
                "Two Hand Mace",
                "One Hand Axe",
                "Two Hand Axe",
                "One Hand Sword",
                "Two Hand Sword",
                "Thrusting One Hand Sword",
                "Bow",
                "Claw",
                "Dagger",
                "Sceptre",
                "Staff",
                "Wand"
            };

            if (groundItem.HasComponent <Quality>())
            {
                var quality = groundItem.GetComponent <Quality>();
                Quality = quality.ItemQuality;
            }

            if (groundItem.HasComponent <Base>())
            {
                var @base = groundItem.GetComponent <Base>();
                IsElder  = @base.isElder;
                IsShaper = @base.isShaper;
            }

            if (groundItem.HasComponent <Mods>())
            {
                var mods = groundItem.GetComponent <Mods>();
                Rarity       = mods.ItemRarity;
                IsIdentified = mods.Identified;
                ItemLevel    = mods.ItemLevel;
            }

            if (groundItem.HasComponent <Sockets>())
            {
                try
                {
                    var sockets = groundItem.GetComponent <Sockets>();
                    IsRGB       = sockets.IsRGB;
                    Sockets     = sockets.NumberOfSockets;
                    LargestLink = sockets.LargestLinkSize;
                }
                catch { }
            }

            if (groundItem.HasComponent <Stack>())
            {
                var stack = groundItem.GetComponent <Stack>();
                Stack = stack.Size;
            }

            if (WeaponClass.Any(ClassName.Equals))
            {
                IsWeapon = true;
            }

            MapTier = groundItem.HasComponent <Map>() ? groundItem.GetComponent <Map>().Tier : 0;
        }
Esempio n. 7
0
        public bool MiscChecks(ItemsOnGroundLabelElement ItemEntity)
        {
            var Item      = ItemEntity.ItemOnGround.GetComponent <WorldItem>().ItemEntity;
            var ClassName = GameController.Files.BaseItemTypes.Translate(Item.Path).ClassName;

            if (Settings.Rares && Item.GetComponent <Mods>().ItemRarity == ItemRarity.Rare)
            {
                if (Settings.RareJewels && ClassName == "Jewel")
                {
                    return(true);
                }
                if (Settings.RareRings && ClassName == "Ring" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareRingsilvl)
                {
                    return(true);
                }
                if (Settings.RareAmulets && ClassName == "Amulet" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareAmuletsilvl)
                {
                    return(true);
                }
                if (Settings.RareBelts && ClassName == "Belt" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareBeltsilvl)
                {
                    return(true);
                }
                if (Settings.RareGloves && ClassName == "Gloves" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareGlovesilvl)
                {
                    return(true);
                }
                if (Settings.RareBoots && ClassName == "Boots" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareBootsilvl)
                {
                    return(true);
                }
                if (Settings.RareHelmets && ClassName == "Helmet" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareHelmetsilvl)
                {
                    return(true);
                }
                if (Settings.RareArmour && ClassName == "Body Armour" && Item.GetComponent <Mods>().ItemLevel >= Settings.RareArmourilvl)
                {
                    return(true);
                }
            }

            if (Settings.SixSocket && Item.GetComponent <Sockets>().NumberOfSockets == 6)
            {
                return(true);
            }
            if (Settings.SixLink && Item.GetComponent <Sockets>().LargestLinkSize == 6)
            {
                return(true);
            }
            if (Settings.RGB && Item.GetComponent <Sockets>().IsRGB)
            {
                return(true);
            }
            if (Settings.AllDivs && ClassName == "DivinationCard")
            {
                return(true);
            }
            if (Settings.AllCurrency && ClassName == "StackableCurrency")
            {
                return(true);
            }
            if (Settings.AllUniques && Item.GetComponent <Mods>().ItemRarity == ItemRarity.Unique)
            {
                return(true);
            }
            if (Settings.Maps && Item.GetComponent <PoeHUD.Poe.Components.Map>().Tier >= Settings.MapTier.Value)
            {
                return(true);
            }
            if (Settings.Maps && Item.GetComponent <PoeHUD.Poe.Components.Map>().Tier >= Settings.MapTier.Value)
            {
                return(true);
            }
            if (Settings.Maps && Settings.MapFragments && ClassName == "MapFragment")
            {
                return(true);
            }
            if (Settings.Maps && Settings.UniqueMap && Item.GetComponent <PoeHUD.Poe.Components.Map>().Tier >= 1 && Item.GetComponent <Mods>().ItemRarity == ItemRarity.Unique)
            {
                return(true);
            }
            if (Settings.QuestItems && ClassName == "QuestItem")
            {
                return(true);
            }
            if (Settings.Gems && Item.GetComponent <Quality>().ItemQuality >= Settings.GemQuality.Value && ClassName.Contains("Skill Gem"))
            {
                return(true);
            }


            return(false);
        }