private void ActivateAbility(AbilitySystemComponent Source, AbilitySystemComponent Target, Entity AbilityEntity, HealAbilityComponent Ability)
{
var abilitySystemActor = Source.GetActor();
//(_, var gameplayEventData) = await AbilitySystem.OnGameplayEvent.WaitForEvent((gameplayTag, eventData) => gameplayTag == WaitForEventTag);
var gameplayEventData = new GameplayAbilitySystem.Events.GameplayEventData()
{
Instigator = Source,
Target = Target
};
GameObject instantiatedProjectile = null;
instantiatedProjectile = Object.Instantiate(Prefab);
instantiatedProjectile.transform.position = abilitySystemActor.transform.position + new Vector3(0, 1.5f, 0) + abilitySystemActor.transform.forward * 1.2f;
var attributesComponent = GetComponentDataFromEntity <AttributesComponent>(false);
Ability.ApplyGameplayEffects(World.Active.EntityManager, Source.entity, Target.entity, attributesComponent[Target.entity], Time.time);
// Animation complete. Spawn and send projectile at target
// if (instantiatedProjectile != null) {
// SeekTargetAndDestroy(Source, Target, instantiatedProjectile, ability, AbilityEntity);
// }
}
public override async void ActivateAbility(AbilitySystemComponent AbilitySystem, GameplayAbility Ability)
{
var abilitySystemActor = AbilitySystem.GetActor();
var animationEventSystemComponent = abilitySystemActor.GetComponent <AnimationEventSystem>();
var animatorComponent = abilitySystemActor.GetComponent <Animator>();
// Make sure we have enough resources. End ability if we don't
(_, var gameplayEventData) = await AbilitySystem.OnGameplayEvent.WaitForEvent((gameplayTag, eventData) => gameplayTag == WaitForEventTag);
animatorComponent.SetTrigger(AnimationTriggerName);
animatorComponent.SetTrigger(AnimationCompleteTriggerName);
if (ExecuteEffectEvent != null)
{
await animationEventSystemComponent.CustomAnimationEvent.WaitForEvent((x) => x == ExecuteEffectEvent);
}
_ = AbilitySystem.ApplyGameEffectToTarget(TargetGameplayEffect, gameplayEventData.Target);
var beh = animatorComponent.GetBehaviour <AnimationBehaviourEventSystem>();
await beh.StateEnter.WaitForEvent((animator, stateInfo, layerIndex) => stateInfo.fullPathHash == Animator.StringToHash(CompletionAnimatorStateFullHash));
// End Ability
Ability.EndAbility(AbilitySystem);
}
public override void InitAbility(AbilitySystemComponent abilitySystem, AbilityEditorData abilityEditorData)
{
base.InitAbility(abilitySystem, abilityEditorData);
abilityData.abilityType = abilityEditorData.abilityType;
abilityData.castPoint = abilityEditorData.castPoint;
abilityData.channelStartTime = abilityEditorData.channelStartTime;
abilityData.channelInterval = abilityEditorData.channelInterval;
abilityData.channelEndTime = abilityEditorData.channelEndTime;
abilityData.targetType = abilityEditorData.targetType;
abilityData.totalTime = abilityEditorData.totalTime;
abilityData.spellRadius = abilityEditorData.spellRadius;
abilityData.spellRange = abilityEditorData.spellRange;
abilityData.spellOverlapType = abilityEditorData.spellOverlapType;
if (abilityEditorData.Buff_CoolDown != null)
{
effect_CoolDown = AbilityManager.Instance.CreateAbility(AbilityTagManager.Instance.GetTagContainer(abilityEditorData.Buff_CoolDown.abilityTags[0]), abilitySystem) as AbilityBuff;
}
if (abilityEditorData.Buff_Cost != null)
{
effect_Cost = AbilityManager.Instance.CreateAbility(AbilityTagManager.Instance.GetTagContainer(abilityEditorData.Buff_Cost.abilityTags[0]), abilitySystem) as AbilityBuff;
}
InitTagList(ref passive_ListenerTags, abilityEditorData.passiveAbilityListenerTags);
InitTagList(ref triggerTags, abilityEditorData.passiveAbilityTriggerTags);
if (abilityData.abilityType == EAbilityType.EAT_PassiveAblity)
{
foreach (FAbilityTagContainer tag in passive_ListenerTags)
{
abilitySystem.RegisterEvent(tag, OnTriggerActivateAbility);
}
}
}
/// <inheritdoc />
public bool CommitAbility(AbilitySystemComponent AbilitySystem)
{
ActivateAbility(AbilitySystem);
AbilitySystem.OnGameplayAbilityActivated.Invoke(this);
ApplyCost(AbilitySystem);
return(true);
}
public AbilityBuffModifiers(AbilitySystemComponent abilitySystem, Editor_FModifierData inData)
{
this.abilitySystem = abilitySystem;
attributeType = inData.attributeType;
modifierOption = inData.modifierOption;
modifierType = inData.modifierType;
attributeMagnitudeList = inData.attributeMagnitudeList;
}
/// <summary>
/// 被动触发技能
/// </summary>
protected virtual void OnTriggerActivateAbility(AbilitySystemComponent inTargetAbilitySystem = null)
{
if (CanActivateAbility())
{
OnAbilitySpell();
ToggleTriggerTags(true);
}
}
private async void SeekTargetAndDestroy(AbilitySystemComponent Source, AbilitySystemComponent Target, GameObject projectile, FireAbilityComponent Ability, Entity AbilityEntity)
{
await projectile.GetComponent <Projectile>().SeekTarget(Target.TargettingLocation.gameObject, Target.gameObject);
var attributesComponent = GetComponentDataFromEntity <AttributesComponent>(false);
Ability.ApplyGameplayEffects(World.Active.EntityManager, Source.entity, Target.entity, attributesComponent[Target.entity], Time.time);
Object.DestroyImmediate(projectile);
}
private void OnTriggerEnter(Collider other)
{
AbilitySystemComponent abilitySystem = other.GetComponent <AbilitySystemComponent>();
if (abilitySystem is object)
{
abilitySystem.TryActivateBuffByTag(triggerTag);
}
}
/// <inheritdoc />
public virtual void ActivateAbility(AbilitySystemComponent AbilitySystem)
{
if (_targettingLogic != null)
{
_targettingLogic.InitiateTargetting(AbilitySystem, this);
}
_abilityLogic.ActivateAbility(AbilitySystem, this);
ApplyCooldown(AbilitySystem);
}
/// <summary>
/// 激活技能
/// </summary>
protected virtual void ActivateAbility(AbilitySystemComponent inTargetAbilitySystem = null)
{
if (abilityData.abilityType == EAbilityType.EAT_PassiveAblity)
{
OnTriggerActivateAbility(inTargetAbilitySystem);
}
else
{
cor_Skill = abilitySystem.StartCoroutine(Skill());
}
}
private void Start()
{
abilitySystem = GetComponent <AbilitySystemComponent>();
animator = GetComponentInChildren <Animator>();
abilitySystem.AcquireAbilityByTag(AbilityConsts.Instance.Fire);
abilitySystem.AcquireAbilityByTag(AbilityConsts.Instance.Ice);
abilitySystem.AcquireAbilityByTag(AbilityConsts.Instance.Wood);
abilitySystem.AcquireAbilityByTag(AbilityConsts.Instance.Soil);
abilitySystem.AcquireAbilityByTag(AbilityConsts.Instance.Gold);
abilitySystem.AttributeSet.RegisterDataChangedEvent(EAttributeType.AT_Health, OnHealthChanged);
abilitySystem.AttributeSet.RegisterDataChangedEvent(EAttributeType.AT_Mana, OnManaChanged);
}
public AbilityBase CreateAbility(FAbilityTagContainer inTag, AbilitySystemComponent systemComponent)
{
if (m_AbilityMaps.TryGetValue(inTag, out AbilityEditorData abilityEditorData) && abilityEditorData.AbilityScript != null)
{
AbilityBase ability = systemComponent.TryGetAbility(inTag);
if (ability == null)
{
ability = System.Activator.CreateInstance(abilityEditorData.AbilityScript.GetClass()) as AbilityBase;
}
ability.InitAbility(systemComponent, abilityEditorData);
return(ability);
}
return(null);
}
public override bool TryActivateAbility(AbilitySystemComponent inTargetAbilitySystem = null)
{
if (abilityData.abilityType == EAbilityType.EAT_ToggleAbility)
{
ToggleTriggerTags(!IsActive);
SetSkillActive(!IsActive);
return(true);
}
else if (CanActivateAbility())
{
ActivateAbility(inTargetAbilitySystem);
return(true);
}
return(false);
}
public AbilityBuffMotionModifiers(AbilitySystemComponent abilitySystem, Editor_FMotionModifierData data)
{
this.abilitySystem = abilitySystem;
priority = data.priority;
duration = data.duration;
moveType = data.moveType;
distance = data.distance;
direction = data.direction;
rotateType = data.rotateType;
rotateAxis = data.rotateAxis;
rotateAngle = data.rotateAngle;
moveCurve = AnimationCurveManager.Instance.GetCurve(data.moveCurve);
rotateCurve = AnimationCurveManager.Instance.GetCurve(data.rotateCurve);
}
public override async void ActivateAbility(AbilitySystemComponent Source, AbilitySystemComponent Target, IAbilityBehaviour Ability)
{
var abilitySystemActor = Source.GetActor();
var animationEventSystemComponent = abilitySystemActor.GetComponent <AnimationEventSystem>();
var animatorComponent = abilitySystemActor.GetComponent <Animator>();
// Ability.State = AbilityState.Activated;
// Make sure we have enough resources. End ability if we don't
animatorComponent.SetTrigger(AnimationTriggerName);
//(_, var gameplayEventData) = await AbilitySystem.OnGameplayEvent.WaitForEvent((gameplayTag, eventData) => gameplayTag == WaitForEventTag);
var gameplayEventData = new GameplayEventData()
{
Instigator = Source,
Target = Target
};
List <GameObject> objectsSpawned = new List <GameObject>();
GameObject instantiatedProjectile = null;
await animationEventSystemComponent.CustomAnimationEvent.WaitForEvent((x) => x == CastingInitiated);
if (Projectile != null)
{
instantiatedProjectile = Instantiate(Projectile);
instantiatedProjectile.transform.position = abilitySystemActor.transform.position + this.ProjectilePositionOffset + abilitySystemActor.transform.forward * 1.2f;
}
animatorComponent.SetTrigger(ProjectileFireTriggerName);
await animationEventSystemComponent.CustomAnimationEvent.WaitForEvent((x) => x == FireProjectile);
// Animation complete. Spawn and send projectile at target
if (instantiatedProjectile != null)
{
SeekTargetAndDestroy(Source, gameplayEventData, instantiatedProjectile);
}
var beh = animatorComponent.GetBehaviour <AnimationBehaviourEventSystem>();
await beh.StateEnter.WaitForEvent((animator, stateInfo, layerIndex) => stateInfo.fullPathHash == Animator.StringToHash(CompletionAnimatorStateFullHash));
}
/// <summary>
/// 初始化
/// </summary>
public virtual void InitAbility(AbilitySystemComponent abilitySystem, AbilityEditorData abilityEditorData)
{
this.abilitySystem = abilitySystem;
abilityTags = AbilityTagManager.Instance.GetTagContainer(abilityEditorData.abilityTags[0]);
InitTagList(ref cancelAbilitiesWithTags, abilityEditorData.cancelAbilitiesWithTags);
InitTagList(ref blockAbilitiesWithTags, abilityEditorData.blockAbilitiesWithTags);
InitTagList(ref activationOwnedTags, abilityEditorData.activationOwnedTags);
InitTagList(ref sourceRequiredTags, abilityEditorData.sourceRequiredTags);
InitTagList(ref sourceBlockedTags, abilityEditorData.sourceBlockedTags);
InitTagList(ref targetRequiredTags, abilityEditorData.targetRequiredTags);
InitTagList(ref targetBlockedTags, abilityEditorData.targetBlockedTags);
Level = 0;
MaxLevel = abilityEditorData.maxLevel;
IsActive = false;
IsImmediately = abilityEditorData.bImmediately;
IsCancelable = abilityEditorData.bIsCancelable;
IsBlockingOtherAbilities = abilityEditorData.bIsBlockingOtherAbilities;
AbilityEditorData.ReadChildInfo(GetType(), abilityEditorData, this);
}
private void ActivateAbility(AbilitySystemComponent Source, AbilitySystemComponent Target, Entity AbilityEntity, FireAbilityComponent ability)
{
var abilitySystemActor = Source.GetActor();
//(_, var gameplayEventData) = await AbilitySystem.OnGameplayEvent.WaitForEvent((gameplayTag, eventData) => gameplayTag == WaitForEventTag);
var gameplayEventData = new GameplayAbilitySystem.Events.GameplayEventData()
{
Instigator = Source,
Target = Target
};
GameObject instantiatedProjectile = null;
instantiatedProjectile = Object.Instantiate(Prefab);
instantiatedProjectile.transform.position = abilitySystemActor.transform.position + new Vector3(0, 1.5f, 0) + abilitySystemActor.transform.forward * 1.2f;
// Animation complete. Spawn and send projectile at target
if (instantiatedProjectile != null)
{
SeekTargetAndDestroy(Source, Target, instantiatedProjectile, ability, AbilityEntity);
}
}
public AbilityBase CreateAbility(Type inType, AbilitySystemComponent systemComponent)
{
AbilityBase ability = System.Activator.CreateInstance(inType) as AbilityBase;
return(ability);
}
public override void ActivateAbility(AbilitySystemComponent AbilitySystem, GameplayAbility Ability)
{
//ActivateAbility(AbilitySystem, new GameplayEventData());
Ability.EndAbility(AbilitySystem);
}
public static void SendGameplayEventToComponent(AbilitySystemComponent TargetAbilitySystem, GameplayTag EventTag, GameplayEventData Payload)
{
TargetAbilitySystem.HandleGameplayEvent(EventTag, Payload);
}
/// <summary> /// 激活能力 /// </summary> public abstract bool TryActivateAbility(AbilitySystemComponent inTargetAbilitySystem = null);
protected void ApplyGameplayEffectToTarget(GameplayEffect effect, AbilitySystemComponent target)
{
//
}
public override void ActivateAbility(AbilitySystemComponent Source, AbilitySystemComponent Target, IAbilityBehaviour Ability)
{
throw new NotImplementedException();
}
IEnumerator WaitingSelect(ETargetType targetType, KeyCode selectKeyCode, KeyCode unSelectKeyCode, AbilitySystemComponent abilitySystem, Ability ability)
{
if (selectKeyCode == KeyCode.None)
{
selectKeyCode = DEFAULT_SELECTKEY;
}
if (unSelectKeyCode == KeyCode.None)
{
unSelectKeyCode = DEFAULT_UNSELECTKEY;
}
//ability.abilityData.spellRange
while (keepWaiting)
{
while (!Input.GetKeyDown(selectKeyCode) && !Input.GetKeyDown(unSelectKeyCode))
{
yield return(null);
}
if (Input.GetKeyDown(selectKeyCode))
{
if (targetType == ETargetType.ETT_Target)
{
// 射线检测
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out RaycastHit hitInfo) && hitInfo.collider != null)
{
AbilitySystemComponent target = hitInfo.collider.GetComponent <AbilitySystemComponent>();
if (target != null && target.CheckTargetTags(ability))
{
SelectTargetStatus = ESelectTarget.ST_SelectSuccess;
SelectedAbilitySystem = target;
}
else
{
SelectTargetStatus = ESelectTarget.ST_WaitingSelect;
//TODO Warning
}
}
}
else
{
// 鼠标位置
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out RaycastHit hitInfo) && hitInfo.collider != null)
{
SelectTargetStatus = ESelectTarget.ST_SelectSuccess;
SelectedAbilitySystems = MathEx.OverlapComponents <AbilitySystemComponent>(ability.AbilityData.spellOverlapType, ability.AbilityData.spellRange, new FTransformData(abilitySystem.transform));
}
else
{
SelectTargetStatus = ESelectTarget.ST_WaitingSelect;
//TODO Warning
}
}
}
else
{
SelectTargetStatus = ESelectTarget.ST_SelectFail;
}
yield return(null);
}
}
public WaitingSelectTarget(ETargetType targetType, KeyCode selectKeyCode, KeyCode unSelectKeyCode, AbilitySystemComponent abilitySystem, Ability ability)
{
SelectTargetStatus = ESelectTarget.ST_WaitingSelect;
abilitySystem.StartCoroutine(WaitingSelect(targetType, selectKeyCode, unSelectKeyCode, abilitySystem, ability));
}
public abstract void ActivateAbility(AbilitySystemComponent Source, AbilitySystemComponent Target, IAbilityBehaviour Ability);
public abstract void ActivateAbility(AbilitySystemComponent AbilitySystem, GameplayAbility Ability);
/// <summary>
/// 选择成功或失败后回调
/// </summary>
protected virtual void OnSelectTarget(bool IsSelectSuc, Vector3 selectPoint, AbilitySystemComponent targetSystems = null)
{
abilityData.selectTargetStatus = IsSelectSuc ? ESelectTarget.ST_SelectSuccess : ESelectTarget.ST_SelectFail;
}
