public void RemoveAbilityByTag(FAbilityTagContainer inTag)
{
if (abilitiesMap.TryGetValue(inTag, out AbilityBase ability))
{
RemoveAbility(ability);
}
}
/// <summary>
/// 尝试触发任务
/// </summary>
public bool TryTrigger(FAbilityTagContainer inTag)
{
if (TaskStatus != ETaskStatus.TS_UnAccepted)
{
return(false);
}
bool bRes = false;
if (needTriggerTaskTags == null)
{
bRes = true;
TaskStatus = ETaskStatus.TS_Accepted;
}
else if (needTriggerTaskTags.Contains(inTag))
{
if (alreadyTriggerTaskTags == null)
{
alreadyTriggerTaskTags = new List <FAbilityTagContainer>();
}
alreadyTriggerTaskTags.Add(inTag);
if (alreadyTriggerTaskTags.Count == needTriggerTaskTags.Count)
{
foreach (FAbilityTagContainer registerTag in registerEventTags)
{
AbilityManager.Instance.RegisterEvent(registerTag, OnTriggerEvent);
}
bRes = true;
TaskStatus = ETaskStatus.TS_Accepted;
}
}
return(bRes);
}
public virtual void RemoveEvent(FAbilityTagContainer inTag, UnityAction <AbilitySystemComponent> inAction)
{
if (OnAbilityTriggerEventMap.ContainsKey(inTag))
{
OnAbilityTriggerEventMap[inTag] -= inAction;
}
}
public void RemoveEvent(FAbilityTagContainer tagContainer, UnityAction <FAbilityTagContainer, object, object, object> register)
{
if (eventMaps.ContainsKey(tagContainer))
{
eventMaps[tagContainer] -= register;
}
}
public void AcquireAbilityByTag(FAbilityTagContainer inTag)
{
if (!abilitiesMap.ContainsKey(inTag))
{
AbilityBase ability = AbilityManager.Instance.CreateAbility(inTag, this);
AcquireAbility(ability);
}
}
public void TriggerEvent(FAbilityTagContainer tagContainer, object param1 = null, object param2 = null, object param3 = null)
{
if (eventMaps.TryGetValue(tagContainer, out UnityAction <FAbilityTagContainer, object, object, object> action))
{
onTriggerEvent?.Invoke(tagContainer);
action?.Invoke(tagContainer, param1, param2, param3);
}
}
public bool TryActivateAbilityByTag(FAbilityTagContainer inTag)
{
if (abilitiesMap.TryGetValue(inTag, out AbilityBase ability))
{
return(TryActivateAbility(ability));
}
return(false);
}
public virtual bool TryCancelAbilityByTag(FAbilityTagContainer inTagContainer)
{
if (abilitiesMap.TryGetValue(inTagContainer, out AbilityBase ability) &&
activityAbilities.Contains(ability))
{
ability.CancelAbility();
}
return(false);
}
public virtual void TriggerEventByTags(FAbilityTagContainer inTag)
{
foreach (FAbilityTagContainer eventContainer in OnAbilityTriggerEventMap.Keys)
{
if (inTag.HasAll(eventContainer))
{
OnAbilityTriggerEventMap[eventContainer]?.Invoke(null);
}
}
}
public bool GetTagContainer(string inTagName, out FAbilityTagContainer tagContainer)
{
if (TagContainersMap != null && TagContainersMap.TryGetValue(inTagName, out FAbilityTagContainer tempContainer))
{
tagContainer = tempContainer;
return(true);
}
tagContainer = new FAbilityTagContainer();
return(false);
}
public void RegisterEvent(FAbilityTagContainer tagContainer, UnityAction <FAbilityTagContainer, object, object, object> register)
{
if (eventMaps.ContainsKey(tagContainer))
{
eventMaps[tagContainer] += register;
}
else
{
eventMaps.Add(tagContainer, register);
}
}
public virtual void RegisterEvent(FAbilityTagContainer inTag, UnityAction <AbilitySystemComponent> inAction)
{
if (OnAbilityTriggerEventMap.ContainsKey(inTag))
{
OnAbilityTriggerEventMap[inTag] += inAction;
}
else
{
OnAbilityTriggerEventMap.Add(inTag, inAction);
}
}
public AbilityBase TryGetAbility(FAbilityTagContainer inTag)
{
AbilityBase abilityBase;
if (!abilitiesMap.TryGetValue(inTag, out abilityBase) || abilityBase == null)
{
if (buffMap.TryGetValue(inTag, out AbilityBuff buff))
{
abilityBase = buff;
}
}
return(abilityBase);
}
public void OnTriggerEvent(FAbilityTagContainer inTag)
{
if (m_UnAcceptTaskMap.TryGetValue(inTag, out List <Task> list))
{
foreach (Task task in list)
{
if (task.TryTrigger(inTag))
{
m_CurrentTaskMap.Add(task.Id, task);
}
}
}
}
public void RemoveTags(FAbilityTagContainer inAbilityTagContainer)
{
if (inAbilityTagContainer.IsEmpty())
{
return;
}
foreach (FAbilityTag abilityTag in inAbilityTagContainer.abilityTags)
{
AddTag(abilityTag, -1);
}
//AddTag(inAbilityTagContainer.abilityTags[inAbilityTagContainer.abilityTags.Count - 1], -1);
}
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 bool HasAnyMatchingTags(FAbilityTagContainer inOtherContainer)
{
if (inOtherContainer.IsEmpty())
{
return(true);
}
foreach (FAbilityTag abilityTag in inOtherContainer.abilityTags)
{
if (HasMatchingTag(abilityTag))
{
return(true);
}
}
return(false);
}
void AddTag(string inStr)
{
if (string.IsNullOrEmpty(inStr) || string.IsNullOrWhiteSpace(inStr))
{
return;
}
string[] strs = inStr.Split('.');
FAbilityTagContainer[] containers = new FAbilityTagContainer[strs.Length];
FAbilityTag rootTag = new FAbilityTag(strs[0]);
if (!TagsMap.ContainsKey(rootTag.TagId))
{
TagsMap.Add(rootTag.TagId, rootTag);
}
for (int i = 0; i < containers.Length; i++)
{
containers[i].AddAbilityTag(rootTag);
}
if (!TagContainersMap.ContainsKey(rootTag.TagName))
{
TagContainersMap.Add(rootTag.TagName, containers[0]);
}
FAbilityTag parentTag = rootTag;
for (int i = 1; i < strs.Length; i++)
{
parentTag = new FAbilityTag(strs[i], parentTag);
if (!TagsMap.ContainsKey(parentTag.TagId))
{
TagsMap.Add(parentTag.TagId, parentTag);
}
for (int j = i; j < containers.Length; j++)
{
containers[j].AddAbilityTag(parentTag);
}
if (!TagContainersMap.ContainsKey(parentTag.TagName))
{
TagContainersMap.Add(parentTag.TagName, containers[i]);
}
}
}
public bool TryActivateBuffByTag(FAbilityTagContainer inTag, int inLevel = 0, int inStackDelta = 1, bool bForceActivate = false)
{
if (blockAbilityTagsContainer.HasBlockMatchingTags(inTag))
{
return(false);
}
if (buffMap.TryGetValue(inTag, out AbilityBuff buff))
{
return(TryActivateBuff(buff, inLevel, inStackDelta));
}
else
{
AbilityBuff tempBuff = AbilityManager.Instance.CreateAbility(inTag, this) as AbilityBuff;
return(TryActivateBuff(tempBuff, inLevel, inStackDelta, bForceActivate));
}
}
/// <summary>
/// 触发事件
/// </summary>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="param3"></param>
public void OnTriggerEvent(FAbilityTagContainer inTriggerTag, object param1, object param2, object param3)
{
float add = (float)param1;
Current += add;
if (Current >= Conditions)
{
TaskStatus = ETaskStatus.TS_Finished;
TaskManager.Instance.RemoveTask(this);
foreach (FAbilityTagContainer registerTag in registerEventTags)
{
AbilityManager.Instance.RemoveEvent(registerTag, OnTriggerEvent);
}
foreach (FAbilityTagContainer triggerTag in finishTriggerTaskTags)
{
AbilityManager.Instance.TriggerEvent(triggerTag, 1);
}
}
}
public bool HasAll(FAbilityTagContainer tagContainer)
{
if (tagContainer.IsEmpty())
{
return(true);
}
if (IsEmpty() || abilityTags.Count < tagContainer.abilityTags.Count)
{
return(false);
}
for (int i = 0; i < tagContainer.abilityTags.Count; i++)
{
if (abilityTags[i] != tagContainer.abilityTags[i])
{
return(false);
}
}
return(true);
}
/// <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);
}
public void RemoveActivateTags(FAbilityTagContainer inTag)
{
activationAbilityTagsContainer.RemoveTags(inTag);
}
public void AddActivateTags(FAbilityTagContainer inTag)
{
activationAbilityTagsContainer.AddTags(inTag);
}
