protected void ErrorClose(string error)
{
UIViewManager.Instance.HideView(this);
UtilityHelper.LogError(error);
}
//开始战斗
private void Fight()
{
battleState = BattleState.Fighting;
BattleUnit actionUnit = null;
do
{
//连接渲染器，则一步一更新
//没有连接渲染器，则一直计算直到结束
actionUnit = actionQueue.Dequeue();
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;
}
}
//考虑是否在放回队列
CalculateNextAction(actionUnit);
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="centerRow">中心所在行</param>
/// <param name="centerColumn">中心所在列</param>
/// <param name="outerRadius">外圆半径</param>
/// <param name="innerRadius">内圆半径</param>
/// <param name="containsCenter">是否包含中心</param>
/// <param name="grids">结果格子</param>
/// <param name="filter">过滤器</param>
public void GetCircularGrids(
int centerRow, int centerColumn,
int outerRadius, int innerRadius, bool containsCenter,
List <GridUnit> grids,
System.Func <GridUnit, bool> filter = null)
{
if (grids == null)
{
return;
}
grids.Clear();
outerRadius = outerRadius < 0 ? 0 : outerRadius;
innerRadius = innerRadius < 0 ? 0 : innerRadius;
//外圆半径更小
if (outerRadius <= innerRadius && outerRadius > 0)
{
UtilityHelper.LogError(string.Format("Get Circular Grids failed.Outer radius = {0}, InnerRadius = {1}", outerRadius, innerRadius));
return;
}
if (outerRadius == 0 && containsCenter && filter == null)
{
grids.Add(GetGridData(centerRow, centerColumn));
return;
}
//按照行移动量来算
for (int i = 0; i <= outerRadius; ++i)
{
//计算每一行的范围
//行之间的差
int rowGap = i;
//移动行后所覆盖的最小、最大横坐标
int minColumn = 0;
int maxColumn = 0;
//奇数行开始时
if ((centerRow & 1) == (EGameConstL.Map_FirstRowOffset ? 0 : 1))
{
minColumn = Mathf.Max(centerColumn - (rowGap / 2), 0);
maxColumn = centerColumn + ((rowGap + 1) / 2);
}
//偶数行开始时
else
{
minColumn = Mathf.Max(centerColumn - ((rowGap + 1) / 2), 0);
maxColumn = centerColumn + (rowGap / 2);
}
//列范围
minColumn = Mathf.Max(0, minColumn - (outerRadius - i));
maxColumn = Mathf.Min(mapWidth - 1, maxColumn + (outerRadius - i));
//装入所有
for (int c = minColumn; c <= maxColumn; ++c)
{
if (i == 0)
{
//设置了内圆半径
if (innerRadius == 0 ||
(innerRadius > 0 && mapGrids[c, centerRow].Distance(mapGrids[centerColumn, centerRow]) > innerRadius))
{
if (c != centerColumn || containsCenter)
{
if (filter == null || filter(mapGrids[c, centerRow]))
{
grids.Add(mapGrids[c, centerRow]);
}
}
}
}
else
{
int temp = centerRow - i;
if (temp >= 0)
{
//设置了内圆半径
if (innerRadius == 0 ||
(innerRadius > 0 && mapGrids[c, temp].Distance(mapGrids[centerColumn, centerRow]) > innerRadius))
{
if (filter == null || filter(mapGrids[c, temp]))
{
grids.Add(mapGrids[c, temp]);
}
}
}
temp = centerRow + i;
if (temp < mapHeight)
{
//设置了内圆半径
if (innerRadius == 0 ||
(innerRadius > 0 && mapGrids[c, temp].Distance(mapGrids[centerColumn, centerRow]) > innerRadius))
{
if (filter == null || filter(mapGrids[c, temp]))
{
grids.Add(mapGrids[c, temp]);
}
}
}
}
}
}
}
//更新
public virtual void UpdateView()
{
dirty = false;
UtilityHelper.Log(string.Format("Update View -> {0}, {1}", config.viewName, this.GetInstanceID()));
}
//点击了技能，在以固定地点为原点的技能情况下
private void OnBattleUnitAndGridTouched_StateSkill_GridUnitTarget(GridUnit gridTouched, BattleUnit battleUnitTouched)
{
//如果当前有点中的格子
if (selectedGridUnitRenderer != null && selectedGridUnitRenderer.Equals(gridTouched.gridUnitRenderer))
{
//点中了重复的格子，判断是否有目标
bool hasTarget = false;
for (int i = 0; i < selectedBattleSkillAnalysis.suitableUnits.Count; ++i)
{
if (selectedBattleSkillAnalysis.suitableUnits[i].mapGrid.Distance(gridTouched) <= selectedBattleSkillAnalysis.battleSkill.rangeRadius)
{
hasTarget = true;
break;
}
}
//有目标，则释放
if (hasTarget)
{
ManualSkill(gridTouched);
}
else
{
UtilityHelper.Log("范围内没有目标");
}
}
else
{
//这个格子不在范围内
if (manualOperatingBattleUnitRenderer.battleUnit.mapGrid.Distance(gridTouched) <= selectedBattleSkillAnalysis.battleSkill.releaseRadius)
{
if (selectedGridUnitRenderer != null)
{
//取消上一个范围显示
SetCircularRangeRenderStateActive(false, GridRenderType.SkillEffectRange);
//取消可被攻击单位的显示
for (int i = 0; i < selectedBattleSkillAnalysis.suitableUnits.Count; ++i)
{
selectedBattleSkillAnalysis.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
}
//设置新的范围显示
selectedGridUnitRenderer = gridTouched.gridUnitRenderer;
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillEffectRange,
gridTouched.row,
gridTouched.column,
selectedBattleSkillAnalysis.battleSkill.rangeRadius
);
//设置新的可被攻击单位的显示
for (int i = 0; i < selectedBattleSkillAnalysis.suitableUnits.Count; ++i)
{
if (selectedBattleSkillAnalysis.suitableUnits[i].mapGrid.Distance(gridTouched) <= selectedBattleSkillAnalysis.battleSkill.rangeRadius)
{
selectedBattleSkillAnalysis.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
}
}
else
{
UtilityHelper.Log("超出区域");
UIViewManager.Instance.ShowView(UIViewName.BattleFieldUnitInfo, gridTouched, battleUnitTouched);
}
}
}
//某个战斗单位点击了使用技能
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.");
UIViewManager.Instance.HideView(UIViewName.BattleFieldPlayerActOption);
return;
}
//获取推算的技能释放结果
selectedBattleSkillAnalysis = BattleCalculator.Instance.AnalyseBattleSkill(battleUnit, skill);
if (selectedBattleSkillAnalysis == null)
{
UtilityHelper.LogError("Battle unit use skill failed.Error analyse.");
UIViewManager.Instance.HideView(UIViewName.BattleFieldPlayerActOption);
return;
}
//显示技能释放范围
if (skill.releaseRadius > 0)
{
SetCircularRangeRenderStateActive(
true,
GridRenderType.SkillReleaseRange,
battleUnit.mapGrid.row,
battleUnit.mapGrid.column,
skill.releaseRadius);
}
//根据类型判断技能显示状态
switch (skill.targetType)
{
//对单个目标
case BattleSkillTargetType.BattleUnit:
//可以被选中的
for (int i = 0; i < selectedBattleSkillAnalysis.suitableUnits.Count; ++i)
{
selectedBattleSkillAnalysis.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selectable);
}
//不可以被选中的
for (int i = 0; i < selectedBattleSkillAnalysis.distanceLimit.Count; ++i)
{
selectedBattleSkillAnalysis.distanceLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.NotSelectable);
}
//队伍不合适的
for (int i = 0; i < selectedBattleSkillAnalysis.teamLimit.Count; ++i)
{
selectedBattleSkillAnalysis.teamLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
//设定技能操作类型
skillOperationType = skill.rangeRadius > 0 ? SkillOperationType.SurroundBattleUnit : SkillOperationType.SingleBattleUnitTarget;
break;
//对范围(某一个位置)目标
case BattleSkillTargetType.GridUnit:
//以自身为中心攻击周围目标
if (skill.releaseRadius <= 0)
{
//可以被选中，标记为已被选中
for (int i = 0; i < selectedBattleSkillAnalysis.suitableUnits.Count; ++i)
{
selectedBattleSkillAnalysis.suitableUnits[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Selected);
}
//不可以被选中的
for (int i = 0; i < selectedBattleSkillAnalysis.distanceLimit.Count; ++i)
{
selectedBattleSkillAnalysis.distanceLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.NotSelectable);
}
//队伍不合适的
for (int i = 0; i < selectedBattleSkillAnalysis.teamLimit.Count; ++i)
{
selectedBattleSkillAnalysis.teamLimit[i].battleUnitRenderer.UpdateRenderState(BattleUnitRenderState.Normal);
}
skillOperationType = SkillOperationType.SurroundSelf;
//省去一步点击操作，直接展示区域
OnBattleUnitAndGridTouched_StateSkill_SurroundSelf(battleUnit.mapGrid, battleUnit);
}
//需要指定范围，需要点击目标地块
else
{
skillOperationType = SkillOperationType.GridUnitTarget;
}
break;
default:
break;
}
//切换操作状态
manualOperationState = ManualOperationState.Skill;
UIViewManager.Instance.HideView(UIViewName.BattleFieldPlayerActOption);
}
//移动
private IEnumerator PlayMotionAction(BattleHeroMotionAction action)
{
if (action == null)
{
UtilityHelper.LogError("Error BattleHeroMotionAction");
yield break;
}
AddBattleBeSelected(this, EGameConstL.Color_Cyan);
AddBattleBeSelected(action.targetUnit.battleUnitRenderer, EGameConstL.Color_Yellow);
//先显示区域
UtilityObjs.gridUnits.Clear();
battleUnit.battleField.battleMap.GetRangeGrids(action.fromGrid.row, action.fromGrid.column, action.moveRange, UtilityObjs.gridUnits);
for (int i = 0; i < UtilityObjs.gridUnits.Count; ++i)
{
if (UtilityObjs.gridUnits[i].GridType == GridType.Obstacle)
{
continue;
}
if (UtilityObjs.gridUnits[i].gridUnitRenderer != null)
{
UtilityObjs.gridUnits[i].gridUnitRenderer.GridRenderType = GridRenderType.Range;
}
}
//显示路径
for (int i = 0; i < action.gridPath.Length; ++i)
{
if (action.gridPath[i].gridUnitRenderer)
{
action.gridPath[i].gridUnitRenderer.GridRenderType = GridRenderType.Path;
}
}
//yield return EGameConstL.WaitForTouchedScreen;
//移动
for (int i = 0; i < action.gridPath.Length; ++i)
{
UpdatePositionByGrid(action.gridPath[i]);
yield return(EGameConstL.WaitForDotOneSecond);
}
//清空范围和路径
for (int i = 0; i < UtilityObjs.gridUnits.Count; ++i)
{
if (UtilityObjs.gridUnits[i].GridType == GridType.Obstacle)
{
continue;
}
if (UtilityObjs.gridUnits[i].gridUnitRenderer != null)
{
UtilityObjs.gridUnits[i].gridUnitRenderer.GridRenderType = GridRenderType.Normal;
}
}
for (int i = 0; i < action.gridPath.Length; ++i)
{
if (action.gridPath[i].gridUnitRenderer)
{
action.gridPath[i].gridUnitRenderer.GridRenderType = GridRenderType.Normal;
}
}
ClearAllSelectedBattleUnit();
}
//搜索目标
private TargetSearchResult SearchTarget(List <BattleAction> actions)
{
//按照距离排序敌人
UtilityObjs.battleUnits.Clear();
//只考虑可以行动的
for (int i = 0; i < enemyTeam.battleUnits.Count; ++i)
{
if (enemyTeam.battleUnits[i].CanAction)
{
UtilityObjs.battleUnits.Add(enemyTeam.battleUnits[i]);
}
}
//天下无敌了，还有谁？？
if (UtilityObjs.battleUnits.Count == 0)
{
return(TargetSearchResult.Inexistence);
}
//结果类型
TargetSearchResult searchResult = TargetSearchResult.InRange;
//按照距离排序
UtilityObjs.battleUnits.Sort(delegate(BattleUnit b1, BattleUnit b2)
{
return(mapGrid.Distance(b1.mapGrid) - mapGrid.Distance(b2.mapGrid));
});
//暂时不添加复杂的逻辑，只选择直线距离最近的
BattleUnit newTarget = null;
GridUnit newTargetGrid = null;
for (int i = 0; i < UtilityObjs.battleUnits.Count; ++i)
{
//如果当前目标就在范围内
if (mapGrid.Distance(UtilityObjs.battleUnits[i].mapGrid) <= 1)
{
//设置目标，但是不需要移动
newTarget = UtilityObjs.battleUnits[i];
toTargetPath.Clear();
targetGrid = null;
searchResult = TargetSearchResult.InRange;
break;
}
//目标不在周围需要移动
newTargetGrid = battleField.battleMap.GetEmptyGrid(mapGrid, UtilityObjs.battleUnits[i].mapGrid, toTargetPath, mobility);
if (newTargetGrid == null)
{
//UtilityHelper.LogWarning(battleUnitID + "找不到空格子了,看看下一个吧");
continue;
}
else
{
newTarget = UtilityObjs.battleUnits[i];
searchResult = TargetSearchResult.NeedMove;
break;
}
}
if (newTarget == null)
{
UtilityHelper.LogWarning("确实找不到了");
targetBattleUnit = null;
targetGrid = null;
toTargetPath.Clear();
if (actions != null)
{
//创建一个warning
BattleHeroWarningAction action = new BattleHeroWarningAction(this, "No target:" + battleUnitID);
actions.Add(action);
}
return(TargetSearchResult.Inexistence);
}
//目标不一致，切换目标
if (targetBattleUnit != newTarget)
{
//切换目标
BattleHeroChangeTargetAction action = new BattleHeroChangeTargetAction(this);
action.lastTargetUnit = targetBattleUnit;
action.newTargetUnit = newTarget;
//设置当前目标以及格子
targetBattleUnit = newTarget;
actions.Add(action);
}
//移动的格子重新设置
targetGrid = newTargetGrid;
return(searchResult);
}
public void Init(params object[] args)
{
UtilityHelper.Log("Battle unit data manager inited.");
}
