//某个战斗单位点击了移动
public void BattleUnitMove(BattleUnit battleUnit)
{
if (battleUnit == null ||
battleUnit.battleUnitRenderer == null ||
!battleUnit.battleUnitRenderer.Equals(manualOperatingBattleUnitRenderer))
{
UtilityHelper.LogError("Battle unit move failed.");
return;
}
//显示移动范围
SetCircularRangeRenderStateActive(
true,
GridRenderType.MoveRange,
battleUnit.mapGrid.row,
battleUnit.mapGrid.column,
battleUnit.battleUnitAttribute.mobility);
//设定为移动状态
manualOperationState = ManualOperationState.Move;
//关闭选择操作界面
HideManualActionList();
}
//点击了地块、战斗单位
private void OnBattleUnitAndGridTouched(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
#if TEST_NAV
Test_Nav(gridTouched);
return;
#endif
#if TEST_RANGE
Test_Range(gridTouched);
return;
#endif
#if TEST_REMOTE_RANGE
Test_RemoteRange(gridTouched);
return;
#endif
if (battleUnitTouched != null && battleUnitTouched.battleBehaviourSystem != null)
{
battleUnitTouched.battleBehaviourSystem.Think();
}
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
//通知helper处理点击反馈逻辑
manualOperationHelper.OnBattleUnitAndGridTouched(gridTouched, battleUnitTouched);
}
//开始战斗
private void Fight()
{
battleState = BattleState.Fighting;
BattleUnit actionUnit = null;
do
{
//连接渲染器，则一步一更新
//没有连接渲染器，则一直计算直到结束
actionUnit = actionQueue.Peek();
if (firstFight)
{
firstFight = false;
}
else
{
if (actionUnit.BPStage)
{
UtilityHelper.Log("We are in BP stage, continue to fight");
actionUnit.battleUnitAttribute.BPUsed();
}
else
{
UtilityHelper.Log("change queue order");
if (actionUnit.battleUnitAttribute.BPUsingStage())
{
actionUnit.battleUnitAttribute.OutOfBPAction();
}
actionQueue.Dequeue();
CalculateNextAction(actionUnit);
actionUnit = actionQueue.Peek();
}
}
//增加BP值
if (actionUnit.battleUnitAttribute.manualOperation &&
actionUnit.battleUnitAttribute.BPUsingStage() == false)
{
if (actionUnit.battleUnitAttribute.BP < EGameConstL.BPMax)
{
actionUnit.battleUnitAttribute.BP++;
}
}
if (actionUnit == null)
{
battleState = BattleState.End;
break;
}
if (actionUnit.CanAction)
{
HeroActionState state = actionUnit.BattleAction();
switch (state)
{
case HeroActionState.Normal:
battleState = BattleState.Fighting;
break;
case HeroActionState.WaitForPlayerChoose:
battleState = BattleState.WaitForPlayer;
break;
case HeroActionState.Error:
battleState = BattleState.Exception;
break;
case HeroActionState.Warn:
battleState = BattleState.Exception;
UtilityHelper.LogWarning(string.Format("Warning: battle action state warning -> {0}", actionUnit.ToString()));
break;
default:
break;
}
}
if (battleFieldEvents.Count > EGameConstL.BattleFieldMaxActions)
{
UtilityHelper.LogError("Battle actions overflow max limit.");
battleState = BattleState.Exception;
}
else
{
//只在这种情况下做战斗结束的判断
if (!actionUnit.CanAction ||
actionUnit.targetBattleUnit == null ||
!actionUnit.targetBattleUnit.CanAction)
{
CheckBattleEnd();
}
}
} while (battleFieldRenderer == null &&
battleState != BattleState.End &&
battleState != BattleState.Exception);
//连接了渲染器，一步一表现
if (battleFieldRenderer != null)
{
if (battleState == BattleState.WaitForPlayer)
{
battleFieldRenderer.PlayBattle(null);
}
else
{
battleFieldRenderer.PlayBattle(Run);
}
}
else
{
Run();
}
}
/// <summary>
/// 计算单个效果
/// </summary>
/// <param name="releaser">释放者</param>
/// <param name="target">目标</param>
/// <param name="battleSkill">技能</param>
/// <param name="mainEffect">是否主要伤害</param>
/// <returns>技能结果</returns>
public BattleUnitSkillResult CalcSingle(BattleUnit releaser, BattleUnit target, SO_BattleSkill battleSkill, bool mainEffect)
{
BattleUnitSkillResult result = new BattleUnitSkillResult();
result.battleUnit = target;
result.battleSkill = battleSkill;
result.syncAttribute = new BattleUnitSyncAttribute();
//简单计算生命值
switch (battleSkill.damageType)
{
case BattleSkillDamageType.Physical:
case BattleSkillDamageType.Move:
case BattleSkillDamageType.Skill:
float critRatio = releaser.battleUnitAttribute.GetTargetCritRatio(target); //判断是否暴击
float critNum = Random.Range(0.0f, 1.0f);
if (critNum < critRatio)
{
result.crit = true;
}
else
{
result.crit = false;
}
float hpChanged = releaser.battleUnitAttribute.power * battleSkill.powerModulus; //力量补正
hpChanged += releaser.battleUnitAttribute.speed * battleSkill.speedModulus; //速度补正
hpChanged += releaser.battleUnitAttribute.technic * battleSkill.technicModulus; //技巧补正
hpChanged += releaser.battleUnitAttribute.power * EGameConstL.PowerCommonModulus; //力量值附加补正
hpChanged *= releaser.battleUnitAttribute.AtkUpRatio; //通用攻击力提升
hpChanged *= releaser.battleUnitAttribute.GetDamageTypeModulus(target); //属性克制补正
hpChanged = Mathf.Max(0, hpChanged - target.battleUnitAttribute.Def); //直接减去目标防御值
if (result.crit)
{
hpChanged *= 2; //判断是否暴击
}
result.syncAttribute.hpChanged = (int)-hpChanged; //(Mathf.Max(0, releaser.battleUnitAttribute.Atk - target.battleUnitAttribute.Def + battleSkill.mainValue));
//能量不变
result.syncAttribute.energyChanged = 0;
result.syncAttribute.currentEnergy = target.battleUnitAttribute.energy;
float avoidRatio = releaser.battleUnitAttribute.GetTargetAvoidRatio(target); //判断是否闪避
float avoidNum = Random.Range(0.0f, 1.0f);
if (!result.crit && avoidNum < avoidRatio)
{
result.syncAttribute.hpChanged = 0;
result.avoid = true;
}
else
{
result.avoid = false;
}
UtilityHelper.LogFormat("Is critical: {0}, Is avoid: {1}", result.crit, result.avoid);
break;
case BattleSkillDamageType.Heal:
result.syncAttribute.hpChanged = Mathf.Min(battleSkill.mainValue, target.battleUnitAttribute.maxHp - target.battleUnitAttribute.hp);
//能量不变
result.syncAttribute.energyChanged = 0;
result.syncAttribute.currentEnergy = target.battleUnitAttribute.energy;
break;
default:
break;
}
//hp变化
target.battleUnitAttribute.hp += result.syncAttribute.hpChanged;
target.battleUnitAttribute.hp = Mathf.Clamp(target.battleUnitAttribute.hp, 0, target.battleUnitAttribute.maxHp);
//记录变化
result.syncAttribute.currentHP = target.battleUnitAttribute.hp;
return(result);
}
public BattleSkillEffectAnalysis AnalyseBattleSkillEffect(SO_BattleSkill battleSkill, BattleUnit releaser = null, BattleUnit targetBattleUnit = null, GridUnit targetGridUnit = null)
{
battleSkillEffectAnalysis.Reset();
if (releaser == null)
{
UtilityHelper.LogError("Analyse Battle Skill Effect error.Releaser is none.");
return(null);
}
switch (battleSkill.targetType)
{
//对战斗单位
case BattleSkillTargetType.BattleUnit:
if (targetBattleUnit == null)
{
return(null);
}
else
{
battleSkillEffectAnalysis.battleSkill = battleSkill;
//记录主要影响
battleSkillEffectAnalysis.mainReceiver.Add(targetBattleUnit);
if (battleSkill.effectRadius > 0)
{
//暂时定为次要目标与主要目标同类
BattleTeam battleTeam = targetBattleUnit.battleField.GetBattleTeam(targetBattleUnit, true);
if (battleTeam != null)
{
for (int i = 0; i < battleTeam.battleUnits.Count; ++i)
{
if (!battleTeam.battleUnits[i].CanAction || battleTeam.battleUnits[i].Equals(targetBattleUnit))
{
continue;
}
//有次要影响
if (battleTeam.battleUnits[i].mapGrid.Distance(targetBattleUnit.mapGrid) <= battleSkill.effectRadius)
{
battleSkillEffectAnalysis.minorReceiver.Add(battleTeam.battleUnits[i]);
}
}
}
}
}
break;
//对自己
case BattleSkillTargetType.Self:
battleSkillEffectAnalysis.battleSkill = battleSkill;
//记录主要影响
battleSkillEffectAnalysis.mainReceiver.Add(releaser);
if (battleSkill.effectRadius > 0)
{
//暂时定为次要目标与主要目标同类
BattleTeam battleTeam = releaser.battleField.GetBattleTeam(releaser, true);
if (battleTeam != null)
{
for (int i = 0; i < battleTeam.battleUnits.Count; ++i)
{
if (!battleTeam.battleUnits[i].CanAction || battleTeam.battleUnits[i].Equals(releaser))
{
continue;
}
//有次要影响
if (battleTeam.battleUnits[i].mapGrid.Distance(releaser.mapGrid) <= battleSkill.effectRadius)
{
battleSkillEffectAnalysis.minorReceiver.Add(battleTeam.battleUnits[i]);
}
}
}
}
break;
//对某个地点
case BattleSkillTargetType.GridUnit:
if (targetGridUnit == null)
{
return(null);
}
else
{
battleSkillEffectAnalysis.battleSkill = battleSkill;
if (battleSkill.effectRadius > 0)
{
BattleTeam battleTeam = releaser.battleField.GetBattleTeam(releaser, battleSkill.damageType == BattleSkillDamageType.Heal);
if (battleTeam != null)
{
for (int i = 0; i < battleTeam.battleUnits.Count; ++i)
{
if (!battleTeam.battleUnits[i].CanAction || battleTeam.battleUnits[i].Equals(releaser))
{
continue;
}
//记录主要影响
if (battleTeam.battleUnits[i].mapGrid.Distance(targetGridUnit) <= battleSkill.effectRadius)
{
battleSkillEffectAnalysis.mainReceiver.Add(battleTeam.battleUnits[i]);
}
}
}
}
}
break;
default:
break;
}
return(battleSkillEffectAnalysis);
}
public void OnEnter(BattleUnit battleUnit)
{
this.battleUnit = battleUnit;
UpdateRuntimePasses(false);
}
public void BattleUnitUseItem(BattleUnit battleUnit, SO_PackageItem item, int count)
{
manualOperationHelper.BattleUnitUseItem(battleUnit, item, count);
}
//某个战斗单位点击了待命
public void BattleUnitStay(BattleUnit battleUnit)
{
manualOperationHelper.BattleUnitStay(battleUnit);
}
//点击了技能，在单体带环绕的技能情况下
private void OnBattleUnitAndGridTouched_StateSkill_SurroundBattleUnit(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//没有点中战斗单位
if (battleUnitTouched == null)
{
return;
}
//是否是有效单位
if (usedManualReleaseAnalysisor.suitableUnits.Contains(battleUnitTouched))
{
//重复点击同一个有效的战斗单位，则释放技能
if (battleUnitTouched.battleUnitRenderer.Equals(selectedBattleUnitRenderer))
{
ManualSkill(battleUnitTouched);
return;
}
else if (selectedBattleUnitRenderer != null)
{
//取消选中
selectedBattleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
//显示新的范围
selectedBattleUnitRenderer = battleUnitTouched.battleUnitRenderer;
//范围内战斗单位设置为选中
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
if (usedManualReleaseAnalysisor.suitableUnits[i].mapGrid.Distance(gridTouched) <= usedManualReleaseAnalysisor.battleSkill.effectRadius)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
}
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillEffectRange,
gridTouched.row,
gridTouched.column,
usedManualReleaseAnalysisor.battleSkill.effectRadius);
}
//不是有效单位
else if (usedManualReleaseAnalysisor.distanceLimit.Contains(battleUnitTouched))
{
UtilityHelper.Log("目标超出攻击范围");
}
//队伍不符合
else if (usedManualReleaseAnalysisor.teamLimit.Contains(battleUnitTouched))
{
UtilityHelper.Log("不能对同一个队伍的单位使用这个技能");
}
else
{
UtilityHelper.Log("目标单位无效");
}
}
//点击了技能，在单体目标技能情况下
private void OnBattleUnitAndGridTouched_StateSkill_SingleBattleUnitTarget(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//没有点中战斗单位
if (battleUnitTouched == null)
{
return;
}
//点中了可以被使用技能的单位
if (usedManualReleaseAnalysisor.suitableUnits.Contains(battleUnitTouched))
{
ManualSkill(battleUnitTouched);
}
//点中了超出距离的
else if (usedManualReleaseAnalysisor.distanceLimit.Contains(battleUnitTouched))
{
UtilityHelper.Log("目标超出攻击范围");
}
//同一个队伍
else if (usedManualReleaseAnalysisor.teamLimit.Contains(battleUnitTouched))
{
UtilityHelper.Log("不能对同一个队伍的单位使用这个技能");
}
else
{
UtilityHelper.Log("无效的目标单位");
}
}
//点击了地块、战斗单位 -- 在当前是选择移动目标的情况下
private void OnBattleUnitAndGridTouched_StateMove(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//点中了战斗单位
if (battleUnitTouched != null)
{
//显示战斗单位的详情
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
//点中了地图
else
{
//障碍物不能作为移动目标(暂时)
if (gridTouched.GridType == GridType.Obstacle)
{
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
else
{
//点击是否超出了范围
GridUnit fromGrid = manualOperatingBattleUnitRenderer.battleUnit.mapGrid;
if (fromGrid.Distance(gridTouched) > manualOperatingBattleUnitRenderer.battleUnit.battleUnitAttribute.mobility)
{
UtilityHelper.Log("超出了移动半径！");
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
else
{
MapNavigator.Instance.NewNavigate(
manualOperatingBattleUnitRenderer.battleUnit,
fieldRenderer.battleField.battleMap,
fromGrid,
gridTouched,
UtilityObjs.gridUnits);
//判断移动是否可以到达
//bool result = MapNavigator.Instance.Navigate(
// fieldRenderer.battleField.battleMap,
// fromGrid,
// gridTouched,
// UtilityObjs.gridUnits,
// null,
// manualOperatingBattleUnitRenderer.battleUnit.battleUnitAttribute.mobility
// );
bool result = MapNavigator.Instance.NewNavigate(
manualOperatingBattleUnitRenderer.battleUnit,
fieldRenderer.battleField.battleMap,
fromGrid,
gridTouched,
UtilityObjs.gridUnits);
//判断是否可以到达(导航成功且可以可以到达)
if (result && UtilityObjs.gridUnits[UtilityObjs.gridUnits.Count - 1].Equals(gridTouched))
{
//可以到达
ManualMoveTo(gridTouched, UtilityObjs.gridUnits.ToArray());
UtilityObjs.gridUnits.Clear();
}
else
{
//不可以到达
UtilityHelper.Log("点击位置不可到达！");
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
}
}
}
}
//使用道具
public void UseItem(BattleUnit battleUnit, SO_PackageItem item, int count)
{
}
//某个战斗单位点击了使用技能
public void BattleUnitUseSkill(BattleUnit battleUnit, SO_BattleSkill skill)
{
if (battleUnit == null ||
battleUnit.battleUnitRenderer == null ||
!battleUnit.battleUnitRenderer.Equals(manualOperatingBattleUnitRenderer))
{
UtilityHelper.LogError("Battle unit use skill failed.");
HideManualActionList();
return;
}
//获取推算的技能释放结果
usedManualReleaseAnalysisor = BattleCalculator.Instance.ManualReleaseAnalysisor;
//分析结果
usedManualReleaseAnalysisor.Analysis(manualOperatingBattleUnitRenderer.battleUnit, skill);
//显示技能释放范围
if (skill.GetReleaseRadius(battleUnit.mapGrid) > 0)
{
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillReleaseRange,
battleUnit.mapGrid.row,
battleUnit.mapGrid.column,
skill.GetReleaseRadius(battleUnit.mapGrid));
}
//根据类型判断技能显示状态
switch (skill.targetType)
{
//对单个目标
case BattleSkillTargetType.BattleUnit:
//可以被选中的
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selectable);
}
//不可以被选中的
for (int i = 0; i < usedManualReleaseAnalysisor.distanceLimit.Count; ++i)
{
usedManualReleaseAnalysisor.distanceLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.NotSelectable);
}
//队伍不合适的
for (int i = 0; i < usedManualReleaseAnalysisor.teamLimit.Count; ++i)
{
usedManualReleaseAnalysisor.teamLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
//设定技能操作类型
skillOperationType = skill.effectRadius > 0 ? SkillOperationType.SurroundBattleUnit : SkillOperationType.SingleBattleUnitTarget;
break;
//对范围(某一个位置)目标
case BattleSkillTargetType.GridUnit:
skillOperationType = SkillOperationType.GridUnitTarget;
//如果没有位置可选，则直接打开范围
if (skill.GetReleaseRadius(battleUnit.mapGrid) <= 0)
{
//可以被选中，标记为已被选中
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
//不可以被选中的
for (int i = 0; i < usedManualReleaseAnalysisor.distanceLimit.Count; ++i)
{
usedManualReleaseAnalysisor.distanceLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.NotSelectable);
}
//队伍不合适的
for (int i = 0; i < usedManualReleaseAnalysisor.teamLimit.Count; ++i)
{
usedManualReleaseAnalysisor.teamLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
OnBattleUnitAndGridTouched_StateSkill_GridUnitTarget(battleUnit.mapGrid, null);
}
else
{
//需要指定范围，需要点击目标地块
}
break;
//以自身为中心的
case BattleSkillTargetType.Self:
//可以被选中，标记为已被选中
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
//不可以被选中的
for (int i = 0; i < usedManualReleaseAnalysisor.distanceLimit.Count; ++i)
{
usedManualReleaseAnalysisor.distanceLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.NotSelectable);
}
//队伍不合适的
for (int i = 0; i < usedManualReleaseAnalysisor.teamLimit.Count; ++i)
{
usedManualReleaseAnalysisor.teamLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
skillOperationType = SkillOperationType.SurroundSelf;
//省去一步点击操作，直接展示区域
OnBattleUnitAndGridTouched_StateSkill_SurroundSelf(battleUnit.mapGrid, battleUnit);
break;
default:
break;
}
//切换操作状态
manualOperationState = ManualOperationState.Skill;
HideManualActionList();
}
public void OnLeave()
{
this.battleUnit = null;
UpdateRuntimePasses(false);
}
public float GetTargetAvoidRatio(BattleUnit target)
{
return(Mathf.Clamp((target.battleUnitAttribute.speed / speed) * 0.5f, 0.0f, 1.0f)); //待修改的公式
}
public float GetTargetCritRatio(BattleUnit target)
{
return(Mathf.Clamp((technic / target.battleUnitAttribute.technic) * 0.2f, 0.0f, 1.0f)); //待修改的公式
}
//点击了技能，在以自身为原点的技能情况下
private void OnBattleUnitAndGridTouched_StateSkill_SurroundSelf(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//当前选定的战斗单位为空，表示还没有显示攻击范围
if (selectedBattleUnitRenderer == null)
{
selectedBattleUnitRenderer = battleUnitTouched.battleUnitRenderer;
//展示攻击区域
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillEffectRange,
selectedBattleUnitRenderer.battleUnit.mapGrid.row,
selectedBattleUnitRenderer.battleUnit.mapGrid.column,
usedManualReleaseAnalysisor.battleSkill.effectRadius);
}
else
{
//点击任意位置判断为释放
ManualSkill(manualOperatingBattleUnitRenderer.battleUnit.mapGrid);
}
}
//某个战斗单位点击了移动
public void BattleUnitMove(BattleUnit battleUnit)
{
manualOperationHelper.BattleUnitMove(battleUnit);
}
//点击了技能，在以固定地点为原点的技能情况下
private void OnBattleUnitAndGridTouched_StateSkill_GridUnitTarget(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//如果当前有点中的格子
if (selectedGridUnitRenderer != null &&
(selectedGridUnitRenderer.Equals(gridTouched.gridUnitRenderer) || usedManualReleaseAnalysisor.battleSkill.GetReleaseRadius(usedManualReleaseAnalysisor.releaser.mapGrid) <= 0))
{
//如果当前的释放距离为0，表示无需二次点击确认，直接释放
if (usedManualReleaseAnalysisor.battleSkill.GetReleaseRadius(usedManualReleaseAnalysisor.releaser.mapGrid) <= 0)
{
ManualSkill(manualOperatingBattleUnitRenderer.battleUnit.mapGrid);
return;
}
//点中了重复的格子，判断是否有目标
bool hasTarget = false;
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
if (usedManualReleaseAnalysisor.suitableUnits[i].mapGrid.Distance(gridTouched) <= usedManualReleaseAnalysisor.battleSkill.effectRadius)
{
hasTarget = true;
break;
}
}
//有目标，则释放
if (hasTarget)
{
ManualSkill(gridTouched);
}
else
{
UtilityHelper.Log("范围内没有目标");
}
}
else
{
//这个格子不在范围内
if (manualOperatingBattleUnitRenderer.battleUnit.mapGrid.Distance(gridTouched) <= usedManualReleaseAnalysisor.battleSkill.GetReleaseRadius(usedManualReleaseAnalysisor.releaser.mapGrid))
{
if (selectedGridUnitRenderer != null)
{
//取消上一个范围显示
SetCircularRangeRenderStateActive(false, GridRenderType.SkillEffectRange);
//取消可被攻击单位的显示
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
}
//设置新的范围显示
selectedGridUnitRenderer = gridTouched.gridUnitRenderer;
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillEffectRange,
gridTouched.row,
gridTouched.column,
usedManualReleaseAnalysisor.battleSkill.effectRadius
);
//设置新的可被攻击单位的显示
for (int i = 0; i < usedManualReleaseAnalysisor.suitableUnits.Count; ++i)
{
if (usedManualReleaseAnalysisor.suitableUnits[i].mapGrid.Distance(gridTouched) <= usedManualReleaseAnalysisor.battleSkill.effectRadius)
{
usedManualReleaseAnalysisor.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
}
}
else
{
UtilityHelper.Log("超出区域");
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
}
}
//某个战斗单位点击了使用技能
public void BattleUnitUseSkill(BattleUnit battleUnit, SO_BattleSkill skill)
{
manualOperationHelper.BattleUnitUseSkill(battleUnit, skill);
}
//设置某个圆形区域的显示状态(每种类型只能显示一个)
public void SetCircularRangeRenderStateActive(bool active, GridRenderType gridRenderType, int centerRow = -1, int centerColumn = -1, int radius = -1)
{
//确定是哪种范围
List <GridUnit> rangeHighlightGridUnits = null;
switch (gridRenderType)
{
case GridRenderType.MoveRange:
if (centerRow != -1 && centerColumn != -1)
{
BattleUnit battleUnit = fieldRenderer.battleField.battleMap.GetGridData(centerRow, centerColumn).battleUnit;
moveRangeGridUnits = MapNavigator.Instance.GetAccessibleGrids(battleUnit, fieldRenderer.battleField.battleMap);
}
rangeHighlightGridUnits = moveRangeGridUnits;
break;
case GridRenderType.SkillReleaseRange:
rangeHighlightGridUnits = skillReleaseRangeGridUnits;
break;
case GridRenderType.SkillEffectRange:
rangeHighlightGridUnits = skillEffectRangeGridUnits;
break;
default:
UtilityHelper.LogError(string.Format("SetRangeHighlightActive error grid render type : {0}", gridRenderType));
return;
}
//当前是取消激活
if (!active)
{
for (int i = 0; i < rangeHighlightGridUnits.Count; ++i)
{
if (rangeHighlightGridUnits[i].gridUnitRenderer != null)
{
rangeHighlightGridUnits[i].gridUnitRenderer.RemoveGridRenderType(gridRenderType);
}
}
//rangeHighlightGridUnits.Clear();
}
else
{
//当前存在上一个激活，先隐藏
if (rangeHighlightGridUnits.Count > 0)
{
SetCircularRangeRenderStateActive(false, gridRenderType);
}
//获取格子
if (gridRenderType != GridRenderType.MoveRange)
{
fieldRenderer.battleField.battleMap.GetCircularGrids(centerRow, centerColumn, radius, 0, true, rangeHighlightGridUnits);
}
//设置高亮状态
for (int i = 0; i < rangeHighlightGridUnits.Count; ++i)
{
if (rangeHighlightGridUnits[i].gridUnitRenderer != null)
{
rangeHighlightGridUnits[i].gridUnitRenderer.AppendGridRenderType(gridRenderType);
}
}
}
}
public override void OnExit()
{
base.OnExit();
battleUnit = null;
}
//寻找某点到另一点的路径
public bool NewNavigate(
BattleUnit battleUnit,
BattleMap battleMap,
GridUnit from,
GridUnit to,
List <GridUnit> path,
int stopDistance = 0)
{
PathTraceData[,] flag = new PathTraceData[battleMap.mapWidth, battleMap.mapHeight];
PriorityQueue <PathTraceData> checkList = new PriorityQueue <PathTraceData>();
PathTraceData currentUnit = new PathTraceData(battleUnit.battleUnitAttribute.mobility, from);
flag[from.column, from.row] = currentUnit;
bool isFind = false;
checkList.Push(currentUnit);
while (checkList.Count > 0)
{
currentUnit = checkList.Pop();
if (currentUnit.currentGridUnit.Distance(to) <= stopDistance)
{
isFind = true;
break;
}
List <GridUnit> gridUnitList = battleMap.GetNearbyGrid(currentUnit.currentGridUnit);
foreach (GridUnit gridUnit in gridUnitList)
{
float MovePointRemainder = currentUnit.MovePointRemainder - currentUnit.currentGridUnit.m_GridAttribute.m_CrossCost;
//绝对障碍不可通过
if (gridUnit.GridType == GridType.Obstacle)
{
continue;
}
//不能跳过去，高度太高
if (gridUnit.m_GridAttribute.m_Height - currentUnit.currentGridUnit.m_GridAttribute.m_Height > battleUnit.battleUnitAttribute.springPower)
{
continue;
}
//体积太大穿不过去
if (gridUnit.m_GridAttribute.m_MaxPassVolume < battleUnit.battleUnitAttribute.volume)
{
continue;
}
//剩余移动点数不足
//if (MovePointRemainder <= 0) continue;
//有敌人挡着（暂时还没判是否是友方）
if (gridUnit.battleUnit != null && gridUnit.battleUnit.CanAction && !gridUnit.NavigationPassable)
{
continue;
}
if (flag[gridUnit.column, gridUnit.row] == null || flag[gridUnit.column, gridUnit.row].MovePointRemainder < MovePointRemainder)
{
flag[gridUnit.column, gridUnit.row] = currentUnit;
checkList.Push(new PathTraceData(MovePointRemainder, gridUnit));
}
}
}
if (!isFind)
{
return(false);
}
path.Clear();
Stack <GridUnit> temp = new Stack <GridUnit>();
while (!currentUnit.currentGridUnit.Equals(from))
{
if (currentUnit.MovePointRemainder >= 0)
{
temp.Push(currentUnit.currentGridUnit);
}
currentUnit = flag[currentUnit.currentGridUnit.column, currentUnit.currentGridUnit.row];
}
while (temp.Count != 0)
{
path.Add(temp.Pop());
}
return(true);
}
