Loot.Caching.ModifierCachePlayer Class Reference

Caches the item held and items equipped by players. When equips and held items change, their respective modifiers' effects are automatically called to detach and attach their delegations. More...

Inheritance diagram for Loot.Caching.ModifierCachePlayer:

Collaboration diagram for Loot.Caching.ModifierCachePlayer:

Public Member Functions
override void	Initialize ()
override void	PostUpdate ()

Private Member Functions
void	AddAttachItem (Item item, Modifier modifier)
void	AddDetachItem (Item item, Modifier modifier)
void	CacheItemModifierEffects (Item item)
void	CacheModifierEffects ()
IEnumerable< ModifierEffect >	GetModifierEffectsForDelegations (IEnumerable<(Item item, Modifier modifier)> list, ModifierDelegatorPlayer modDelegatorPlayer, Func< ModifierEffect, bool > conditionFunc)
	This method will return a list of ModifierEffects based on Modifiers passed to it More...
IEnumerable<(MethodInfo methodInfo, ModifierEffect effect)>	OrderDelegationList (IEnumerable<(Item item, Modifier modifier)> list, ModifierDelegatorPlayer modDelegatorPlayer)
	This method orders delegation entries following the rules of DelegationPrioritizationAttribute which orders by Early/Late prioritization and a level ranging from 0-999 which indicates how much that prioritization should be enforced. More...
void	UpdateAttachments ()
	This method handles updating all delegations First, it will perform 'manual' detachments calling ModifierEffect.DetachDelegations(ModifierDelegatorPlayer) then it will perform 'manual' attachments calling ModifierEffect.AttachDelegations(ModifierDelegatorPlayer) These will unbind/bind ModifierEffect.ResetEffects to ModifierDelegatorPlayer.OnResetEffects and set ModifierEffect.IsBeingDelegated to false or true. More...
void	UpdateCheatSheetCache ()
void	UpdateEquipsCache ()
void	UpdateHeldItemCache ()
bool	UpdateMouseItemCache ()
void	UpdateVanityCache ()

Static Private Member Functions
static bool	IsMouseUsable (Item item)

Private Attributes
List<(Item, Modifier)>	_attachList
List<(Item, Modifier)>	_detachList
bool	_forceEquipUpdate
List< Type >	_modifierEffects
Item[]	_oldCheatSheetEquips
Item[]	_oldEquips
Item	_oldMouseItem
int	_oldSelectedItem
Item[]	_oldVanityEquips

Detailed Description

Caches the item held and items equipped by players. When equips and held items change, their respective modifiers' effects are automatically called to detach and attach their delegations.

Definition at line 7 of file ModifierCacheCheatSheet.cs.

Member Function Documentation

void Loot.Caching.ModifierCachePlayer.AddAttachItem ( Item  item, Modifier  modifier  )

private

Definition at line 230 of file ModifierCachePlayer.cs.

