mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 08:25:20 +01:00
560 lines
24 KiB
C#
560 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using FlatBuffers;
|
|
using MoleMole.Config;
|
|
using MoleMole.MPProtocol;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public class MPActorAbilityPlugin : ActorAbilityPlugin
|
|
{
|
|
public delegate void MPRemoteActionHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry);
|
|
|
|
public delegate void MPAuthorityActionHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context);
|
|
|
|
public const int INVOCATION_META_LOCALID = 255;
|
|
|
|
private FlatBufferBuilder _invokeTableBuilder = new FlatBufferBuilder(128);
|
|
|
|
private List<Offset<AbilityInvokeEntry>> _invokeTableOffsets = new List<Offset<AbilityInvokeEntry>>();
|
|
|
|
private static MetaArg_ModifierChange _metaModifierChange = new MetaArg_ModifierChange();
|
|
|
|
private static MetaArg_AbilityControl _metaAbilityControl = new MetaArg_AbilityControl();
|
|
|
|
private static MetaArg_Command_ModifierChangeRequest _metaModifierReq = new MetaArg_Command_ModifierChangeRequest();
|
|
|
|
protected BaseAbilityEntityIdentiy _abilityIdentity;
|
|
|
|
public MPActorAbilityPlugin(BaseAbilityActor abilityActor)
|
|
: base(abilityActor)
|
|
{
|
|
}
|
|
|
|
public void FireEffect_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
FireEffectHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void FireEffect_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
FireEffectHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void ApplyModifier_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
ApplyModifier applyModifier = (ApplyModifier)actionConfig;
|
|
if (target == _owner)
|
|
{
|
|
_owner.abilityPlugin.ApplyModifier(instancedAbility, applyModifier.ModifierName);
|
|
}
|
|
else if (Singleton<MPEventManager>.Instance.IsIdentityAuthority(target.runtimeID))
|
|
{
|
|
target.abilityPlugin.ApplyModifier(instancedAbility, applyModifier.ModifierName);
|
|
}
|
|
else
|
|
{
|
|
context.Finish(true);
|
|
}
|
|
}
|
|
|
|
public void ApplyModifier_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
ApplyModifier applyModifier = (ApplyModifier)actionConfig;
|
|
if (target != _owner && Singleton<MPEventManager>.Instance.IsIdentityAuthority(target.runtimeID))
|
|
{
|
|
target.abilityPlugin.ApplyModifier(instancedAbility, applyModifier.ModifierName);
|
|
}
|
|
}
|
|
|
|
public void AttachEffect_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
AttachEffectHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void AttachEffect_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
AttachEffectHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void DamageByAttackValue_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
DamageByAttackValueHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
}
|
|
|
|
public void Predicated_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
PredicatedHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
}
|
|
|
|
private void HealSP_Common(HealSP config, ActorAbility instancedAbility, BaseAbilityActor target)
|
|
{
|
|
float num = instancedAbility.Evaluate(config.Amount);
|
|
if (Singleton<MPEventManager>.Instance.IsIdentityAuthority(target.runtimeID))
|
|
{
|
|
target.HealSP(num);
|
|
}
|
|
if ((bool)target.isAlive && !config.MuteHealEffect && num > 0f)
|
|
{
|
|
target.entity.FireEffect("Ability_HealSP");
|
|
}
|
|
}
|
|
|
|
public void HealSP_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
HealSP_Common((HealSP)actionConfig, instancedAbility, target);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void HealSP_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
HealSP_Common((HealSP)actionConfig, instancedAbility, target);
|
|
}
|
|
|
|
public void AvatarSkillStart_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
AvatarSkillStartHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void AvatarSKillStart_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
AvatarSkillStartHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void ActTimeSlow_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
TimeSlowHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void ActTimeSlow_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
TimeSlowHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void SetAnimatorBool_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
SetAnimatorBoolHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void SetAnimatorBool_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
SetAnimatorBoolHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void TriggerAbility_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
TriggerAbilityHandler(actionConfig, instancedAbility, instancedModifier, target, evt);
|
|
context.Finish(true);
|
|
}
|
|
|
|
public void TriggerAbility_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
TriggerAbilityHandler(actionConfig, instancedAbility, instancedModifier, target, null);
|
|
}
|
|
|
|
public void ApplyLevelBuff_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
ApplyLevelBuff applyLevelBuff = (ApplyLevelBuff)actionConfig;
|
|
float duration = _Internal_CalculateApplyLevelBuffDuration(applyLevelBuff, instancedAbility, evt);
|
|
uint runtimeID = instancedAbility.caster.runtimeID;
|
|
LevelBuffSide levelBuffSide = ((!applyLevelBuff.UseOverrideCurSide) ? CalculateLevelBuffSide(instancedAbility.caster.runtimeID) : applyLevelBuff.OverrideCurSide);
|
|
MPSendPacketContainer pc = Singleton<MPManager>.Instance.CreateSendPacket<Packet_Level_RequestLevelBuff>();
|
|
Packet_Level_RequestLevelBuff.StartPacket_Level_RequestLevelBuff(pc.builder);
|
|
Packet_Level_RequestLevelBuff.AddLevelBuffType(pc.builder, (byte)applyLevelBuff.LevelBuff);
|
|
Packet_Level_RequestLevelBuff.AddEnteringSlow(pc.builder, applyLevelBuff.EnteringTimeSlow);
|
|
Packet_Level_RequestLevelBuff.AddAllowRefresh(pc.builder, applyLevelBuff.LevelBuffAllowRefresh);
|
|
Packet_Level_RequestLevelBuff.AddSide(pc.builder, (byte)levelBuffSide);
|
|
Packet_Level_RequestLevelBuff.AddOwnerRuntimeID(pc.builder, runtimeID);
|
|
Packet_Level_RequestLevelBuff.AddNotStartEffect(pc.builder, applyLevelBuff.NotStartEffect);
|
|
Packet_Level_RequestLevelBuff.AddDuration(pc.builder, duration);
|
|
Packet_Level_RequestLevelBuff.AddInstancedAbilityID(pc.builder, (byte)instancedAbility.instancedAbilityID);
|
|
Packet_Level_RequestLevelBuff.AddActionLocalID(pc.builder, (byte)applyLevelBuff.localID);
|
|
pc.Finish(Packet_Level_RequestLevelBuff.EndPacket_Level_RequestLevelBuff(pc.builder));
|
|
Singleton<MPManager>.Instance.SendReliableToPeer(562036737u, 1, pc);
|
|
Singleton<MPLevelManager>.Instance.levelActor.GetPlugin<MPLevelAbilityHelperPlugin>().AttachPendingModifiersToNextLevelBuff(applyLevelBuff, _owner.runtimeID, instancedAbility.instancedAbilityID, (target != null) ? target.runtimeID : 0u);
|
|
}
|
|
|
|
public void ApplyLevelBuff_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
}
|
|
|
|
public void RemoveModifier_AuthorityHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt, ref RecordInvokeEntryContext context)
|
|
{
|
|
RemoveModifier removeModifier = (RemoveModifier)actionConfig;
|
|
if (target == _owner)
|
|
{
|
|
_owner.abilityPlugin.TryRemoveModifier(instancedAbility, removeModifier.ModifierName);
|
|
}
|
|
else if (Singleton<MPEventManager>.Instance.IsIdentityAuthority(target.runtimeID))
|
|
{
|
|
target.abilityPlugin.TryRemoveModifier(instancedAbility, removeModifier.ModifierName);
|
|
}
|
|
else
|
|
{
|
|
context.Finish(true);
|
|
}
|
|
}
|
|
|
|
public void RemoveModifier_RemoteHandler(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, AbilityInvokeEntry invokeEntry)
|
|
{
|
|
RemoveModifier removeModifier = (RemoveModifier)actionConfig;
|
|
if (target != _owner && Singleton<MPEventManager>.Instance.IsIdentityAuthority(target.runtimeID))
|
|
{
|
|
target.abilityPlugin.TryRemoveModifier(instancedAbility, removeModifier.ModifierName);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
private void FlushRecordInvokeEntriesAndSend()
|
|
{
|
|
if (_invokeTableOffsets.Count > 0)
|
|
{
|
|
MPSendPacketContainer pc = Singleton<MPManager>.Instance.CreateSendPacket(typeof(Packet_Ability_InvocationTable), _invokeTableBuilder);
|
|
VectorOffset invokesOffset = Packet_Ability_InvocationTable.CreateInvokesVector(pc.builder, _invokeTableOffsets.ToArray());
|
|
Offset<Packet_Ability_InvocationTable> offset = Packet_Ability_InvocationTable.CreatePacket_Ability_InvocationTable(pc.builder, invokesOffset);
|
|
pc.Finish(offset);
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
Singleton<MPManager>.Instance.SendReliableToOthers(_owner.runtimeID, pc);
|
|
}
|
|
else
|
|
{
|
|
Singleton<MPManager>.Instance.SendReliableToPeer(_owner.runtimeID, _abilityIdentity.GetPeerID(), pc);
|
|
}
|
|
_invokeTableBuilder.Clear();
|
|
_invokeTableOffsets.Clear();
|
|
}
|
|
}
|
|
|
|
protected override ActorModifier ApplyModifier(ActorAbility instancedAbility, ConfigAbilityModifier modifierConfig)
|
|
{
|
|
return base.ApplyModifier(instancedAbility, modifierConfig);
|
|
}
|
|
|
|
protected override void RemoveModifier(ActorModifier modifier, int index)
|
|
{
|
|
base.RemoveModifier(modifier, index);
|
|
}
|
|
|
|
public void StartRecordInvokeEntry(int instancedAbilityID, int instancedModifierID, uint targetRuntimeID, int localID, out RecordInvokeEntryContext entry)
|
|
{
|
|
entry = default(RecordInvokeEntryContext);
|
|
entry.instancedAbilityID = (byte)instancedAbilityID;
|
|
entry.instanceModifierID = (byte)instancedModifierID;
|
|
entry.targetID = ((targetRuntimeID != _owner.runtimeID) ? targetRuntimeID : 0u);
|
|
entry.localID = (byte)localID;
|
|
entry.builder = _invokeTableBuilder;
|
|
entry.outOffsetLs = _invokeTableOffsets;
|
|
}
|
|
|
|
protected override void HandleAction(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor target, BaseEvent evt)
|
|
{
|
|
if (_abilityIdentity.isAuthority && EvaluateAbilityPredicate(actionConfig.Predicates, instancedAbility, instancedModifier, target, evt))
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(instancedAbility.instancedAbilityID, (instancedModifier != null) ? instancedModifier.instancedModifierID : 0, (target != null) ? target.runtimeID : _owner.runtimeID, actionConfig.localID, out entry);
|
|
actionConfig.MPGetAuthorityHandler(this)(actionConfig, instancedAbility, instancedModifier, target, evt, ref entry);
|
|
}
|
|
}
|
|
|
|
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 == byte.MaxValue)
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
MetaAuthorityInvokeHandler(invokes);
|
|
}
|
|
else
|
|
{
|
|
MetaRemoteInvokeHandler(invokes);
|
|
}
|
|
continue;
|
|
}
|
|
uint target = invokes.Target;
|
|
BaseAbilityActor baseAbilityActor = ((target != 0) ? Singleton<EventManager>.Instance.GetActor<BaseAbilityActor>(target) : _owner);
|
|
if (baseAbilityActor == null)
|
|
{
|
|
break;
|
|
}
|
|
int instancedModifierID = invokes.InstancedModifierID;
|
|
ActorModifier actorModifier;
|
|
ActorAbility actorAbility;
|
|
if (instancedModifierID != 0)
|
|
{
|
|
actorModifier = GetInstancedModifierByID(instancedModifierID);
|
|
actorAbility = actorModifier.parentAbility;
|
|
}
|
|
else
|
|
{
|
|
actorModifier = null;
|
|
actorAbility = GetInstancedAbilityByID(invokes.InstancedAbilityID);
|
|
}
|
|
BaseActionContainer baseActionContainer = actorAbility.config.InvokeSites[invokes.LocalID];
|
|
if (baseActionContainer is ConfigAbilityAction)
|
|
{
|
|
ConfigAbilityAction configAbilityAction = (ConfigAbilityAction)baseActionContainer;
|
|
configAbilityAction.MPGetRemoteHandler(this)(configAbilityAction, actorAbility, actorModifier, baseAbilityActor, invokes);
|
|
continue;
|
|
}
|
|
BaseAbilityMixin baseAbilityMixin = null;
|
|
if (actorModifier != null)
|
|
{
|
|
baseAbilityMixin = actorModifier.GetInstancedMixin(invokes.LocalID);
|
|
}
|
|
if (baseAbilityMixin == null)
|
|
{
|
|
baseAbilityMixin = actorAbility.GetInstancedMixin(invokes.LocalID);
|
|
}
|
|
baseAbilityMixin.HandleMixinInvokeEntry(invokes, fromPeerID);
|
|
}
|
|
}
|
|
|
|
protected override ActorModifier AddModifierOnIndex(ActorAbility instancedAbility, ConfigAbilityModifier modifierConfig, int index)
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(instancedAbility.instancedAbilityID, index + 1, instancedAbility.caster.runtimeID, 255, out entry);
|
|
Offset<MetaArg_ModifierChange> offset = MetaArg_ModifierChange.CreateMetaArg_ModifierChange(entry.builder, ModifierAction.Added, (byte)modifierConfig.localID);
|
|
entry.Finish(offset, AbilityInvokeArgument.MetaArg_ModifierChange);
|
|
return base.AddModifierOnIndex(instancedAbility, modifierConfig, index);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void RemoveModifierOnIndex(ActorModifier modifier, int index)
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(0, modifier.instancedModifierID, 0u, 255, out entry);
|
|
Offset<MetaArg_ModifierChange> offset = MetaArg_ModifierChange.CreateMetaArg_ModifierChange(entry.builder, ModifierAction.Removed, (byte)modifier.config.localID);
|
|
entry.Finish(offset, AbilityInvokeArgument.MetaArg_ModifierChange);
|
|
base.RemoveModifierOnIndex(modifier, index);
|
|
}
|
|
}
|
|
|
|
protected override void AddAppliedAbilities()
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(0, 0, 0u, 255, out entry);
|
|
Offset<MetaArg_AbilityControl> offset = MetaArg_AbilityControl.CreateMetaArg_AbilityControl(entry.builder);
|
|
entry.Finish(offset, AbilityInvokeArgument.MetaArg_AbilityControl);
|
|
base.AddAppliedAbilities();
|
|
}
|
|
}
|
|
|
|
protected override void RemoveAllAbilities()
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(0, 0, 0u, 255, out entry);
|
|
Offset<MetaArg_AbilityControl> offset = MetaArg_AbilityControl.CreateMetaArg_AbilityControl(entry.builder, AbilityControlType.RemoveAllAbilities);
|
|
entry.Finish(offset, AbilityInvokeArgument.MetaArg_AbilityControl);
|
|
base.RemoveAllAbilities();
|
|
}
|
|
}
|
|
|
|
protected override void RemoveAllNonOnDestroyAbilities()
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
RecordInvokeEntryContext entry;
|
|
StartRecordInvokeEntry(0, 0, 0u, 255, out entry);
|
|
Offset<MetaArg_AbilityControl> offset = MetaArg_AbilityControl.CreateMetaArg_AbilityControl(entry.builder, AbilityControlType.RemoveAllNonDestroyAbilities);
|
|
entry.Finish(offset, AbilityInvokeArgument.MetaArg_AbilityControl);
|
|
base.RemoveAllNonOnDestroyAbilities();
|
|
}
|
|
}
|
|
|
|
protected override void RemoveAllModifies()
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
base.RemoveAllModifies();
|
|
}
|
|
}
|
|
|
|
private void MetaAuthorityInvokeHandler(AbilityInvokeEntry invokeEntry)
|
|
{
|
|
if (invokeEntry.ArgumentType == AbilityInvokeArgument.MetaArg_Command_ModifierChangeRequest)
|
|
{
|
|
MetaAuthorityCommand_ModifierChangeRequestHandler(invokeEntry);
|
|
}
|
|
}
|
|
|
|
private void MetaAuthorityCommand_ModifierChangeRequestHandler(AbilityInvokeEntry invokeEntry)
|
|
{
|
|
_metaModifierReq = invokeEntry.GetArgument(_metaModifierReq);
|
|
uint target = invokeEntry.Target;
|
|
uint casterID = ((target != 0) ? target : _owner.runtimeID);
|
|
if (_metaModifierReq.Action == ModifierAction.Added)
|
|
{
|
|
MPTryApplyModifierByID(casterID, invokeEntry.InstancedAbilityID, _metaModifierReq.ModifierLocalID);
|
|
}
|
|
else if (_metaModifierReq.Action == ModifierAction.Removed)
|
|
{
|
|
MPTryRemoveModifierByID(casterID, invokeEntry.InstancedAbilityID, _metaModifierReq.ModifierLocalID);
|
|
}
|
|
}
|
|
|
|
private void MetaRemoteInvokeHandler(AbilityInvokeEntry invokeEntry)
|
|
{
|
|
if (invokeEntry.ArgumentType == AbilityInvokeArgument.MetaArg_ModifierChange)
|
|
{
|
|
MetaHandleModifierChange(invokeEntry);
|
|
}
|
|
else if (invokeEntry.ArgumentType == AbilityInvokeArgument.MetaArg_AbilityControl)
|
|
{
|
|
MetaHandlerAbilityControl(invokeEntry);
|
|
}
|
|
}
|
|
|
|
private void MetaHandlerAbilityControl(AbilityInvokeEntry invokeEntry)
|
|
{
|
|
_metaAbilityControl = invokeEntry.GetArgument(_metaAbilityControl);
|
|
switch (_metaAbilityControl.Type)
|
|
{
|
|
case AbilityControlType.AddAppliedAbilities:
|
|
base.AddAppliedAbilities();
|
|
break;
|
|
case AbilityControlType.RemoveAllAbilities:
|
|
base.RemoveAllAbilities();
|
|
break;
|
|
case AbilityControlType.RemoveAllNonDestroyAbilities:
|
|
base.RemoveAllNonOnDestroyAbilities();
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void MetaHandleModifierChange(AbilityInvokeEntry table)
|
|
{
|
|
_metaModifierChange = table.GetArgument(_metaModifierChange);
|
|
if (_metaModifierChange.Action == ModifierAction.Added)
|
|
{
|
|
ActorAbility actorAbility = null;
|
|
ConfigAbilityModifier configAbilityModifier = null;
|
|
int index = table.InstancedModifierID - 1;
|
|
BaseAbilityActor baseAbilityActor = ((table.Target != 0) ? Singleton<EventManager>.Instance.GetActor<BaseAbilityActor>(table.Target) : _owner);
|
|
actorAbility = ((MPActorAbilityPlugin)baseAbilityActor.abilityPlugin).GetInstancedAbilityByID(table.InstancedAbilityID);
|
|
configAbilityModifier = actorAbility.config.ModifierIDMap[_metaModifierChange.ModifierLocalID];
|
|
base.AddModifierOnIndex(actorAbility, configAbilityModifier, index);
|
|
}
|
|
else
|
|
{
|
|
ActorModifier instancedModifierByID = GetInstancedModifierByID(table.InstancedModifierID);
|
|
int index2 = table.InstancedModifierID - 1;
|
|
base.RemoveModifierOnIndex(instancedModifierByID, index2);
|
|
}
|
|
}
|
|
|
|
public void SetupIdentity(BaseAbilityEntityIdentiy identity)
|
|
{
|
|
_abilityIdentity = identity;
|
|
base.OnAdded();
|
|
}
|
|
|
|
public override void OnAdded()
|
|
{
|
|
MPManager instance = Singleton<MPManager>.Instance;
|
|
instance.OnFrameEnd = (Action)Delegate.Combine(instance.OnFrameEnd, new Action(FlushRecordInvokeEntriesAndSend));
|
|
}
|
|
|
|
public override void OnRemoved()
|
|
{
|
|
MPManager instance = Singleton<MPManager>.Instance;
|
|
instance.OnFrameEnd = (Action)Delegate.Remove(instance.OnFrameEnd, new Action(FlushRecordInvokeEntriesAndSend));
|
|
base.OnRemoved();
|
|
}
|
|
|
|
public override BaseAbilityMixin CreateInstancedAbilityMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config)
|
|
{
|
|
BaseAbilityMixin baseAbilityMixin = config.MPCreateInstancedMixin(instancedAbility, instancedModifier);
|
|
if (baseAbilityMixin == null)
|
|
{
|
|
return null;
|
|
}
|
|
baseAbilityMixin.selfIdentity = Singleton<MPManager>.Instance.GetIdentity<BaseAbilityEntityIdentiy>(baseAbilityMixin.actor.runtimeID);
|
|
return baseAbilityMixin;
|
|
}
|
|
|
|
public ActorAbility GetInstancedAbilityByID(int appliedAbilityID)
|
|
{
|
|
return _appliedAbilities[appliedAbilityID - 1];
|
|
}
|
|
|
|
public ActorModifier GetInstancedModifierByID(int appliedModifierID)
|
|
{
|
|
return _appliedModifiers[appliedModifierID - 1];
|
|
}
|
|
|
|
public bool MPTryRemoveModifierByID(uint casterID, int instancedAbilityID, int modifierLocalID)
|
|
{
|
|
for (int i = 0; i < _appliedModifiers.Count; i++)
|
|
{
|
|
if (_appliedModifiers[i] != null)
|
|
{
|
|
ActorModifier actorModifier = _appliedModifiers[i];
|
|
if (actorModifier.parentAbility.caster.runtimeID == casterID && actorModifier.parentAbility.instancedAbilityID == instancedAbilityID && actorModifier.config.localID == modifierLocalID)
|
|
{
|
|
RemoveModifier(actorModifier, i);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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];
|
|
ActorModifier actorModifier = ApplyModifier(instancedAbilityByID, modifierConfig);
|
|
return actorModifier != null;
|
|
}
|
|
|
|
protected override void HandleActionTargetDispatch(ConfigAbilityAction actionConfig, ActorAbility instancedAbility, ActorModifier instancedModifier, BaseAbilityActor other, BaseEvent evt, Func<BaseAbilityActor, bool> targetPredicate)
|
|
{
|
|
if (_abilityIdentity.isAuthority)
|
|
{
|
|
base.HandleActionTargetDispatch(actionConfig, instancedAbility, instancedModifier, other, evt, targetPredicate);
|
|
}
|
|
}
|
|
|
|
public void ExternalResolveTarget(AbilityTargetting targetting, TargettingOption option, ActorAbility instancedAbility, BaseAbilityActor other, out BaseAbilityActor outTarget, out BaseAbilityActor[] outTargetLs, out bool needHandleTargetOnNull)
|
|
{
|
|
ResolveTarget(targetting, option, instancedAbility, other, out outTarget, out outTargetLs, out needHandleTargetOnNull);
|
|
}
|
|
}
|
|
}
|