/// <inheritdoc />
public bool CommitAbility(IGameplayAbilitySystem AbilitySystem)
{
ActivateAbility(AbilitySystem);
AbilitySystem.OnGameplayAbilityActivated.Invoke(this);
ApplyCost(AbilitySystem);
return(true);
}
/// <summary>
/// Applies cooldown. Cooldown is applied even if the ability is already
/// on cooldown
/// </summary>
protected void ApplyCooldown(IGameplayAbilitySystem abilitySystem)
{
foreach (var cooldownEffect in this.CooldownsToApply)
{
abilitySystem.ApplyGameEffectToTarget(cooldownEffect, abilitySystem);
}
}
public override async void ActivateAbility(IGameplayAbilitySystem AbilitySystem, IGameplayAbility 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);
}
/// <summary>
/// Applies cooldown. Cooldown is applied even if the ability is already
/// on cooldown
/// </summary>
protected void ApplyCooldown(IGameplayAbilitySystem abilitySystem)
{
foreach (var cooldown in this.GameplayCooldowns)
{
abilitySystem.ActiveGameplayEffectsContainer.ApplyCooldownEffect(new ActiveGameplayEffectData(cooldown.CooldownGameplayEffect, abilitySystem, abilitySystem));
}
}
public override async void ActivateAbility(IGameplayAbilitySystem AbilitySystem, IGameplayAbility 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);
List <GameObject> objectsSpawned = new List <GameObject>();
// projectile.transform.position = abilitySystemActor.transform.position + abilitySystemActor.transform.forward * 1.2f + new Vector3(0, 1.5f, 0);
await animationEventSystemComponent.CustomAnimationEvent.WaitForEvent((x) => x == FireProjectile);
AbilitySystem.ApplyGameEffectToTarget(TargetGameplayEffect, gameplayEventData.Target);
var beh = animatorComponent.GetBehaviour <AnimationBehaviourEventSystem>();
await beh.StateEnter.WaitForEvent((animator, stateInfo, layerIndex) => stateInfo.fullPathHash == Animator.StringToHash(CompletionAnimatorStateFullHash));
// Commit ability cost
// TODO: ApplyCost();
// Wait for some specific gameplay event
// Not applicable for base activate
// Commit ability cooldown
//TODO: ApplyCooldown();
// Apply game effect(s)
// End Ability
Ability.EndAbility(AbilitySystem);
}
private async void SeekTargetAndDestroy(IGameplayAbilitySystem AbilitySystem, GameplayEventData gameplayEventData, GameObject projectile)
{
await projectile.GetComponent <Projectile>().SeekTarget(gameplayEventData.Target.TargettingLocation.gameObject, gameplayEventData.Target.gameObject);
_ = AbilitySystem.ApplyGameEffectToTarget(TargetGameplayEffect, gameplayEventData.Target);
DestroyImmediate(projectile);
}
private bool TagRequirementsMet(IGameplayAbilitySystem AbilitySystem)
{
// Checks to make sure Source ability system doesn't have prohibited tags
var activeTags = AbilitySystem.ActiveTags;
var hasActivationRequiredTags = true;
var hasActivationBlockedTags = false;
var hasSourceRequiredTags = false;
var hasSourceBlockedTags = false;
if (this.Tags.ActivationRequiredTags.Added.Count > 0)
{
hasActivationRequiredTags = !this.Tags.ActivationRequiredTags.Added.Except(activeTags).Any();
}
if (this.Tags.ActivationBlockedTags.Added.Count > 0)
{
hasActivationBlockedTags = activeTags.Any(x => this.Tags.ActivationBlockedTags.Added.Contains(x));
}
if (this.Tags.SourceRequiredTags.Added.Count > 0)
{
hasSourceRequiredTags = !this.Tags.SourceRequiredTags.Added.Except(activeTags).Any();
}
if (this.Tags.SourceBlockedTags.Added.Count > 0)
{
hasSourceBlockedTags = activeTags.Any(x => this.Tags.SourceBlockedTags.Added.Contains(x));
}
return(!hasActivationBlockedTags && hasActivationRequiredTags);
}
/// <summary>
/// Applies cooldown. Cooldown is applied even if the ability is already
/// on cooldown
/// </summary>
protected void ApplyCooldown(IGameplayAbilitySystem abilitySystem)
{
for (var i = 0; i < this.GameplayCooldowns.Count; i++)
{
abilitySystem.AddGameplayEffectToActiveList(this.GameplayCooldowns[i].CooldownGameplayEffect);
}
}
/// <summary>
/// Applies the ability cost, decreasing the specified cost resource from the player.
/// If player doesn't have the required resource, the resource goes to negative (or clamps to 0)
/// </summary>
protected void ApplyCost(IGameplayAbilitySystem AbilitySystem)
{
var modifiers = this.GameplayCost.CostGameplayEffect.CalculateModifierEffect();
var attributeModification = this.GameplayCost.CostGameplayEffect.CalculateAttributeModification(AbilitySystem, modifiers);
this.GameplayCost.CostGameplayEffect.ApplyInstantEffect(AbilitySystem);
}
/// <inheritdoc />
public GameplayEffect ApplyGameEffectToTarget(GameplayEffect Effect, IGameplayAbilitySystem Target, float Level = 0)
{
if (Effect.ExecuteEffect(Target))
{
this.AddGameplayEffectToActiveList(Effect);
}
return(Effect);
}
/// <inheritdoc />
public virtual bool IsAbilityActivatable(IGameplayAbilitySystem AbilitySystem)
{
// Player must be "Idle" to begin ability activation
if (AbilitySystem.Animator.GetCurrentAnimatorStateInfo(0).fullPathHash != Animator.StringToHash("Base.Idle"))
{
return(false);
}
return(PlayerHasResourceToCast(AbilitySystem) && AbilityOffCooldown(AbilitySystem) && TagRequirementsMet(AbilitySystem));
}
/// <inheritdoc />
public bool CommitAbility(IGameplayAbilitySystem AbilitySystem)
{
if (!IsAbilityActivatable(AbilitySystem))
{
return(false);
}
// this.abilitySystem.OnGameplayAbilityActivated.Invoke(this);
ApplyCost();
return(true);
}
public ActiveGameplayEffectData(GameplayEffect effect, IGameplayAbilitySystem instigator, IGameplayAbilitySystem target)
{
this._gameplayEffect = effect;
this._startWorldTime = Time.time;
this.Instigator = instigator;
this.Target = target;
if (!this.Effect.Period.ExecuteOnApplication)
{
this._timeOfLastPeriodicApplication = Time.time;
}
}
/// <inheritdoc />
public bool AbilityOffCooldown(IGameplayAbilitySystem AbilitySystem)
{
var cooldownTags = this.GetAbilityCooldownTags();
// Check if we have the cooldown effect
var cooldownEffectsMatched = AbilitySystem.ActiveGameplayEffectsContainer.ActiveCooldowns.Select(x => x.Effect)
.Intersect(this.GameplayCooldowns.Select(x => x.CooldownGameplayEffect)).Count();
return(cooldownEffectsMatched == 0);
}
/// <inheritdoc />
public void EndAbility(IGameplayAbilitySystem AbilitySystem)
{
_onGameplayAbilityEnded.Invoke(this);
// Ability finished. Remove all listeners.
_onGameplayAbilityEnded.RemoveAllListeners();
// Tell ability system ability has ended
AbilitySystem.NotifyAbilityEnded(this);
}
/// <inheritdoc />
public bool PlayerHasResourceToCast(IGameplayAbilitySystem AbilitySystem)
{
// Check the modifiers on the ability cost GameEffect
var modifiers = this.GameplayCost.CostGameplayEffect.CalculateModifierEffect();
var attributeModification = this.GameplayCost.CostGameplayEffect.CalculateAttributeModification(AbilitySystem, modifiers, operateOnCurrentValue: true);
foreach (var attribute in attributeModification)
{
if (attribute.Value.NewAttribueValue < 0)
{
return(false);
}
}
return(true);
}
/// <inheritdoc />
public bool AbilityOffCooldown(IGameplayAbilitySystem AbilitySystem)
{
var cooldownTags = this.GetAbilityCooldownTags();
// Check if the ability system has any of these tags. Since tags are provided
// by game effects, that means we need to iterate through all active game effects
// and check if any of them provide these tags
// Check each active gameplay effect. If we have a match, store the reference
foreach (var gameplayEffect in AbilitySystem.ActiveGameplayEffects)
{
if (gameplayEffect.Effect.GetOwningTags().Intersect(cooldownTags).Count() > 0)
{
return(false);
}
}
return(true);
}
public override async void ActivateAbility(IGameplayAbilitySystem AbilitySystem, IGameplayAbility 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);
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(AbilitySystem, gameplayEventData, instantiatedProjectile);
}
var beh = animatorComponent.GetBehaviour <AnimationBehaviourEventSystem>();
await beh.StateEnter.WaitForEvent((animator, stateInfo, layerIndex) => stateInfo.fullPathHash == Animator.StringToHash(CompletionAnimatorStateFullHash));
Ability.EndAbility(AbilitySystem);
}
/// <inheritdoc />
public void EndAbility(IGameplayAbilitySystem AbilitySystem)
{
_onGameplayAbilityEnded.Invoke(this);
// Ability finished. Remove all listeners.
_onGameplayAbilityEnded.RemoveAllListeners();
// TODO: Remove tags added by this ability
// TODO: Cancel all tasks?
// TODO: Remove gameplay cues
// TODO: Cancel ability
// TODO: Remove blocking/cancelling Gameplay Tags
// Tell ability system ability has ended
AbilitySystem.NotifyAbilityEnded(this);
}
public (float CooldownElapsed, float CooldownTotal) CalculateCooldown(IGameplayAbilitySystem AbilitySystem)
{
var dominantCooldown = this.GameplayCooldowns
.Select(abilityCooldown => abilityCooldown.CooldownGameplayEffect)
.Select(abilityCooldown =>
AbilitySystem.ActiveGameplayEffectsContainer.ActiveCooldowns
.FirstOrDefault(activeCooldownOnCharacter => activeCooldownOnCharacter.Effect == abilityCooldown))
.Where(x => x != null && x.Effect != null)
.DefaultIfEmpty()
.OrderByDescending(activeEffect => activeEffect?.CooldownTimeRemaining)
.FirstOrDefault();
if (dominantCooldown == null)
{
return(0f, 0f);
}
return(dominantCooldown.CooldownTimeElapsed, dominantCooldown.CooldownTimeTotal);
}
public (float CooldownElapsed, float CooldownTotal) CalculateCooldown(IGameplayAbilitySystem AbilitySystem)
{
var cooldownTags = this.GetAbilityCooldownTags();
// Iterate through all gameplay effects on the ability system and find all effects which grant these cooldown tags
var dominantCooldownEffect = AbilitySystem.ActiveGameplayEffectsContainer
.ActiveEffectAttributeAggregator
.GetActiveEffects()
.Where(x => x.Effect.GrantedTags.Intersect(cooldownTags).Any())
.DefaultIfEmpty()
.OrderByDescending(x => x?.CooldownTimeRemaining)
.FirstOrDefault();
if (dominantCooldownEffect == null)
{
return(0f, 0f);
}
return(dominantCooldownEffect.CooldownTimeElapsed, dominantCooldownEffect.CooldownTimeTotal);
}
public GameplayCueParameters(IGameplayAbilitySystem Instigator, GameObject EffectCauser, GameObject SourceObject)
{
this.Instigator = Instigator;
this.EffectCauser = EffectCauser;
this.SourceObject = SourceObject;
}
public ActiveGameplayEffectsContainer(IGameplayAbilitySystem AbilitySystem)
{
this.AbilitySystem = AbilitySystem;
}
public abstract List <IGameplayAbilitySystem> InitiateTargetting(IGameplayAbilitySystem AbilitySystem, IGameplayAbility Ability);
public override List <IGameplayAbilitySystem> InitiateTargetting(IGameplayAbilitySystem AbilitySystem, IGameplayAbility Ability)
{
return(new List <IGameplayAbilitySystem>());
}
public abstract void ActivateAbility(IGameplayAbilitySystem AbilitySystem, IGameplayAbility Ability);
/// <inheritdoc />
public bool AbilityOffCooldown(IGameplayAbilitySystem AbilitySystem)
{
(var elapsed, var total) = this.CalculateCooldown(AbilitySystem);
return(total == 0f);
}
/// <inheritdoc />
public virtual bool IsAbilityActivatable(IGameplayAbilitySystem AbilitySystem)
{
return(PlayerHasResourceToCast(AbilitySystem) && AbilityOffCooldown(AbilitySystem));
}
/// <inheritdoc />
public virtual void ActivateAbility(IGameplayAbilitySystem AbilitySystem)
{
_abilityLogic.ActivateAbility(AbilitySystem, this);
ApplyCooldown(AbilitySystem);
}
/// <inheritdoc />
public bool PlayerHasResourceToCast(IGameplayAbilitySystem AbilitySystem)
{
return(true);
}
