public PathCell(Cell cell, CellPartEnum prevDirection, CellPartEnum nextDirection)
{
_cell = cell;
_prevDirection = prevDirection;
_nextDirection = nextDirection;
_isAvoidObstracle = false;
}
private bool FindPath_Sub(Cell cell, Cell cellDest, ArrayList path, CellPartEnum direction, ArrayList deadPath,
bool ignoreDestCharacter, bool ignoreObstacle, bool useStraightAngle)
{
Debug.WriteLine(string.Format("Find cell at {0}", direction));
Cell cellNext = null;
if (direction == CellPartEnum.Center)
cellNext = null;
else
cellNext = cell._adjacentCells[direction];
if (cellNext == null)
{
// no more cell found
Debug.WriteLine(string.Format("No cell"));
// get new direction
CellPartEnum direction2 = FindDirection(cell.GetCenterPoint(), cellDest.GetCenterPoint());
if (direction == direction2)
{
switch (direction2)
{
case CellPartEnum.LowerRight:
direction2 = CellPartEnum.LowerLeft;
break;
case CellPartEnum.LowerLeft:
direction2 = CellPartEnum.LowerRight;
break;
case CellPartEnum.UpperLeft:
direction2 = CellPartEnum.UpperRight;
break;
case CellPartEnum.UpperRight:
direction2 = CellPartEnum.UpperLeft;
break;
}
}
direction = direction2;
//Debug.WriteLine(string.Format("Find cell on {0}", direction));
return FindPath_Sub(cell, cellDest, path, direction, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
if (!cellNext.HasPassability() || deadPath.Contains(cellNext))
{
// has character or dead cell
//Debug.WriteLine(string.Format("Obstacle found"));
if (ignoreDestCharacter)
{
if (cellNext.Equals(cellDest))
{
path.Add(cellNext);
// end
return true;
}
}
if (ignoreObstacle)
{
return FindPath_Good(cellNext, cellDest, direction, path, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
else
{
// change direction
Cell cellNextTest = GetPathNextCell(cell, cellDest, direction, deadPath);
if (cellNextTest != null)
{
// if go backward, remove unwanted (dead) cell
if (path.Contains(cellNextTest))
{
int index = path.IndexOf(cellNextTest);
while (path.Count - 1 > index)
{
Cell deadCell = (Cell)path[path.Count - 1];
deadPath.Add(deadCell);
path.RemoveAt(path.Count - 1);
}
}
//Debug.WriteLine(string.Format("ChangeDir, {0},{1},{2}", direction, cellNextTest._row, cellNextTest._col));
cellNext = cellNextTest;
path.Add(cellNext);
// continue to find next cell
cell = cellNext;
}
else
{
// cannot move
// end
Debug.WriteLine(string.Format("No more move"));
return false;
}
return FindPath_Sub(cell, cellDest, path, direction, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
}
return FindPath_Good(cellNext, cellDest, direction, path, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
private bool FindPath_Good(Cell cellNext, Cell cellDest, CellPartEnum direction, ArrayList path, ArrayList deadPath,
bool ignoreDestCharacter, bool ignoreObstacle, bool useStraightAngle)
{
//Debug.WriteLine(string.Format("Accept cell {0},{1}", cellNext._row, cellNext._col));
path.Add(cellNext);
if (cellNext.Equals(cellDest))
{
// end
//Debug.WriteLine("Reach Destination");
return true;
}
if (useStraightAngle)
direction = CellPartEnum.Center;
else
{
// change direction if has whole/direct angle
double degree = FindDegree(cellNext.GetCenterPoint(), cellDest.GetCenterPoint());
if (Math.Abs(degree) <= 0.05)
direction = CellPartEnum.CenterRight;
else if (Math.Abs(degree - DIGONAL_ANGLE) <= 0.05)
direction = CellPartEnum.LowerRight;
else if (Math.Abs(degree - (180 - DIGONAL_ANGLE)) <= 0.05)
direction = CellPartEnum.LowerLeft;
else if (Math.Abs(degree - 180) <= 0.05)
direction = CellPartEnum.CenterLeft;
else if (Math.Abs(degree - (180 + DIGONAL_ANGLE)) <= 0.05)
direction = CellPartEnum.UpperLeft;
else if (Math.Abs(degree - (360 - DIGONAL_ANGLE)) <= 0.05)
direction = CellPartEnum.UpperRight;
}
return FindPath_Sub(cellNext, cellDest, path, direction, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
private void FindPathAvoid_SubAdj(ArrayList directPath, ArrayList adjCells, ArrayList obsCells,
List<ArrayList> pathAvoidLst, ArrayList pathAvoid, Cell prevCell)
{
ArrayList pathAvoid2 = null;
foreach (Cell adjCell in prevCell._adjacentCells.Values)
{
if (pathAvoid.Contains(adjCell)) continue;
if (obsCells.Contains(adjCell)) continue;
if (!directPath.Contains(adjCell) && !adjCells.Contains(adjCell)) continue;
Debug.WriteLine(string.Format("PA_SubAdj:{0},{1}", adjCell._row, adjCell._col));
{
// clone a new pathAvoid
pathAvoid2 = new ArrayList();
foreach (Cell cellClone in pathAvoid)
{
pathAvoid2.Add(cellClone);
}
pathAvoidLst.Add(pathAvoid2);
}
if (directPath.Contains(adjCell))
{
pathAvoid2.Add(adjCell);
continue;
}
pathAvoid2.Add(adjCell);
FindPathAvoid_SubAdj(directPath, adjCells, obsCells, pathAvoidLst, pathAvoid2, adjCell);
}
pathAvoidLst.Remove(pathAvoid);
}
private void GetAdjCells(ArrayList directPath, ArrayList adjCells, ArrayList obstacles, Cell directCell)
{
foreach (Cell adjCell in directCell._adjacentCells.Values)
{
if (adjCell == null) continue;
if (directPath.Contains(adjCell)) continue;
if (adjCells.Contains(adjCell)) continue;
if (!adjCell.HasPassability())
{
if (obstacles.Contains(adjCell)) continue;
obstacles.Add(adjCell);
GetAdjCells(directPath, adjCells, obstacles, adjCell);
}
else
adjCells.Add(adjCell);
}
}
public static Action CreateShootAction(StandardCharacter character, CellPartEnum attackDirection,
ArrayList targets, Cell targetCell)
{
Action action = new Action(ActionTypeEnum.RangeAttack);
SubAction subAction = new SubAction();
action._subActions.Add(subAction);
subAction._character = character;
// add getting hit or death
ArrayList defendTriggers = new ArrayList();
ArrayList hitTriggers = new ArrayList();
foreach (Heroes.Core.Battle.Characters.Armies.Army target in targets)
{
SubAction subAction2 = new SubAction();
action._subActions.Add(subAction2);
subAction2._character = target;
AnimationSequence animationSeq = null;
if (target._isDead)
animationSeq = subAction2.AddDeath(attackDirection);
else if (target._isDefend)
animationSeq = subAction2.AddDefend(attackDirection);
else
animationSeq = subAction2.AddGettingHit(attackDirection);
subAction2._currentAnimationSeq = animationSeq;
if (target._isDefend)
defendTriggers.Add(animationSeq);
else
hitTriggers.Add(animationSeq);
}
subAction.AddStartShoot(attackDirection, defendTriggers);
subAction.AddStopShoot(attackDirection, hitTriggers);
subAction._currentAnimationSeq = (AnimationSequence)subAction._animationSeqs[0];
return action;
}
private void SetDestCell(StandardCharacter c, Cell cell)
{
c._cell._character = null;
c._cell = cell;
c._cell._character = c;
}
public void InitCell(Cell cell)
{
_cell = cell;
Point pt = cell.GetStandingPoint();
this._currentAnimationPt = pt;
this._destAnimationPt = new Point(pt.X, pt.Y);
}
private void BuildCells()
{
_cells = new Cell[_rowCount, _colCount];
_rowTops = new int[_rowCount];
_rowBottoms = new int[_rowCount];
_colLefts = new int[_rowCount, _colCount];
_colRights = new int[_rowCount, _colCount];
int startx = 58;
int starty = 86;
int x = startx;
int y = starty;
for (int row = 0; row < _rowCount; row++)
{
_rowTops[row] = y;
if (row % 2 == 1)
x = startx;
else
x = startx + Cell.WIDTH_MIDDLE - 1;
for (int col = 0; col < _colCount; col++)
{
_colLefts[row, col] = x;
_cells[row, col] = new Cell(row, col, x, y);
x += Cell.WIDTH_BODY - 1;
_colRights[row, col] = x;
}
y += Cell.HEIGHT_HEAD + Cell.HEIGHT_BODY;
_rowBottoms[row] = y + Cell.HEIGHT_HEAD;
}
// build surrounding cell
for (int row = 0; row < _rowCount; row++)
{
for (int col = 0; col < _colCount; col++)
{
Cell cell = _cells[row, col];
CellPartEnum direction = CellPartEnum.CenterRight;
Cell cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
direction = CellPartEnum.CenterLeft;
cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
direction = CellPartEnum.LowerRight;
cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
direction = CellPartEnum.LowerLeft;
cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
direction = CellPartEnum.UpperRight;
cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
direction = CellPartEnum.UpperLeft;
cell2 = GetNextCell(cell, direction);
cell._adjacentCells.Add(direction, cell2);
}
}
}
public Cell GetNextCell(Cell cell, CellPartEnum direction)
{
if (cell == null) return null;
switch (direction)
{
case CellPartEnum.UpperLeft:
{
return GetCell(cell._row - 1, cell._rect.Left);
}
case CellPartEnum.UpperRight:
{
return GetCell(cell._row - 1, cell._rect.Right);
}
case CellPartEnum.CenterLeft:
{
if (cell._col - 1 < 0)
return null;
else
{
return _cells[cell._row, cell._col - 1];
}
}
case CellPartEnum.CenterRight:
{
if (cell._col + 1 >= _colCount)
return null;
else
{
return _cells[cell._row, cell._col + 1];
}
}
case CellPartEnum.LowerRight:
{
return GetCell(cell._row + 1, cell._rect.Right);
}
case CellPartEnum.LowerLeft:
{
return GetCell(cell._row + 1, cell._rect.Left);
}
default:
return null;
}
}
public bool FindPathAdjBest(Cell cellSrc, Cell cellDest,
bool ignoreDestCharacter, bool ignoreObstacle, out ArrayList path)
{
path = null;
ArrayList directions = new ArrayList();
FindDirection(cellSrc.GetCenterPoint(), cellDest.GetCenterPoint(), out directions);
// use fine path
foreach (CellPartEnum direction in directions)
{
ArrayList path3 = new ArrayList();
if (FindPathAdj(cellSrc, cellDest, direction,
ignoreDestCharacter, ignoreObstacle, false,
out path3))
{
if (path == null || path3.Count < path.Count)
{
path = path3;
}
}
}
//// use straight path
//ArrayList path2 = null;
//if (FindPathAdj(cellSrc, cellDest, (CellPartEnum)directions[0],
// ignoreDestCharacter, ignoreObstacle, true,
// out path2))
//{
// if (path == null || path2.Count < path.Count)
// {
// path = path2;
// }
//}
return true;
}
public bool FindPath(Cell cellSrc, Cell cellDest, ArrayList path, CellPartEnum startingDirection,
bool ignoreDestCharacter, bool ignoreObstacle, bool includeSrcCell, bool useStraightAngle)
{
if (includeSrcCell) path.Add(cellSrc);
if (cellSrc.Equals(cellDest))
{
// end
return true;
}
//CellPartEnum direction = FindDirection(cellSrc.GetCenterPoint(), cellDest.GetCenterPoint());
CellPartEnum direction = startingDirection;
Debug.WriteLine("--------------------------------------");
Debug.WriteLine(string.Format("Start to find at {0}", direction));
// detect unless cell
ArrayList deadPath = new ArrayList();
return FindPath_Sub(cellSrc, cellDest, path, direction, deadPath,
ignoreDestCharacter, ignoreObstacle, useStraightAngle);
}
public bool FindPath(Cell cellSrc, Cell cellDest, ArrayList path,
bool ignoreDestCharacter, bool ignoreObstacle)
{
ArrayList directions = null;
FindDirection(cellSrc.GetCenterPoint(), cellDest.GetCenterPoint(), out directions);
return FindPath(cellSrc, cellDest, path, (CellPartEnum)directions[0],
ignoreDestCharacter, ignoreObstacle, false, false);
}
public CellPartEnum FindCellPart(int x, int y, Cell cell)
{
if (y <= cell._rect.Top + Cell.HEIGHT_HEAD)
{
// upper
if (x <= cell._rect.Left + Cell.WIDTH_MIDDLE)
{
// left
return CellPartEnum.UpperLeft;
}
else
{
// right
return CellPartEnum.UpperRight;
}
}
else if (y <= cell._rect.Top + Cell.HEIGHT_HEAD + Cell.HEIGHT_BODY)
{
// center
if (x <= cell._rect.Left + Cell.WIDTH_BODY_LEFT)
{
// left
return CellPartEnum.CenterLeft;
}
else if (x <= cell._rect.Left + Cell.WIDTH_BODY_LEFT + Cell.WIDTH_BODY_CENTER)
{
// center
return CellPartEnum.Center;
}
else
{
// right
return CellPartEnum.CenterRight;
}
}
else
{
// lower
if (x <= cell._rect.Left + Cell.WIDTH_MIDDLE)
{
// left
return CellPartEnum.LowerLeft;
}
else
{
// right
return CellPartEnum.LowerRight;
}
}
}
private Cell GetPathNextCell(Cell cell, Cell cellDest, CellPartEnum direction, ArrayList deadPath)
{
double degree = FindDegree(cell.GetCenterPoint(), cellDest.GetCenterPoint());
switch (direction)
{
case CellPartEnum.CenterRight:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = GetNextCell(cell, direction2);
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
{
//Debug.WriteLine(string.Format("Change direction to {0},{1},{2}", direction2, cellNextTest._row, cellNextTest._col));
return cellNextTest;
}
}
}
break;
case CellPartEnum.CenterLeft:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = GetNextCell(cell, direction2);
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
{
//Debug.WriteLine(string.Format("Change direction to {0},{1},{2}", direction2, cellNextTest._row, cellNextTest._col));
return cellNextTest;
}
}
}
break;
case CellPartEnum.LowerRight:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = GetNextCell(cell, direction2);
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
{
//Debug.WriteLine(string.Format("Change direction to {0},{1},{2}", direction2, cellNextTest._row, cellNextTest._col));
return cellNextTest;
}
}
}
break;
case CellPartEnum.LowerLeft:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = GetNextCell(cell, direction2);
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
{
//Debug.WriteLine(string.Format("Change direction to {0},{1},{2}", direction2, cellNextTest._row, cellNextTest._col));
return cellNextTest;
}
}
}
break;
case CellPartEnum.UpperLeft:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = GetNextCell(cell, direction2);
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
return cellNextTest;
}
}
break;
case CellPartEnum.UpperRight:
{
// get preferred directions
ArrayList directions = GetPathFavourDirections(degree, direction);
foreach (CellPartEnum direction2 in directions)
{
Cell cellNextTest = cell._adjacentCells[direction2];
if (cellNextTest != null && cellNextTest.HasPassability() && !deadPath.Contains(cellNextTest))
{
//Debug.WriteLine(string.Format("Change direction to {0},{1},{2}", direction2, cellNextTest._row, cellNextTest._col));
return cellNextTest;
}
}
}
break;
}
Debug.WriteLine("Change direction but no cell found.");
return null;
}
private void SetDestCell(Heroes.Core.Battle.Armies.Army c, Cell cell)
{
c._cell._character = null;
c._cell = cell;
c._cell._character = c;
}
private int CalDiff(int x, int y, Cell cell)
{
if (y <= cell._rect.Top + Cell.HEIGHT_HEAD)
{
// upper
if (x <= cell._rect.Left + Cell.WIDTH_MIDDLE)
{
// left
return Math.Abs(cell._rect.Left + Cell.WIDTH_MIDDLE - x) + Math.Abs(cell._rect.Top + Cell.HEIGHT_HEAD - y);
//return new Rectangle(cell._rect.Left, cell._rect.Top, 23, 10);
}
else
{
// right
return Math.Abs(cell._rect.Left + Cell.WIDTH_MIDDLE + 1 - x) + Math.Abs(cell._rect.Top + Cell.HEIGHT_HEAD - y);
//return new Rectangle(cell._rect.Left + 24, cell._rect.Top, 22, 10);
}
}
else
{
// lower
if (x <= cell._rect.Left + 23)
{
// left
return Math.Abs(cell._rect.Left + Cell.WIDTH_MIDDLE - x) + Math.Abs(cell._rect.Top + Cell.HEIGHT_HEAD + Cell.HEIGHT_BODY - y);
//return new Rectangle(cell._rect.Left, cell._rect.Top + 42, 23, 10);
}
else
{
// right
return Math.Abs(cell._rect.Left + Cell.WIDTH_MIDDLE + 1 - x) + Math.Abs(cell._rect.Top + Cell.HEIGHT_HEAD + Cell.HEIGHT_BODY - y);
//return new Rectangle(cell._rect.Left + 24, cell._rect.Top + 42, 22, 10);
}
}
}
private bool FindPathAdj(Cell cellSrc, Cell cellDest, CellPartEnum staringDirection,
bool ignoreDestCharacter, bool ignoreObstacle, bool useStraightAngle, out ArrayList path)
{
path = null;
bool hasObstacle = false;
List<ArrayList> shortestPathAvoids = null;
if (!FindPathAdj(cellSrc, cellDest, staringDirection,
ignoreDestCharacter, ignoreObstacle, useStraightAngle,
out shortestPathAvoids, out hasObstacle))
return false;
if (!hasObstacle)
{
if (shortestPathAvoids.Count > 0)
{
path = shortestPathAvoids[0];
// remove srcCell
if (path.Count > 0) path.RemoveAt(0);
}
return true;
}
// find shortest path from srcCell to pathAvoid
foreach (ArrayList shortestPathAvoid in shortestPathAvoids)
{
if (shortestPathAvoid.Count < 1) continue;
int index = 0;
while (index < shortestPathAvoid.Count)
{
Cell cell = (Cell)shortestPathAvoid[index];
List<ArrayList> shortestPathAvoids2 = new List<ArrayList>();
bool hasObstacle2 = false;
if (!FindPathAdj(cellSrc, cell, staringDirection,
false, false, true,
out shortestPathAvoids2, out hasObstacle2))
{
break;
}
else
{
foreach (ArrayList shortestPathAvoid2 in shortestPathAvoids2)
{
if (shortestPathAvoid2.Count - 1 < index)
{
// shorter found
Debug.WriteLine("Shorter found.");
// remove previous
while (!shortestPathAvoid[0].Equals(cell))
{
shortestPathAvoid.RemoveAt(0);
}
// add cell
foreach (Cell cell2 in shortestPathAvoid2)
{
shortestPathAvoid.Insert(0, cell2);
}
}
}
}
index += 1;
}
}
List<ArrayList> shortestPathAvoids3 = null;
FindShortestPathAvoid(shortestPathAvoids, out shortestPathAvoids3);
path = shortestPathAvoids3[0];
// remove srcCell
if (path.Count > 0) path.RemoveAt(0);
return true;
}
public void SetCell(Cell cell)
{
_cell._character = null;
_cell = cell;
_cell._character = this;
Point pt = cell.GetStandingPoint();
this._destAnimationPt = pt;
}
private bool FindPathAdj(Cell cellSrc, Cell cellDest, CellPartEnum startingDirection,
bool ignoreDestCharacter, bool ignoreObstacle, bool useStraightAngle,
out List<ArrayList> shortestPathAvoids, out bool hasObstacle)
{
shortestPathAvoids = new List<ArrayList>();
hasObstacle = false;
// source is destination
if (cellSrc.Equals(cellDest)) return true;
// destination cannot has character or obstacle
if (!cellDest.HasPassability())
{
if (!ignoreDestCharacter && !ignoreObstacle) return false;
}
// find direct path (shortest path)
ArrayList directPath = new ArrayList();
if (!FindPath(cellSrc, cellDest, directPath, startingDirection,
true, true, true, useStraightAngle)) return false;
// find all adjacent cells for obstacle
ArrayList adjCells = new ArrayList();
ArrayList obsCells = new ArrayList();
GetAdjCells(directPath, cellDest, ignoreDestCharacter, adjCells, obsCells);
// if no obstacles
if (obsCells.Count < 1)
{
hasObstacle = false;
shortestPathAvoids.Add(directPath);
return true;
}
else
{
hasObstacle = true;
}
// find new path
List<ArrayList> pathAvoids = null;
FindPathAvoid(directPath, adjCells, obsCells, cellDest, out pathAvoids);
if (pathAvoids.Count < 1) return false;
// get shortest avoid path (might be many)
FindShortestPathAvoid(pathAvoids, out shortestPathAvoids);
if (shortestPathAvoids.Count < 1) return false;
return true;
}
private void SetRangeAttackNAnimate(StandardCharacter attacker, StandardCharacter defender,
CellPartEnum attackDirection, Cell targetCell)
{
// reset defend and wait
Heroes.Core.Battle.Characters.Armies.Army army
= (Heroes.Core.Battle.Characters.Armies.Army)attacker;
army._isWait = false;
army._isDefend = false;
// attack
SetAttackDamage(attacker, defender, true);
attacker._shotRemain -= 1;
// attack Action
{
ArrayList targets = new ArrayList();
targets.Add(defender);
Action action = Action.CreateShootAction(attacker, attackDirection, targets, targetCell);
_actions.Add(action);
}
if (!defender._isDead)
{
// retaliate
//if (defender._canRangeRetaliate && defender._retaliateRemain > 0 && defender._shotRemain > 0)
//{
// SetAttackDamage(defender, attacker, true);
// defender._retaliateRemain -= 1;
// // retaliate action
// {
// CellPartEnum oppAttackDirection = BattleTerrain.GetOppositeDirection(attackDirection);
// ArrayList targets = new ArrayList();
// targets.Add(attacker);
// Action action = Action.CreateShootAction(defender, oppAttackDirection, targets, attacker._cell);
// _actions.Add(action);
// }
//}
// attack more
{
ArrayList targets = new ArrayList();
targets.Add(defender);
for (int i = 1; i < attacker._noOfAttack; i++)
{
SetAttackDamage(attacker, defender, true);
attacker._shotRemain -= 1;
// attack more action
{
Action action = Action.CreateShootAction(attacker, attackDirection, targets, targetCell);
_actions.Add(action);
}
}
}
}
}
private void FindPathAvoid(ArrayList directPath, ArrayList adjCells, ArrayList obsCells, Cell destCell,
out List<ArrayList> pathAvoidLst)
{
pathAvoidLst = new List<ArrayList>();
pathAvoidLst.Add(new ArrayList());
int index = 0;
ArrayList pathAvoid = null;
while (index < pathAvoidLst.Count)
{
pathAvoid = (ArrayList)pathAvoidLst[index];
if (pathAvoid.Count > 0 && pathAvoid[pathAvoid.Count - 1].Equals(destCell))
{
index += 1;
continue;
}
else
{
FindPathAvoid_Sub(directPath, adjCells, obsCells, pathAvoidLst, pathAvoid);
index = 0;
}
}
}
public static Action CreateCastSpellAction(Heroes.Core.Battle.Characters.Hero hero,
Heroes.Core.Battle.Characters.Spells.Spell spell,
CellPartEnum attackDirection,
ArrayList targets, Cell targetCell)
{
Action action = new Action(ActionTypeEnum.Spell);
SubAction subAction = new SubAction();
action._subActions.Add(subAction);
subAction._character = hero;
// hero casting animation
AnimationSequence startCastSpellSeq = subAction.AddStartCasting(attackDirection);
AnimationSequence stopCastSpellSeq = subAction.AddStopCasting(attackDirection);
stopCastSpellSeq._waitToTrigger = true;
// add casting
AnimationSequence spellSeq = null;
AnimationSequence spellHitSeq = null;
AnimationSequence hitSeq = null;
foreach (Heroes.Core.Battle.Characters.ICharacter target in targets)
{
// spell animate
{
SubAction subAction2 = new SubAction();
action._subActions.Add(subAction2);
subAction2._character = spell;
PointF destPoint = spell._destCell.GetStandingPoint();
if (spell._isMissile)
{
// move missile
PointF srcPoint = hero._castingPointRight;
spell._currentAnimationPt = srcPoint;
destPoint.Y -= hero._castingHeight;
Character.CalculateFlySpeed(srcPoint, destPoint,
spell._defaultMoveSpeed,
out spell._moveSpeedX, out spell._moveSpeedY);
spellSeq = subAction2.AddMissileSpell(destPoint, attackDirection, AnimationPurposeEnum.Moving);
subAction2._currentAnimationSeq = spellSeq;
}
else
{
spell._currentAnimationPt = destPoint;
spellSeq = subAction2.AddOnArmySpell(destPoint, attackDirection, AnimationPurposeEnum.CastSpell);
subAction2._currentAnimationSeq = spellSeq;
}
// hit
if (spell._isHit)
{
spellHitSeq = subAction2.AddSpellHit(destPoint, attackDirection);
subAction2._currentAnimationSeq = spellSeq;
}
}
// target
if (spell._isDamage)
{
Heroes.Core.Battle.Characters.Armies.Army army
= (Heroes.Core.Battle.Characters.Armies.Army)target;
SubAction subAction2 = new SubAction();
action._subActions.Add(subAction2);
subAction2._character = target;
if (army._isDead)
hitSeq = subAction2.AddDeath(attackDirection);
else if (army._isDefend)
hitSeq = subAction2.AddDefend(attackDirection);
else
hitSeq = subAction2.AddGettingHit(attackDirection);
hitSeq._waitToTrigger = true;
subAction2._currentAnimationSeq = hitSeq;
}
}
startCastSpellSeq._waitToTrigger = false;
startCastSpellSeq._triggerWhenEnd = true;
startCastSpellSeq._triggerAnimationSeqs.Add(spellSeq);
spellSeq._waitToTrigger = true;
spellSeq._triggerWhenEnd = true;
if (spell._isHit)
{
spellHitSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(spellHitSeq);
}
if (spell._isDamage)
{
hitSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(hitSeq);
}
stopCastSpellSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(stopCastSpellSeq);
subAction._currentAnimationSeq = (AnimationSequence)subAction._animationSeqs[0];
return action;
}
private void GetAdjCells(ArrayList directPath, Cell destCell, bool ignoreDestCharacter,
ArrayList adjCells, ArrayList obstacles)
{
int index = 0;
foreach (Cell cell in directPath)
{
if (cell.Equals(destCell) && ignoreDestCharacter)
{
index += 1;
continue;
}
// index 0 is srcCell
if (index > 0 && !cell.HasPassability())
{
obstacles.Add(cell);
// get all adjacent cells
GetAdjCells(directPath, adjCells, obstacles, cell);
}
index += 1;
}
}