private EffectiveAttachModifier AttachLevelBuffModifier(PendingApplyModifierEntry entry)
        {
            BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(entry.ownerID);

            if (actor == null)
            {
                return(null);
            }
            ActorAbility instancedAbilityByID = actor.mpAbilityPlugin.GetInstancedAbilityByID(entry.instancedAbilityID);

            if (instancedAbilityByID == null)
            {
                return(null);
            }
            BaseAbilityActor other = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(entry.otherTargetID);

            EffectiveAttachModifier modifier = new EffectiveAttachModifier {
                ownerID            = entry.ownerID,
                config             = entry.config,
                instancedAbilityID = entry.instancedAbilityID
            };

            foreach (AttachModifier modifier2 in entry.config.AttachModifiers)
            {
                BaseAbilityActor   actor3;
                BaseAbilityActor[] actorArray;
                bool flag;
                actor.mpAbilityPlugin.ExternalResolveTarget(modifier2.Target, modifier2.TargetOption, instancedAbilityByID, other, out actor3, out actorArray, out flag);
                ConfigAbilityModifier modifier3 = instancedAbilityByID.config.Modifiers[modifier2.ModifierName];
                int localID = modifier3.localID;
                if (actor3 != null)
                {
                    Singleton <MPManager> .Instance.GetIdentity <BaseAbilityEntityIdentiy>(actor3.runtimeID).Command_TryApplyModifier(entry.ownerID, entry.instancedAbilityID, localID);

                    SubModifierLocater item = new SubModifierLocater {
                        modifierOwnerID = actor3.runtimeID,
                        modifierLocalID = localID
                    };
                    modifier.attachedModifiers.Add(item);
                }
                else if (actorArray != null)
                {
                    for (int i = 0; i < actorArray.Length; i++)
                    {
                        if (actorArray[i] != null)
                        {
                            Singleton <MPManager> .Instance.GetIdentity <BaseAbilityEntityIdentiy>(actorArray[i].runtimeID).Command_TryApplyModifier(entry.ownerID, entry.instancedAbilityID, localID);

                            SubModifierLocater locater2 = new SubModifierLocater {
                                modifierOwnerID = actorArray[i].runtimeID,
                                modifierLocalID = localID
                            };
                            modifier.attachedModifiers.Add(locater2);
                        }
                    }
                }
            }
            return(modifier);
        }
        public void AttachPendingModifiersToNextLevelBuff(ApplyLevelBuff config, uint ownerID, int instancedAbilityID, uint otherTargetID)
        {
            PendingApplyModifierEntry item = new PendingApplyModifierEntry {
                config             = config,
                ownerID            = ownerID,
                instancedAbilityID = instancedAbilityID,
                otherTargetID      = otherTargetID
            };

            this._pendingApplyLevelBuffs.Add(item);
        }
 private void AttachCurrent(uint sourceID)
 {
     for (int i = 0; i < this._pendingApplyLevelBuffs.Count; i++)
     {
         PendingApplyModifierEntry entry = this._pendingApplyLevelBuffs[i];
         if (entry.ownerID == sourceID)
         {
             this._curAttachedEntry = this.AttachLevelBuffModifier(this._pendingApplyLevelBuffs[i]);
             break;
         }
     }
     this._pendingApplyLevelBuffs.Clear();
 }