private static void ParseModifierAura(JsonData json, AbilityData abilityData, ModifierData modifier)
{
modifier.Aura = GetStringValue(json, "Aura");
if (modifier.Aura != null)
{
modifier.Aura_Teams = GetEnumValue <MultipleTargetsTeam>(json, "Aura_Teams");
if (modifier.Aura_Teams == default)
{
BattleLog.LogError("技能[{0}]的Modifier[{1}]中配置了光环类型，但是Aura_Teams未找到或者配置有错误", abilityData.configFileName, modifier.Name);
return;
}
modifier.Aura_Types = GetEnumValue <MultipleTargetsType>(json, "Aura_Types");
if (modifier.Aura_Teams == default)
{
BattleLog.LogError("技能[{0}]的Modifier[{1}]中配置了光环类型，但是Aura_Types未找到或者配置有错误", abilityData.configFileName, modifier.Name);
return;
}
modifier.Aura_Radius = GetFloatValue(json, "Aura_Radius");
if (modifier.Aura_Teams == default)
{
BattleLog.LogError("技能[{0}]的Modifier[{1}]中配置了光环类型，但是Aura_Radius未配置", abilityData.configFileName, modifier.Name);
return;
}
}
}
//解析技能行为
private AbilityInput CreateAbilityInput(Ability ability)
{
// 非指向性技能，妲己一技能
AbilityBehavior abilityBehavior = ability.GetAbilityBehavior();
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_NO_TARGET) != 0)
{
return(CreateAbilityNoTargetInput(abilityBehavior));
}
// 指向性技能：妲己二技能
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_UNIT_TARGET) != 0)
{
return(CreateAbilityTargetInput(abilityBehavior));
}
// 点施法类型，王昭君大招
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_POINT) != 0)
{
return(CreateAbilityPointInput(abilityBehavior));
}
BattleLog.LogError("技能[%s]中有未定义的Input类型", ability.GetConfigName());
return(null);
}
// 大招技能指示器解析，这部分有点冗余，是自己抽出来的，不是dota源解析，那dota是怎么实现技能指示器的
private static ActionTarget ParseAbilityRange(JsonData json, AbilityData abilityData)
{
if (json == null)
{
return(null);
}
var actionTarget = new ActionTarget();
var targetTeam = GetEnumValue <MultipleTargetsTeam>(json, "AbilityUnitTargetTeam");
actionTarget.SetTargetTeam(targetTeam);
var abilityBehavior = abilityData.abilityBehavior;
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_DIRECTIONAL) != 0)
{
var lineJsonData = GetJsonValue(json, "AbilityAoeLine");
if (lineJsonData == null)
{
BattleLog.LogError("技能[{0}]行为是ABILITY_BEHAVIOR_LINE_AOE，未找到AbilityAoeLine配置", abilityData.configFileName);
return(null);
}
var length = (float)GetJsonValue(lineJsonData, "Length");
var thickness = (float)GetJsonValue(lineJsonData, "Thickness");
actionTarget.SetLineAoe(ActionMultipleTargetsCenter.CASTER, length, thickness);
}
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_SECTOR_AOE) != 0)
{
var sectorJsonData = GetJsonValue(json, "AbilityAoeSector");
if (sectorJsonData == null)
{
BattleLog.LogError("技能[{0}]行为是ABILITY_BEHAVIOR_SECTOR_AOE，未找到AbilityAoeSector配置", abilityData.configFileName);
return(null);
}
var sectorRadius = (float)GetJsonValue(sectorJsonData, "Radius");
var angle = (float)GetJsonValue(sectorJsonData, "Angle");
actionTarget.SetSectorAoe(ActionMultipleTargetsCenter.CASTER, sectorRadius, angle);
}
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_RADIUS_AOE) != 0)
{
var radiusJson = GetJsonValue(json, "AbilityAoeRadius");
if (radiusJson == null)
{
BattleLog.LogError("技能[{0}]行为是ABILITY_BEHAVIOR_RADIUS_AOE，未找到AbilityAoeRadius配置", abilityData.configFileName);
return(null);
}
float radius = (float)radiusJson;
actionTarget.SetRadiusAoe(ActionMultipleTargetsCenter.CASTER, radius);
}
return(actionTarget);
}
public TargetCollection CalculateAOETarget(BattleUnit caster, AbilityData abilityData, RequestTarget requestTarget, ActionTarget actionTarget)
{
var targetCollection = new TargetCollection();
// 根据中心类型获取目标点
var centerType = actionTarget.Center;
float centerX, centerZ;
if (centerType == ActionMultipleTargetsCenter.CASTER)
{
caster.Get2DPosition(out centerX, out centerZ);
}
else if (centerType == ActionMultipleTargetsCenter.TARGET)
{
if (requestTarget.targetType == AbilityRequestTargetType.POINT)
{
BattleLog.LogError("单体技能[{0}]目标配置为TARGET，REQUEST TARGET却是POINT类型", abilityData.configFileName);
return(null);
}
requestTarget.GetTarget2DPosition(out centerX, out centerZ);
}
else if (centerType == ActionMultipleTargetsCenter.POINT)
{
requestTarget.GetTarget2DPosition(out centerX, out centerZ);
}
else
{
BattleLog.LogError("区域技能[{0}]中有未实现的技能中心点类型[{1}]", abilityData.configFileName, centerType);
return(null);
}
// 根据目标点和范围获取目标对象
List <BattleUnit> tempTargets;
var casterCamp = caster.camp;
var Teams = actionTarget.Teams;
var Types = actionTarget.Types;
var aoeType = actionTarget.aoeType;
if (aoeType == AOEType.Radius)
{
}
else if (aoeType == AOEType.Line)
{
}
else if (aoeType == AOEType.Sector)
{
}
else
{
BattleLog.LogError("区域技能[{0}]中有未实现区域类型{1}", abilityData.configFileName, aoeType);
}
return(targetCollection);
}
public void ApplyModifierByName(BattleUnit caster, AbilityData abilityData, string modifierName)
{
var modifierData = abilityData.GetModifierData(modifierName);
if (modifierData != null)
{
BattleLog.LogError("角色[{0}]的技能[{1}]未找到Modifier[{2}]的数据", id, abilityData.configFileName, modifierName);
return;
}
ApplyModifier(caster, abilityData, modifierData);
}
private static D2Action CreateIsHitAction(JsonData json, ActionTarget actionTarget, AbilityData abilityData)
{
var onSuccessActionConfig = GetJsonValue(json, "OnSuccess");
if (onSuccessActionConfig == null)
{
BattleLog.LogError("技能[%s]中IsHit未找到key[OnSuccess]的配置", abilityData.configFileName);
return(null);
}
var successActions = ParseActions(onSuccessActionConfig, abilityData);
var d2Action_IsHit = new D2Action_IsHit(successActions, actionTarget);
return(d2Action_IsHit);
}
/*
* "ApplyModifier":
* {
* "Target":"TARGET",
* "ModifierName":"dunji"
* }
*/
private static D2Action CreateApplyModifierAction(JsonData json, ActionTarget actionTarget, AbilityData abilityData)
{
var modifierName = GetStringValue(json, "ModifierName");
if (string.IsNullOrEmpty(modifierName))
{
BattleLog.LogError("技能[{0}]中ApplyModifier未找到key[ModifierName]的配置", abilityData.configFileName);
return(null);
}
//var targetFlags =
var applyModifier = new D2Action_ApplyModifier(modifierName, actionTarget);
return(applyModifier);
}
public static Ability CreateAbility(int id, BattleUnit caster)
{
skillItem skillItem = skillTable.Instance.GetTableItem(id);
if (skillItem == null)
{
BattleLog.LogError("skill 表没有找到指定id:", id.ToString());
return(null);
}
string path = skillItem.config;
int priority = skillItem.priority;
AbilityData abilityData = CreateAbility(path);
Ability ability = new Ability(id, priority, caster, abilityData);
return(ability);
}
private static D2Action CreateChangeEnergyAction(JsonData json, ActionTarget actionTarget, AbilityData abilityData)
{
var energyParams = GetJsonValue(json, "EnergyParams");
if (energyParams == null)
{
BattleLog.LogError("技能[{0}]中ChangeEnergy中未找到key[EnergyParams]的配置", abilityData.configFileName);
return(null);
}
if (!energyParams.IsArray)
{
BattleLog.LogError("技能[{0}]中ChangeEnergy中key[EnergyParams]的配置必须是数组类型", abilityData.configFileName);
return(null);
}
var d2Action_ChangeEnergy = new D2Action_ChangeEnergy(energyParams, actionTarget);
return(d2Action_ChangeEnergy);
}
private static void ParseModifierProperties(JsonData json, AbilityData abilityData, ModifierData modifier)
{
var propertyDataConfig = GetJsonValue(json, "Properties");
if (propertyDataConfig != null)
{
var modifierPropertyDatas = new List <ModifierPropertyValue>();
foreach (var propertyType in propertyDataConfig.Keys)
{
var propertyEnum = GetEnumValue <ModifierProperties>(propertyType.ToString());
if (propertyEnum == default)
{
BattleLog.LogError("技能[{0}]中有未定义的ModifierProperty类型[{1}]", abilityData.configFileName, propertyType);
}
else
{
var modifierPropertyValue = new ModifierPropertyValue();
var propertyValueConfig = propertyDataConfig[propertyType];
if (propertyValueConfig.IsArray)
{
// todo 解析数值
var valueSourceJson = GetJsonValue(propertyValueConfig, "ValueSource");
if (valueSourceJson == null)
{
//modifierPropertyValue.
}
else
{
//var damageValueSource = ParseValueSource(valueSourceJson, abilityData);
}
modifierPropertyDatas.Add(modifierPropertyValue);
}
else
{
BattleLog.LogError("技能[{0}]中的ModifierProperty类型[{1}]不是数组配置或者ValueSource类型", abilityData.configFileName, propertyType);
}
}
}
modifier.ModifierProperties = modifierPropertyDatas;
}
}
private BattleUnit FilterTargetEntityFromList(BattleUnit caster, Ability ability, List <BattleUnit> targetUnits)
{
if (targetUnits.Count <= 0)
{
return(null);
}
AbilityUnitAITargetCondition aiTargetCondition = ability.GetAiTargetCondition();
switch (aiTargetCondition)
{
case AbilityUnitAITargetCondition.UNIT_TARGET_RANDOM:
return(GetRandomHeroEntity(targetUnits));
case AbilityUnitAITargetCondition.UNIT_TARGET_RANGE_MIN:
return(GetRangeHeroEntity(caster.Get2DPosition(), targetUnits, MinValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_RANGE_MAX:
return(GetRangeHeroEntity(caster.Get2DPosition(), targetUnits, MaxValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_HP_MIN:
return(GetHpHeroEntity(targetUnits, MinValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_HP_MAX:
return(GetHpHeroEntity(targetUnits, MaxValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_HP_PERCENT_MIN:
return(GetHpPercentHeroEntity(targetUnits, MinValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_HP_PERCENT_MAX:
return(GetHpPercentHeroEntity(targetUnits, MaxValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_ENERGY_MIN:
return(GetEnergyHeroEntity(targetUnits, MinValueCompare()));
case AbilityUnitAITargetCondition.UNIT_TARGET_ENERGY_MAX:
return(GetEnergyHeroEntity(targetUnits, MaxValueCompare()));
}
BattleLog.LogError("[FilterTargetUnitFromList]没有找到指定Entity,返回列表第一个单位！");
return(null);
}
public TargetCollection CalculateSingleTarget(BattleUnit caster, AbilityData abilityData, RequestTarget requestTarget, ActionTarget actionTarget)
{
var targetCollection = new TargetCollection();
if (actionTarget.singTarget == ActionSingTarget.CASTER)
{
targetCollection.targetType = AbilityRequestTargetType.UNIT;
targetCollection.AddUnit(caster);
return(targetCollection);
}
if (requestTarget == null)
{
BattleLog.LogError("单体技能[{0}]的单体目标配置非CASTER，但是请求的目标为nil", abilityData.configFileName);
return(null);
}
if (actionTarget.singTarget == ActionSingTarget.TARGET)
{
if (requestTarget.targetType == AbilityRequestTargetType.POINT)
{
BattleLog.LogError("单体技能[{0}]目标配置为TARGET，REQUEST TARGET却是POINT类型", abilityData.configFileName);
return(null);
}
targetCollection.targetType = AbilityRequestTargetType.UNIT;
targetCollection.AddUnit(requestTarget.GetTargetUnit());
return(targetCollection);
}
if (actionTarget.singTarget == ActionSingTarget.POINT)
{
targetCollection.targetType = AbilityRequestTargetType.POINT;
targetCollection.AddPoint(requestTarget.targetPos);
return(targetCollection);
}
BattleLog.LogError("技能[{0}]中有未实现的目标类型[{1}]", abilityData.configFileName);
return(null);
}
// 点施法类型，王昭君大招
private AbilityInput CreateAbilityPointInput(AbilityBehavior abilityBehavior)
{
var abilityInput = new AbilityInputPoint(m_casterTransform, ability);
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_RADIUS_AOE) != 0)
{
var radius = ability.GetAbilityAOERadius();
var trans = GetIndicatorAsset(AbilityIndicatorType.RANGE_AREA);
AbilityIndicatorRange abilityIndicatorRange = new AbilityIndicatorRange(trans, m_casterTransform, ability.GetCastRange());
trans = GetIndicatorAsset(AbilityIndicatorType.CIRCLE_AREA);
AbilityIndicatorPoint abilityIndicatorPoint = new AbilityIndicatorPoint(trans, m_casterTransform, radius);
abilityInput.AddAbilityIndicator(abilityIndicatorRange);
abilityInput.AddAbilityIndicator(abilityIndicatorPoint);
}
else
{
BattleLog.LogError("技能[{0}]中有未定义的Point类型技能区域", ability.GetConfigName());
}
return(abilityInput);
}
private static AbilityData CreateAbility(string path)
{
JsonData jsonData = LoadModule.LoadJson(path);
if (jsonData == null)
{
BattleLog.LogError("[CreateAbility]没有找到指定json配置！", path);
return(null);
}
AbilityData abilityData = new AbilityData();
abilityData.configFileName = GetStringValue(jsonData, "Name");
string abilityType = GetStringValue(jsonData, "AbilityType");
abilityData.abilityType = abilityType;
abilityData.abilityBranch = GetEnumValue <AbilityBranch>(jsonData, "AbilityBranch");
abilityData.abilityBehavior = ParseAbilityBehaviorArray(jsonData, "AbilityBehavior");
abilityData.aiTargetCondition = GetEnumValue <AbilityUnitAITargetCondition>(jsonData, "AbilityUnitAiTargetCondition");
abilityData.castRange = GetFloatValue(jsonData, "AbilityCastRange");
abilityData.castPoint = GetFloatValue(jsonData, "AbilityCastPoint");
abilityData.castDuration = GetFloatValue(jsonData, "AbilityCastDuration");
abilityData.castAnimation = GetStringValue(jsonData, "AbilityCastAnimation");
abilityData.cooldown = GetFloatValue(jsonData, "AbilityCooldown");
abilityData.costType = GetEnumValue <AbilityCostType>(jsonData, "AbilityCostType");
abilityData.costValue = GetFloatValue(jsonData, "AbilityCostValue");
abilityData.abilityTarget = ParseAbilityRange(jsonData, abilityData);
// 解析技能事件
abilityData.eventMap = ParseAbilityEvents(jsonData, abilityData);
// 解析Modifier
abilityData.modifierMap = ParseModifiers(jsonData, abilityData);
return(abilityData);
}
private static void ParseModifierStates(JsonData json, AbilityData abilityData, ModifierData modifier)
{
var stateDataConfig = GetJsonValue(json, "States");
if (stateDataConfig != null)
{
var modifierStates = new List <ModifierState>();
foreach (var stateName in stateDataConfig.Keys)
{
var stateEnum = GetEnumValue <ModifierStates>(stateName.ToString());
if (stateEnum == default)
{
BattleLog.LogError("技能[{0}]中有未定义的ModifierStates类型[{1}]", abilityData.configFileName, stateName);
}
else
{
var stateValue = GetIntValue(stateDataConfig, stateName);
// todo 解析数值
//modifierStates.Add();
}
}
modifier.States = modifierStates;
}
}
private static AbilityValueSource ParseValueSource(JsonData json, AbilityData abilityData)
{
var abilityValueSource = new AbilityValueSource();
var valueSourceJsonData = GetJsonValue(json, "ValueSource");
if (valueSourceJsonData == null)
{
return(abilityValueSource);
}
var valueBasicParamsConfig = GetJsonValue(valueSourceJsonData, "ValueBasicParams");
if (valueBasicParamsConfig == null)
{
return(abilityValueSource);
}
if (!valueBasicParamsConfig.IsArray)
{
BattleLog.LogError("技能[%s]中的[ValueSource]的[ValueBasicParams]的配置必须是数组类型", abilityData.configFileName);
}
else
{
var baseJsonData = valueBasicParamsConfig[0].ToString();
var baseGrowJsonData = valueBasicParamsConfig[1].ToString();
var baseValue = string.IsNullOrEmpty(baseJsonData) ? 0f : float.Parse(baseJsonData);
var baseValueGrow = string.IsNullOrEmpty(baseGrowJsonData) ? 0f : float.Parse(baseGrowJsonData);
abilityValueSource.baseValue = baseValue;
abilityValueSource.baseValueGrow = baseValueGrow;
}
//todo 附加值
var valueAdditionParamsConfig = GetJsonValue(valueSourceJsonData, "ValueAdditionParams");
if (valueAdditionParamsConfig != null)
{
if (valueAdditionParamsConfig.IsArray)
{
for (int i = 0; i < valueAdditionParamsConfig.Count; i++)
{
var additionValueConfig = valueAdditionParamsConfig[i];
var valueSourceType = GetEnumValue <AbilityValueSourceType>(additionValueConfig, "ValueSourceType");
var valueSourceParamsConfig = GetJsonValue(additionValueConfig, "ValueSourceParams");
if (valueSourceParamsConfig != null)
{
if (valueSourceParamsConfig.IsArray)
{
int sourceValueCoefficient = valueSourceParamsConfig.Count >= 1 ? (int)valueSourceParamsConfig[0] : 0;
int sourceValueCoefficientGrow = valueSourceParamsConfig.Count >= 2 ? (int)valueSourceParamsConfig[1] : 0;
int limitBasicValue = valueSourceParamsConfig.Count >= 3 ? (int)valueSourceParamsConfig[2] : 0;
int limitBasicValueGrow = valueSourceParamsConfig.Count >= 4 ? (int)valueSourceParamsConfig[3] : 0;
abilityValueSource.AddAdditionValueParams(valueSourceType,
sourceValueCoefficient, sourceValueCoefficientGrow, limitBasicValue, limitBasicValueGrow);
}
else
{
BattleLog.LogError("技能[%s]中的[ValueSource]的[ValueSourceParams]的配置必须是数组类型", abilityData.configFileName);
}
}
}
}
else
{
BattleLog.LogError("技能[%s]中的[ValueSource]的[ValueAdditionParams]的配置必须是数组类型", abilityData.configFileName);
}
}
return(abilityValueSource);
}
private static ActionTarget ParseActionTarget(JsonData json, AbilityData abilityData)
{
if (json == null)
{
return(null);
}
var actionTarget = new ActionTarget();
if (json.IsObject)
{
var aoeAreaJsonData = GetJsonValue(json, "AoeArea");
if (aoeAreaJsonData == null)
{
BattleLog.LogError("技能[%s]中Target配置是区域目标配置，但是未配置AoeArea或者配置错误", abilityData.configFileName);
return(null);
}
var targetCenter = GetEnumValue <ActionMultipleTargetsCenter>(json, "Center");
var areaType = GetStringValue(aoeAreaJsonData, "AreaType");
var abilityAreaDamageType = GetEnumValue <AOEType>(areaType);
switch (abilityAreaDamageType)
{
case AOEType.Radius:
float radius = (int)GetJsonValue(aoeAreaJsonData, "Radius");
actionTarget.SetRadiusAoe(targetCenter, radius);
break;
case AOEType.Line:
JsonData lineJsonData = (int)GetJsonValue(aoeAreaJsonData, "Line");
if (lineJsonData == null)
{
BattleLog.LogError("技能[{0}]中Target配置是区域目标配置，但是未配置Line", abilityData.configFileName);
return(null);
}
var length = (float)GetJsonValue(lineJsonData, "Length");
var thickness = (float)GetJsonValue(lineJsonData, "Thickness");
actionTarget.SetLineAoe(targetCenter, length, thickness);
break;
case AOEType.Sector:
JsonData sectorJsonData = GetJsonValue(json, "Sector");
if (sectorJsonData == null)
{
BattleLog.LogError("技能[{0}]中Target配置是区域目标配置，但是未配置Sector", abilityData.configFileName);
return(null);
}
var sectorRadius = (float)GetJsonValue(sectorJsonData, "Radius");
var angle = (float)GetJsonValue(sectorJsonData, "Angle");
actionTarget.SetSectorAoe(targetCenter, sectorRadius, angle);
break;
default:
break;
}
var teamJsonData = GetStringValue(json, "Teams");
var abilityTargetTeam = GetEnumValue <MultipleTargetsTeam>(teamJsonData);
actionTarget.SetTargetTeam(abilityTargetTeam);
}
else
{
var target = (ActionSingTarget)Enum.Parse(typeof(ActionSingTarget), json.ToString());
actionTarget.SetSingTarget(target);
}
return(actionTarget);
}
// 非指向性技能输入，妲己一技能
private AbilityInput CreateAbilityNoTargetInput(AbilityBehavior abilityBehavior)
{
AbilityInput abilityInput;
AbilityIndicatorRange abilityIndicatorRange;
var rangeTrans = GetIndicatorAsset(AbilityIndicatorType.RANGE_AREA);
// 直线型
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_DIRECTIONAL) != 0)
{
abilityInput = new AbilityInputDirection(m_casterTransform, ability);
var castRange = ability.GetCastRange();
abilityIndicatorRange = new AbilityIndicatorRange(rangeTrans, m_casterTransform, castRange);
var trans = GetIndicatorAsset(AbilityIndicatorType.LINE_AREA);
float lineLength, lineThickness;
ability.GetLineAoe(out lineLength, out lineThickness);
AbilityIndicatorLine abilityIndicatorLine = new AbilityIndicatorLine(trans, m_casterTransform, lineLength, lineThickness);
abilityInput.AddAbilityIndicator(abilityIndicatorRange);
abilityInput.AddAbilityIndicator(abilityIndicatorLine);
return(abilityInput);
}
// 扇形型
if ((abilityBehavior & AbilityBehavior.ABILITY_BEHAVIOR_SECTOR_AOE) != 0)
{
abilityInput = new AbilityInputDirection(m_casterTransform, ability);
AbilityIndicatorType abilityIndicatorType;
float sectorRadius, sectorAngle;
ability.GetSectorAoe(out sectorRadius, out sectorAngle);
if (sectorAngle == 60)
{
abilityIndicatorType = AbilityIndicatorType.SECTOR60_AREA;
}
else if (sectorAngle == 90)
{
abilityIndicatorType = AbilityIndicatorType.SECTOR90_AREA;
}
else if (sectorAngle == 120)
{
abilityIndicatorType = AbilityIndicatorType.SECTOR120_AREA;
}
else
{
BattleLog.LogError("技能[{0}]中有未定义的扇形AOE范围角度[{1}]", ability.GetConfigName(), sectorAngle);
return(null);
}
var castRange = ability.GetCastRange();
abilityIndicatorRange = new AbilityIndicatorRange(rangeTrans, m_casterTransform, castRange);
var trans = GetIndicatorAsset(abilityIndicatorType);
var abilityIndicatorSector = new AbilityIndicatorLine(trans, m_casterTransform, sectorRadius, sectorRadius);
abilityInput.AddAbilityIndicator(abilityIndicatorRange);
abilityInput.AddAbilityIndicator(abilityIndicatorSector);
return(abilityInput);
}
// 范围型AOE 和 普通攻击，可以原地平A
abilityInput = new AbilityInputDirection(m_casterTransform, ability);
abilityIndicatorRange = new AbilityIndicatorRange(rangeTrans, m_casterTransform, ability.GetCastRange());
abilityInput.AddAbilityIndicator(abilityIndicatorRange);
return(abilityInput);
}