References Loot.LootModItem.GetInfo(), and Loot.LootModItem.IsActivated.

        {
            LootModItem.GetInfo(item).IsActivated = true;
            _attachList.Add((item, modifier));
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.AddDetachItem ( Item  item, Modifier  modifier  )

private

Definition at line 224 of file ModifierCachePlayer.cs.

References Loot.LootModItem.GetInfo(), and Loot.LootModItem.IsActivated.

        {
            LootModItem.GetInfo(item).IsActivated = false;
            _detachList.Add((item, modifier));
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.CacheItemModifierEffects ( Item  item )

private

Definition at line 274 of file ModifierCachePlayer.cs.

References Loot.LootModItem.GetActivePool(), Loot.Api.Delegators.ModifierDelegatorPlayer.GetEffect(), and Loot.Api.Delegators.ModifierDelegatorPlayer.GetPlayer().

        {
            var mods = LootModItem.GetActivePool(item);
            foreach (var modifier in mods)
            {
                var effectsAttribute = modifier
                    .GetType()
                    .GetCustomAttribute<UsesEffectAttribute>();

                if (effectsAttribute == null)
                    continue;

                ModifierDelegatorPlayer modDelegatorPlayer = ModifierDelegatorPlayer.GetPlayer(player);
                foreach (Type effect in effectsAttribute.Effects)
                {
                    var modEffect = modDelegatorPlayer.GetEffect(effect);
                    if (modEffect != null && !_modifierEffects.Contains(modEffect.GetType()))
                    {
                        _modifierEffects.Add(modEffect.GetType());
                    }
                }
            }
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.CacheModifierEffects ( )

private

Definition at line 236 of file ModifierCachePlayer.cs.

References Loot.Hacks.CheatedItemHackGlobalItem.GetInfo(), and Loot.Hacks.CheatedItemHackGlobalItem.IsCheated.

        {
            if (!_forceEquipUpdate && Ready)
                return;

            _modifierEffects.Clear();

            for (int i = 0; i < 8 + player.extraAccessorySlots; i++)
            {
                var equip = player.armor[i];
                if (equip != null && !equip.IsAir)
                {
                    CacheItemModifierEffects(equip);
                }
            }

            // vanity
            for (int k = 13; k < 18 + player.extraAccessorySlots; k++)
            {
                var equip = player.armor[k];
                if (equip != null
                    && !equip.IsAir
                    && CheatedItemHackGlobalItem.GetInfo(equip).IsCheated)
                {
                    CacheItemModifierEffects(equip);
                }
            }

            if (Main.mouseItem != null && !Main.mouseItem.IsAir && Main.mouseItem.IsWeapon())
            {
                CacheItemModifierEffects(Main.mouseItem);
            }
            else if (player.HeldItem != null && !player.HeldItem.IsAir && player.HeldItem.IsWeapon())
            {
                CacheItemModifierEffects(player.HeldItem);
            }
        }

Here is the call graph for this function:

IEnumerable<ModifierEffect> Loot.Caching.ModifierCachePlayer.GetModifierEffectsForDelegations ( IEnumerable<(Item item, Modifier modifier)>  list, ModifierDelegatorPlayer  modDelegatorPlayer, Func< ModifierEffect, bool >  conditionFunc  )

private

This method will return a list of ModifierEffects based on Modifiers passed to it

Definition at line 61 of file ModifierCachePlayer.cs.

        {
            var tempList = new List<ModifierEffect>();
            foreach (var delegationTuple in list)
            {
                var effectsAttribute =
                    delegationTuple.modifier
                        .GetType()
                        .GetCustomAttribute<UsesEffectAttribute>();

                if (effectsAttribute == null) continue;
                tempList.AddRange(effectsAttribute.Effects
                    .Select(modDelegatorPlayer.GetEffect)
                    .Where(modEffect => modEffect != null && conditionFunc.Invoke(modEffect)));
            }

            return tempList;
        }

override void Loot.Caching.ModifierCachePlayer.Initialize

(

)

Definition at line 44 of file ModifierCachePlayer.cs.

        {
            _oldSelectedItem = player.selectedItem;
            _oldMouseItem = null;
            _oldEquips = new Item[8];
            _oldVanityEquips = new Item[8];
            _forceEquipUpdate = false;
            _oldCheatSheetEquips = new Item[6]; // MaxExtraAccessories = 6
            _modifierEffects = new List<Type>();
            _detachList = new List<(Item, Modifier)>();
            _attachList = new List<(Item, Modifier)>();
            Ready = false;
        }

static bool Loot.Caching.ModifierCachePlayer.IsMouseUsable ( Item  item )

staticprivate

IEnumerable<(MethodInfo methodInfo, ModifierEffect effect)> Loot.Caching.ModifierCachePlayer.OrderDelegationList ( IEnumerable<(Item item, Modifier modifier)>  list, ModifierDelegatorPlayer  modDelegatorPlayer  )

private

This method orders delegation entries following the rules of DelegationPrioritizationAttribute which orders by Early/Late prioritization and a level ranging from 0-999 which indicates how much that prioritization should be enforced.

Definition at line 146 of file ModifierCachePlayer.cs.

        {
            var delegationEntries = new List<(MethodInfo, ModifierEffect)>();
            var effects = GetModifierEffectsForDelegations(list, modDelegatorPlayer, e => true);

            foreach (var modEffect in effects)
            {
                (MethodInfo, ModifierEffect) MakeEntry((MethodInfo, DelegationPrioritizationAttribute) tuple)
                    => (tuple.Item1, modEffect);

                var delegatedMethods = modEffect
                    .GetType()
                    .GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)
                    .Where(x => x.GetCustomAttributes(typeof(AutoDelegation), false).Length > 0)
                    .Select(x => (methodInfo: x, attribute: (DelegationPrioritizationAttribute) x.GetCustomAttribute(typeof(DelegationPrioritizationAttribute))))
                    .ToList();

                delegationEntries.AddRange(
                    delegatedMethods
                        .Where(x => x.attribute?.DelegationPrioritization == DelegationPrioritization.Early)
                        .OrderByDescending(x => x.attribute.DelegationLevel)
                        .Select(MakeEntry));

                delegationEntries.AddRange(
                    delegatedMethods
                        .Where(x => x.attribute == null)
                        .Select(MakeEntry));

                delegationEntries.AddRange(
                    delegatedMethods
                        .Where(x => x.attribute?.DelegationPrioritization == DelegationPrioritization.Late)
                        .OrderByDescending(x => x.attribute.DelegationLevel)
                        .Select(MakeEntry));
            }

            return delegationEntries;
        }

override void Loot.Caching.ModifierCachePlayer.PostUpdate

(

)

Definition at line 184 of file ModifierCachePlayer.cs.

        {
            // If our equips cache is not the right size we resize it and force an update
            if (_oldEquips.Length != 8 + player.extraAccessorySlots)
            {
                Ready = false;
                _forceEquipUpdate = true;
                Array.Resize(ref _oldEquips, 8 + player.extraAccessorySlots);
            }

            if (_oldVanityEquips.Length != 8 + player.extraAccessorySlots)
            {
                Ready = false;
                _forceEquipUpdate = true;
                Array.Resize(ref _oldVanityEquips, 8 + player.extraAccessorySlots);
            }

            _detachList.Clear();
            _attachList.Clear();

            UpdateEquipsCache();
            if (ModSupportTunneler.GetModSupport<CheatSheetSupport>().ModIsLoaded)
            {
                UpdateCheatSheetCache();
            }

            UpdateVanityCache();

            if (!UpdateMouseItemCache())
            {
                UpdateHeldItemCache();
            }

            CacheModifierEffects();
            UpdateAttachments();

            _forceEquipUpdate = false;
            Ready = true;
        }

void Loot.Caching.ModifierCachePlayer.UpdateAttachments ( )

private

This method handles updating all delegations First, it will perform 'manual' detachments calling ModifierEffect.DetachDelegations(ModifierDelegatorPlayer) then it will perform 'manual' attachments calling ModifierEffect.AttachDelegations(ModifierDelegatorPlayer) These will unbind/bind ModifierEffect.ResetEffects to ModifierDelegatorPlayer.OnResetEffects and set ModifierEffect.IsBeingDelegated to false or true.

After this, the automatic detachments/attachments are done which will bind any methods to whichever method noted in their AutoDelegation attribute.

Definition at line 90 of file ModifierCachePlayer.cs.

References Loot.Api.Attributes.AutoDelegation.Attach(), Loot.Api.Attributes.AutoDelegation.Detach(), and Loot.Api.Delegators.ModifierDelegatorPlayer.GetPlayer().

        {
            ModifierDelegatorPlayer modDelegatorPlayer = ModifierDelegatorPlayer.GetPlayer(player);

            // Manual detach
            var detachEffects = GetModifierEffectsForDelegations(_detachList, modDelegatorPlayer, (e) => e.IsBeingDelegated && !_modifierEffects.Contains(e.GetType()));
            var attachEffects = GetModifierEffectsForDelegations(_attachList, modDelegatorPlayer, (e) => !e.IsBeingDelegated);
            // Automatic delegation lists
            var orderedDetachList = OrderDelegationList(_detachList, modDelegatorPlayer)
                .Where(x => x.effect.IsBeingDelegated && !_modifierEffects.Contains(x.effect.GetType()))
                .GroupBy(x => x.methodInfo)
                .Select(x => x.First())
                .ToList();

            var orderedAttachList = OrderDelegationList(_attachList, modDelegatorPlayer)
                .Where(x => !x.effect.IsBeingDelegated)
                .GroupBy(x => x.methodInfo)
                .Select(x => x.First())
                .ToList();

            // Manual detach
            foreach (var effect in detachEffects.Distinct())
            {
                modDelegatorPlayer.ResetEffectsEvent -= effect.ResetEffects;
                effect._DetachDelegations(modDelegatorPlayer);
                effect.IsBeingDelegated = false;
            }

            // Manual attach
            foreach (var effect in attachEffects.Distinct())
            {
                modDelegatorPlayer.ResetEffectsEvent += effect.ResetEffects;
                effect.AttachDelegations(modDelegatorPlayer);
                effect.IsBeingDelegated = true;
            }

            // Auto delegation detach
            foreach (var (methodInfo, effect) in orderedDetachList)
            {
                var attr = methodInfo.GetCustomAttribute<AutoDelegation>();
                attr.Detach(modDelegatorPlayer, methodInfo, effect);
            }

            // Auto delegation attach
            foreach (var (methodInfo, effect) in orderedAttachList)
            {
                var attr = methodInfo.GetCustomAttribute<AutoDelegation>();
                attr.Attach(modDelegatorPlayer, methodInfo, effect);
            }
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.UpdateCheatSheetCache ( )

private

Definition at line 11 of file ModifierCacheCheatSheet.cs.

References Loot.LootModItem.GetActivePool().

        {
            // get cheat sheet slots
            var curEquips = CheatSheetInterface.GetEnabledExtraAccessories(player).Take(_oldCheatSheetEquips.Length).ToArray();

            // go over enabled slots
            for (int i = 0; i < curEquips.Length; i++)
            {
                var oldEquip = _oldCheatSheetEquips[i];
                var newEquip = curEquips[i];

                // update delegations
                if (oldEquip != null && newEquip == oldEquip)
                {
                    continue;
                }

                Ready = false;

                // detach old first
                if (oldEquip != null && !oldEquip.IsAir)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(oldEquip))
                    {
                        AddDetachItem(oldEquip, m);
                    }
                }

                // attach new
                if (newEquip != null && !newEquip.IsAir)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(newEquip))
                    {
                        AddAttachItem(newEquip, m);
                    }
                }

                _oldCheatSheetEquips[i] = newEquip;
            }

            // current enabled is smaller than total
            if (curEquips.Length >= _oldCheatSheetEquips.Count(x => x != null))
            {
                return;
            }

            var outOfDateEquips = _oldCheatSheetEquips.Skip(curEquips.Length);
            // for all disabled slots but still had a registered item, detach it
            foreach (var item in outOfDateEquips.Where(x => x != null && !x.IsAir))
            {
                Ready = false;
                foreach (Modifier m in LootModItem.GetActivePool(item))
                {
                    AddDetachItem(item, m);
                }
            }
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.UpdateEquipsCache ( )

