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; }