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 bool MPTryApplyModifierByID(uint casterID, int instancedAbilityID, int modifierLocalID)
{
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(casterID);
if (actor == null)
{
return(false);
}
ActorAbility instancedAbilityByID = actor.mpAbilityPlugin.GetInstancedAbilityByID(instancedAbilityID);
if (instancedAbilityByID == null)
{
return(false);
}
ConfigAbilityModifier modifierConfig = instancedAbilityByID.config.ModifierIDMap[modifierLocalID];
return(this.ApplyModifier(instancedAbilityByID, modifierConfig) != null);
}
private void MetaHandleModifierChange(AbilityInvokeEntry table)
{
_metaModifierChange = table.GetArgument <MetaArg_ModifierChange>(_metaModifierChange);
if (((int)_metaModifierChange.Action) == 0)
{
ActorAbility instancedAbility = null;
ConfigAbilityModifier modifierConfig = null;
int index = table.InstancedModifierID - 1;
BaseAbilityActor actor = (table.Target != 0) ? Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(table.Target) : base._owner;
instancedAbility = ((MPActorAbilityPlugin)actor.abilityPlugin).GetInstancedAbilityByID(table.InstancedAbilityID);
modifierConfig = instancedAbility.config.ModifierIDMap[_metaModifierChange.ModifierLocalID];
base.AddModifierOnIndex(instancedAbility, modifierConfig, index);
}
else
{
ActorModifier instancedModifierByID = this.GetInstancedModifierByID(table.InstancedModifierID);
int num2 = table.InstancedModifierID - 1;
base.RemoveModifierOnIndex(instancedModifierByID, num2);
}
}
public ActorModifier(ActorAbility parentAbility, BaseAbilityActor owner, ConfigAbilityModifier config)
{
this.parentAbility = parentAbility;
this.config = config;
this.owner = owner;
List <BaseAbilityMixin> list = new List <BaseAbilityMixin>();
for (int i = 0; i < config.ModifierMixins.Length; i++)
{
BaseAbilityMixin item = owner.abilityPlugin.CreateInstancedAbilityMixin(parentAbility, this, config.ModifierMixins[i]);
if (item != null)
{
list.Add(item);
}
}
base.instancedMixins = list.ToArray();
for (int j = 0; j < base.instancedMixins.Length; j++)
{
base.instancedMixins[j].instancedMixinID = j;
}
this.stackIndices = new int[config.Properties.Count + config.EntityProperties.Count];
}
public static bool IsModifierDebuff(ConfigAbilityModifier config)
{
return(config.IsDebuff || ((config.State & (AbilityState.Tied | AbilityState.TargetLocked | AbilityState.Fragile | AbilityState.Weak | AbilityState.AttackSpeedDown | AbilityState.MoveSpeedDown | AbilityState.Frozen | AbilityState.Poisoned | AbilityState.Burn | AbilityState.Paralyze | AbilityState.Stun | AbilityState.Bleed)) != AbilityState.None));
}
public static bool IsModifierBuff(ConfigAbilityModifier config)
{
return(config.IsBuff || ((config.State & (AbilityState.Undamagable | AbilityState.MaxMoveSpeed | AbilityState.Immune | AbilityState.CritUp | AbilityState.Shielded | AbilityState.PowerUp | AbilityState.AttackSpeedUp | AbilityState.MoveSpeedUp | AbilityState.Endure)) != AbilityState.None));
}
protected override ActorModifier ApplyModifier(ActorAbility instancedAbility, ConfigAbilityModifier modifierConfig)
{
return(base.ApplyModifier(instancedAbility, modifierConfig));
}
protected override ActorModifier AddModifierOnIndex(ActorAbility instancedAbility, ConfigAbilityModifier modifierConfig, int index)
{
if (this._abilityIdentity.isAuthority)
{
RecordInvokeEntryContext context;
this.StartRecordInvokeEntry(instancedAbility.instancedAbilityID, index + 1, instancedAbility.caster.runtimeID, 0xff, out context);
Offset <MetaArg_ModifierChange> offset = MetaArg_ModifierChange.CreateMetaArg_ModifierChange(context.builder, ModifierAction.Added, (byte)modifierConfig.localID);
context.Finish <MetaArg_ModifierChange>(offset, AbilityInvokeArgument.MetaArg_ModifierChange);
return(base.AddModifierOnIndex(instancedAbility, modifierConfig, index));
}
return(null);
}