private

Definition at line 105 of file ModifierCacheVanilla.cs.

References Loot.LootModItem.GetActivePool().

        {
            for (int i = 0; i < 8 + player.extraAccessorySlots; i++)
            {
                var oldEquip = _oldEquips[i];
                var newEquip = player.armor[i];

                // If equip slot needs an update
                if (!_forceEquipUpdate && oldEquip != null && newEquip == oldEquip)
                    continue;

                Ready = false;

                // detach old first
                if (oldEquip != null && !oldEquip.IsAir)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(oldEquip))
                    {
                        AddDetachItem(oldEquip, m);
                    }
                }

                // attach new
                if (newEquip != null && !newEquip.IsAir)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(newEquip))
                    {
                        AddAttachItem(newEquip, m);
                    }
                }

                _oldEquips[i] = newEquip;
            }
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.UpdateHeldItemCache ( )

private

Definition at line 45 of file ModifierCacheVanilla.cs.

References Loot.LootModItem.GetActivePool().

        {
            // If held item needs an update
            if (_oldSelectedItem == player.selectedItem)
                return;

            Ready = false;

            // detach old held item
            Item oldSelectedItem = player.inventory[_oldSelectedItem];
            if (oldSelectedItem != null && !oldSelectedItem.IsAir && IsMouseUsable(oldSelectedItem))
            {
                foreach (Modifier m in LootModItem.GetActivePool(oldSelectedItem))
                {
                    AddDetachItem(oldSelectedItem, m);
                }
            }

            // attach new held item
            if (player.HeldItem != null && !player.HeldItem.IsAir && IsMouseUsable(player.HeldItem))
            {
                foreach (Modifier m in LootModItem.GetActivePool(player.HeldItem))
                {
                    AddAttachItem(player.HeldItem, m);
                }
            }

            _oldSelectedItem = player.selectedItem;
        }

