protected override void HandleActionTargetDispatch(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor other, BaseEvent evt, Func <BaseAbilityActor, bool> targetPredicate)
{
if (this._abilityIdentity.isAuthority)
{
base.HandleActionTargetDispatch(actionConfig, instancedAbility, instancedModifier, other, evt, targetPredicate);
}
}
public void ApplyLevelBuff_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
LevelBuffSide overrideCurSide;
ApplyLevelBuff config = (ApplyLevelBuff)actionConfig;
float duration = base._Internal_CalculateApplyLevelBuffDuration(config, instancedAbility, evt);
uint runtimeID = instancedAbility.caster.runtimeID;
if (config.UseOverrideCurSide)
{
overrideCurSide = config.OverrideCurSide;
}
else
{
overrideCurSide = base.CalculateLevelBuffSide(instancedAbility.caster.runtimeID);
}
MPSendPacketContainer pc = Singleton <MPManager> .Instance.CreateSendPacket <Packet_Level_RequestLevelBuff>();
Packet_Level_RequestLevelBuff.StartPacket_Level_RequestLevelBuff(pc.builder);
Packet_Level_RequestLevelBuff.AddLevelBuffType(pc.builder, (byte)config.LevelBuff);
Packet_Level_RequestLevelBuff.AddEnteringSlow(pc.builder, config.EnteringTimeSlow);
Packet_Level_RequestLevelBuff.AddAllowRefresh(pc.builder, config.LevelBuffAllowRefresh);
Packet_Level_RequestLevelBuff.AddSide(pc.builder, (byte)overrideCurSide);
Packet_Level_RequestLevelBuff.AddOwnerRuntimeID(pc.builder, runtimeID);
Packet_Level_RequestLevelBuff.AddNotStartEffect(pc.builder, config.NotStartEffect);
Packet_Level_RequestLevelBuff.AddDuration(pc.builder, duration);
Packet_Level_RequestLevelBuff.AddInstancedAbilityID(pc.builder, (byte)instancedAbility.instancedAbilityID);
Packet_Level_RequestLevelBuff.AddActionLocalID(pc.builder, (byte)config.localID);
pc.Finish <Packet_Level_RequestLevelBuff>(Packet_Level_RequestLevelBuff.EndPacket_Level_RequestLevelBuff(pc.builder));
Singleton <MPManager> .Instance.SendReliableToPeer(0x21800001, 1, pc);
Singleton <MPLevelManager> .Instance.levelActor.GetPlugin <MPLevelAbilityHelperPlugin>().AttachPendingModifiersToNextLevelBuff(config, base._owner.runtimeID, instancedAbility.instancedAbilityID, (target != null) ? target.runtimeID : 0);
}
public void RemoveModifier_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
MoleMole.Config.RemoveModifier modifier = (MoleMole.Config.RemoveModifier)actionConfig;
if ((target != base._owner) && Singleton <MPEventManager> .Instance.IsIdentityAuthority(target.runtimeID))
{
target.abilityPlugin.TryRemoveModifier(instancedAbility, modifier.ModifierName);
}
}
protected override void HandleAction(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt)
{
if (this._abilityIdentity.isAuthority && base.EvaluateAbilityPredicate(actionConfig.Predicates, instancedAbility, instancedModifier, target, evt))
{
RecordInvokeEntryContext context;
this.StartRecordInvokeEntry(instancedAbility.instancedAbilityID, (instancedModifier == null) ? 0 : instancedModifier.instancedModifierID, (target != null) ? target.runtimeID : base._owner.runtimeID, actionConfig.localID, out context);
actionConfig.MPGetAuthorityHandler(this)(actionConfig, instancedAbility, instancedModifier, target, evt, ref context);
}
}
public void RemoveModifier_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
MoleMole.Config.RemoveModifier modifier = (MoleMole.Config.RemoveModifier)actionConfig;
if (target == base._owner)
{
base._owner.abilityPlugin.TryRemoveModifier(instancedAbility, modifier.ModifierName);
}
else if (Singleton <MPEventManager> .Instance.IsIdentityAuthority(target.runtimeID))
{
target.abilityPlugin.TryRemoveModifier(instancedAbility, modifier.ModifierName);
}
else
{
context.Finish(true);
}
}
public void TriggerAbility_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
base.TriggerAbilityHandler(actionConfig, instancedAbility, instancedModifier, target, null);
}
public void TriggerAbility_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
base.TriggerAbilityHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
context.Finish(true);
}
public static void STUB_RemoteMute(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, Table argument)
{
}
public static void STUB_AuthorityMute(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
context.Finish(false);
}
public void SetAnimatorBool_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
base.SetAnimatorBoolHandler(actionConfig, instancedAbility, instancedModifier, target, null);
}
public void AvatarSKillStart_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
base.AvatarSkillStartHandler(actionConfig, instancedAbility, instancedModifier, target, null);
}
public void Predicated_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
base.PredicatedHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
}
public void HealSP_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
this.HealSP_Common((HealSP)actionConfig, instancedAbility, target);
}
public void HealSP_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
this.HealSP_Common((HealSP)actionConfig, instancedAbility, target);
context.Finish(true);
}
public void HandleInvokes(Packet_Ability_InvocationTable table, int fromPeerID)
{
int invokesLength = table.InvokesLength;
for (int i = 0; i < invokesLength; i++)
{
AbilityInvokeEntry invokes = table.GetInvokes(i);
if (invokes.LocalID == 0xff)
{
if (this._abilityIdentity.isAuthority)
{
this.MetaAuthorityInvokeHandler(invokes);
}
else
{
this.MetaRemoteInvokeHandler(invokes);
}
}
else
{
ActorAbility parentAbility;
ActorModifier instancedModifierByID;
uint target = invokes.Target;
BaseAbilityActor actor = (target != 0) ? Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(target) : base._owner;
if (actor == null)
{
return;
}
int instancedModifierID = invokes.InstancedModifierID;
if (instancedModifierID != 0)
{
instancedModifierByID = this.GetInstancedModifierByID(instancedModifierID);
parentAbility = instancedModifierByID.parentAbility;
}
else
{
instancedModifierByID = null;
parentAbility = this.GetInstancedAbilityByID(invokes.InstancedAbilityID);
}
BaseActionContainer container = parentAbility.config.InvokeSites[invokes.LocalID];
if (container is ConfigAbilityAction)
{
ConfigAbilityAction actionConfig = (ConfigAbilityAction)container;
actionConfig.MPGetRemoteHandler(this)(actionConfig, parentAbility, instancedModifierByID, actor, invokes);
}
else
{
BaseAbilityMixin instancedMixin = null;
if (instancedModifierByID != null)
{
instancedMixin = instancedModifierByID.GetInstancedMixin(invokes.LocalID);
}
if (instancedMixin == null)
{
instancedMixin = parentAbility.GetInstancedMixin(invokes.LocalID);
}
instancedMixin.HandleMixinInvokeEntry(invokes, fromPeerID);
}
}
}
}
public void DamageByAttackValue_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
{
base.DamageByAttackValueHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
}
public void ApplyLevelBuff_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
}
public void AttachEffect_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
{
base.AttachEffectHandler(actionConfig, instancedAbility, instancedModifier, target, null);
}