Here is the call graph for this function:

bool Loot.Caching.ModifierCachePlayer.UpdateMouseItemCache ( )

private

Definition at line 75 of file ModifierCacheVanilla.cs.

References Loot.LootModItem.GetActivePool().

        {
            // If held item needs an update
            if (_oldMouseItem != null && _oldMouseItem == Main.mouseItem)
                return false;

            Ready = false;

            // detach old mouse item
            if (_oldMouseItem != null && !_oldMouseItem.IsAir && IsMouseUsable(_oldMouseItem))
            {
                foreach (Modifier m in LootModItem.GetActivePool(_oldMouseItem))
                {
                    AddDetachItem(_oldMouseItem, m);
                }
            }

            // attach new held item
            if (Main.mouseItem != null && !Main.mouseItem.IsAir && IsMouseUsable(Main.mouseItem))
            {
                foreach (Modifier m in LootModItem.GetActivePool(player.HeldItem))
                {
                    AddAttachItem(Main.mouseItem, m);
                }
            }

            _oldMouseItem = Main.mouseItem;
            return Main.mouseItem != null && !Main.mouseItem.IsAir;
        }

Here is the call graph for this function:

void Loot.Caching.ModifierCachePlayer.UpdateVanityCache ( )

private

Definition at line 9 of file ModifierCacheVanilla.cs.

References Loot.LootModItem.GetActivePool(), Loot.Hacks.CheatedItemHackGlobalItem.GetInfo(), and Loot.Hacks.CheatedItemHackGlobalItem.IsCheated.

        {
            // vanity
            for (int i = 13; i < 18 + player.extraAccessorySlots; i++)
            {
                var oldEquip = _oldVanityEquips[i - 13];
                var newEquip = player.armor[i];

                // If equip slot needs an update
                if (!_forceEquipUpdate && oldEquip != null && newEquip == oldEquip)
                    continue;

                Ready = false;

                // detach old first
                if (oldEquip != null && !oldEquip.IsAir && CheatedItemHackGlobalItem.GetInfo(oldEquip).IsCheated)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(oldEquip))
                    {
                        AddDetachItem(oldEquip, m);
                    }
                }

                // attach new
                if (newEquip != null && !newEquip.IsAir && CheatedItemHackGlobalItem.GetInfo(newEquip).IsCheated)
                {
                    foreach (Modifier m in LootModItem.GetActivePool(newEquip))
                    {
                        AddAttachItem(newEquip, m);
                    }
                }

                _oldVanityEquips[i - 13] = newEquip;
            }
        }

Here is the call graph for this function:

Member Data Documentation

List<(Item, Modifier)> Loot.Caching.ModifierCachePlayer._attachList

private

Definition at line 42 of file ModifierCachePlayer.cs.

List<(Item, Modifier)> Loot.Caching.ModifierCachePlayer._detachList

private

Definition at line 41 of file ModifierCachePlayer.cs.

bool Loot.Caching.ModifierCachePlayer._forceEquipUpdate

private

Definition at line 38 of file ModifierCachePlayer.cs.

List<Type> Loot.Caching.ModifierCachePlayer._modifierEffects

private

Definition at line 40 of file ModifierCachePlayer.cs.

Item [] Loot.Caching.ModifierCachePlayer._oldCheatSheetEquips

private

Definition at line 39 of file ModifierCachePlayer.cs.

Item [] Loot.Caching.ModifierCachePlayer._oldEquips

private

Definition at line 36 of file ModifierCachePlayer.cs.

Item Loot.Caching.ModifierCachePlayer._oldMouseItem

private

Definition at line 35 of file ModifierCachePlayer.cs.

int Loot.Caching.ModifierCachePlayer._oldSelectedItem

private

Definition at line 34 of file ModifierCachePlayer.cs.

Item [] Loot.Caching.ModifierCachePlayer._oldVanityEquips

private

Definition at line 37 of file ModifierCachePlayer.cs.