private void AddImageToInformationScreen(IUnit unit, Tile tile)
{
Hex hex = Game.HexFactory.GetHex(tile);
if (unit != null)
{
Game.HexFactory.AddUnit(hex, unit);
}
this.image.Children.Add(hex);
}
public Tile DetermineRetreatTile(Tile startTile, Tile endTile)
{
Tile retreatTile = null;
Tile tile = null;
List<Tile> adjacentTiles = GetAdjacentTiles(endTile, 1, true);
List<Int32> retreatPaths = new List<int>();
int attackPathNumber = 0;
for (int i = 0; i < adjacentTiles.Count; i++)
{
tile = adjacentTiles[i];
if (tile == startTile)
{
attackPathNumber = i;
}
}
switch (attackPathNumber)
{
case 0:
int[] path0 = new int[] { 3, 2, 4, 1, 5 };
retreatPaths.AddRange(path0);
break;
case 1:
int[] path1 = new int[] { 4, 3, 5, 2, 0 };
retreatPaths.AddRange(path1);
break;
case 2:
int[] path2 = new int[] { 5, 0, 4, 1, 3 };
retreatPaths.AddRange(path2);
break;
case 3:
int[] path3 = new int[] { 0, 1, 5, 2, 4 };
retreatPaths.AddRange(path3);
break;
case 4:
int[] path4 = new int[] { 1, 2, 0, 3, 5 };
retreatPaths.AddRange(path4);
break;
case 5:
int[] path5 = new int[] { 2, 1, 3, 0, 4 };
retreatPaths.AddRange(path5);
break;
}
foreach (Int32 retreatHexNumber in retreatPaths)
{
if (adjacentTiles[retreatHexNumber].GroundUnit == null)
retreatTile = adjacentTiles[retreatHexNumber];
break;
}
return retreatTile;
}
public Tile CreateTile(TerrainTypeEnum terrainTypeEnum)
{
Tile tile = new Tile();
tile.TileId = 0;
tile.ColumnNumber = 0;
tile.RowNumber = 0;
tile.Terrain = Game.TerrainFactory.Terrains.Where(t => t.TerrainTypeEnum == terrainTypeEnum).FirstOrDefault();
tile.Nation = null;
tile.TileName = TileNameFactory.GetTileName(0);
tile.DeployIndicator = false;
tile.SupplyIndicator = false;
tile.VictoryIndicator = false;
return tile;
}
public void AddHexInfo(Tile tile, Hex hex)
{
hex.Dispatcher.BeginInvoke(() =>
{
Canvas canvas = new Canvas();
canvas.Name = "HexInfoCanvas";
TextBlock textBlock = new TextBlock();
textBlock.Name = "HexInfoTextBlock";
textBlock.TextAlignment = TextAlignment.Center;
textBlock.SetValue(Canvas.LeftProperty, (double)(15 * Game.CurrentViewLevel));
textBlock.SetValue(Canvas.TopProperty, (double)5 * Game.CurrentViewLevel);
textBlock.Height = 10 * Game.CurrentViewLevel;
textBlock.Width = 30 * Game.CurrentViewLevel;
textBlock.FontFamily = new FontFamily("Arial");
textBlock.Foreground = new SolidColorBrush(Colors.Black);
textBlock.TextWrapping = TextWrapping.Wrap;
textBlock.Text = String.Format("{0} {1}:{2}", tile.TileName.TileNameDescription, tile.ColumnNumber, tile.RowNumber);
canvas.Children.Add(textBlock);
hex.MainCanvas.Children.Add(canvas);
});
}
void ScenarioTileFactory_ScenarioTilesLoaded(object sender, EventArgs e)
{
Tile tile = null;
List<ScenarioTile> scenarioTiles = Game.ScenarioFactory.ScenarioTileFactory.ScenarioTiles;
foreach (ScenarioTile scenarioTile in scenarioTiles)
{
tile = new Tile();
tile.TileId = scenarioTile.ScenarioTileId;
tile.ColumnNumber = scenarioTile.ColumnNumber;
tile.RowNumber = scenarioTile.RowNumber;
tile.Terrain = Game.TerrainFactory.GetTerrain(scenarioTile.TerrainId);
tile.Nation = Game.NationFactory.GetNation(scenarioTile.NationId);
tile.TileName = TileNameFactory.GetTileName(scenarioTile.TileNameId);
tile.DeployIndicator = scenarioTile.DeployIndicator;
tile.SupplyIndicator = scenarioTile.SupplyIndicator;
tile.VictoryIndicator = scenarioTile.VictoryIndicator;
Tiles.Add(tile);
}
AddUnitsToTile();
TilesLoaded(null, null);
}
private List<Tile> GetLandAttackableTiles(LandCombatUnit landUnit, Tile tile)
{
List<Tile> tiles = new List<Tile>();
switch (landUnit.EquipmentClassEnum)
{
case EquipmentClassEnum.AirDefense:
tiles = GetAdjacentTiles(tile, landUnit.Equipment.Range, true);
tiles.Add(tile);
tiles = tiles.Where(t => t.AirUnit != null).ToList();
tiles = tiles.Where(t => t.AirUnit.SideEnum != landUnit.SideEnum).ToList();
break;
case EquipmentClassEnum.AntiAir:
tiles = GetAdjacentTiles(tile, landUnit.Equipment.Range, true);
tiles.Add(tile);
tiles = tiles.Where(t => t.AirUnit != null).ToList();
tiles = tiles.Where(t => t.AirUnit.SideEnum != landUnit.SideEnum).ToList();
List<Tile> landTiles = new List<Tile>();
landTiles = GetAdjacentTiles(tile, 1, true);
landTiles = tiles.Where(t => t.GroundUnit != null).ToList();
landTiles = tiles.Where(t => t.GroundUnit.SideEnum != landUnit.SideEnum).ToList();
tiles.AddRange(landTiles);
break;
case EquipmentClassEnum.Artillery:
tiles = GetAdjacentTiles(tile, landUnit.Equipment.Range, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != landUnit.SideEnum).ToList();
break;
default:
tiles = GetAdjacentTiles(tile, 1, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != landUnit.SideEnum).ToList();
break;
}
return tiles;
}
private List<Tile> GetAirMoveableTiles(IAirUnit unit, Tile tile)
{
List<Tile> tiles;
int movementPoints = GetMaximumMovementPointsForAUnit(unit);
tiles = GetAdjacentTiles(tile, movementPoints, true);
tiles = RemoveUnitsFromAirReachableTiles(tiles);
return tiles;
}
private List<Tile> CalculateGroundReachableTiles(IGroundUnit unit, Tile startTile, int movementPoints)
{
List<Tile> reachableTiles = new List<Tile>();
List<Tile> tilesForEvaluation = new List<Tile>();
List<Tile> outsideTiles = new List<Tile>();
List<Tile> adjacentTiles = GetAdjacentTiles(startTile, 1, false);
List<Tile> currentTileAdjacentTiles = null;
List<Tile> currentTileOtherUnits = null;
List<Tile> otherUnitAdjactentTiles = null;
//Level 1
foreach (Tile tile in adjacentTiles)
{
if (tile.MovementCost <= movementPoints)
{
tile.Distance = tile.MovementCost;
reachableTiles.Add(tile);
}
if (tile.MovementCost == 99)
{
tile.UnitCanPassThrough = false;
tile.Distance = tile.MovementCost;
reachableTiles.Add(tile);
}
}
//Enemy ZOC
currentTileOtherUnits = adjacentTiles.Where(t => t.GroundUnit != null).ToList();
currentTileOtherUnits = currentTileOtherUnits.Where(t => t.GroundUnit.SideEnum != unit.SideEnum).ToList();
foreach (Tile tile in currentTileOtherUnits)
{
otherUnitAdjactentTiles = GetAdjacentTiles(tile, 1, true);
if (tile.GroundUnit == null)
{
tile.UnitCanPassThrough = false;
}
}
//Level 2-n
for (int i = 1; i < movementPoints; i++)
{
tilesForEvaluation.Clear();
tilesForEvaluation.AddRange(reachableTiles.Where(t => t.Depth == i && t.UnitCanPassThrough));
foreach (Tile tile in tilesForEvaluation)
{
outsideTiles.Clear();
adjacentTiles = GetAdjacentTiles(tile, 1, false);
outsideTiles.AddRange(adjacentTiles.Where(t => t.Depth == i+1));
foreach (Tile currentTile in outsideTiles)
{
int cumulativeMovementCost = tile.Distance;
currentTileAdjacentTiles = GetAdjacentTiles(currentTile, 1, false);
currentTileOtherUnits = currentTileAdjacentTiles.Where(t => t.GroundUnit != null).ToList();
foreach (Tile otherUnitTile in currentTileOtherUnits)
{
if (unit.SideEnum != otherUnitTile.GroundUnit.SideEnum)
{
currentTile.UnitCanPassThrough = false;
}
}
if (!reachableTiles.Contains(currentTile))
{
if (currentTile.MovementCost + cumulativeMovementCost <= movementPoints)
{
currentTile.Distance = tile.MovementCost + cumulativeMovementCost;
reachableTiles.Add(currentTile);
}
}
}
}
}
return reachableTiles;
}
public void SetMovableTiles(IUnit unit, Tile tile)
{
if (unit is IAirUnit)
{
IAirUnit airUnit = (IAirUnit)unit;
unit.MoveableTiles = GetAirMoveableTiles(airUnit, tile);
}
else if (unit is ISeaUnit)
{
ISeaUnit seaUnit = (ISeaUnit)unit;
unit.MoveableTiles = GetSeaMoveableTiles(seaUnit, tile);
}
else if (unit is ILandUnit)
{
ILandUnit landUnit = (ILandUnit)unit;
unit.MoveableTiles = GetLandMoveableTiles(landUnit, tile);
}
}
private TargetAndJumpOffTile DetermineSeaAttackJumpOffTile(SeaCombatUnit seaCombatUnit, Tile currentTile)
{
List<Tile> adjacentTiles = null;
List<TargetAndJumpOffTile> targetAndJumpOffTiles = new List<TargetAndJumpOffTile>();
TargetAndJumpOffTile targetAndJumpOffTile = null;
foreach (Tile tile in seaCombatUnit.MoveableTiles)
{
Game.TileFactory.SetAttackableTiles(seaCombatUnit, tile);
adjacentTiles = seaCombatUnit.AttackableTiles;
adjacentTiles = adjacentTiles.Where(t => t.GroundUnit != null).ToList();
adjacentTiles = adjacentTiles.Where(t => t.GroundUnit.SideEnum == SideEnum.Axis).ToList();
foreach (Tile potentialTargetTile in adjacentTiles)
{
targetAndJumpOffTile = new TargetAndJumpOffTile();
targetAndJumpOffTile.TargetTile = potentialTargetTile;
targetAndJumpOffTile.JumpOffTile = tile;
targetAndJumpOffTiles.Add(targetAndJumpOffTile);
}
}
return DetermineTarget(targetAndJumpOffTiles, TargetTypeEnum.SoftGround);
}
private static void MoveLandCombatUnit(LandCombatUnit landCombatUnit, Tile currentTile)
{
Tile targetTile = null;
TargetAndJumpOffTile targetAndJumpOffTile = null;
targetTile = DetermineCaptureTile(landCombatUnit);
if (targetTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = landCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(landCombatUnit, currentTile, targetTile);
return;
}
targetAndJumpOffTile = DetermineLandAttackJumpOffTile(landCombatUnit, currentTile);
if (landCombatUnit.CanAttack && targetAndJumpOffTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = landCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(landCombatUnit, currentTile, targetAndJumpOffTile.JumpOffTile);
Game.BoardFactory.ActiveTile = targetAndJumpOffTile.JumpOffTile;
if (landCombatUnit.CanAttack)
{
Game.BoardFactory.CalculateBattleForComputerPlayer(targetAndJumpOffTile.TargetTile);
}
return;
}
targetTile = DetermineLandWithdrawlTile(landCombatUnit);
if(targetTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = landCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(landCombatUnit, currentTile, targetTile);
return;
}
}
private static void MoveAirCombatUnit(AirCombatUnit airCombatUnit, Tile currentTile)
{
Tile targetTile = null;
TargetAndJumpOffTile targetAndJumpOffTile = null;
targetAndJumpOffTile = DetermineAirAttackJumpOffTile(airCombatUnit, currentTile);
if (airCombatUnit.CanAttack && targetAndJumpOffTile != null && airCombatUnit.CurrentFuel >= airCombatUnit.Equipment.MaxFuel*.5)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = airCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(airCombatUnit, currentTile, targetAndJumpOffTile.JumpOffTile);
Game.BoardFactory.ActiveTile = targetAndJumpOffTile.JumpOffTile;
Game.BoardFactory.CalculateBattleForComputerPlayer(targetAndJumpOffTile.TargetTile);
return;
}
targetTile = DetermineAirWithdrawlTile(airCombatUnit);
if (targetTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = airCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(airCombatUnit, currentTile, targetTile);
return;
}
}
private static TargetAndJumpOffTile DetermineLandAttackJumpOffTile(LandCombatUnit landCombatUnit, Tile currentTile)
{
List<Tile> adjacentTiles = null;
List<TargetAndJumpOffTile> targetAndJumpOffTiles = new List<TargetAndJumpOffTile>();
TargetAndJumpOffTile targetAndJumpOffTile = null;
foreach (Tile tile in landCombatUnit.MoveableTiles)
{
adjacentTiles = Game.TileFactory.GetAdjacentTiles(tile, 1, false);
adjacentTiles = adjacentTiles.Where(t => t.GroundUnit != null).ToList();
adjacentTiles = adjacentTiles.Where(t => t.GroundUnit.SideEnum == SideEnum.Axis).ToList();
foreach (Tile potentialTargetTile in adjacentTiles)
{
targetAndJumpOffTile = new TargetAndJumpOffTile();
targetAndJumpOffTile.TargetTile = potentialTargetTile;
targetAndJumpOffTile.JumpOffTile = tile;
targetAndJumpOffTiles.Add(targetAndJumpOffTile);
}
}
return DetermineTarget(targetAndJumpOffTiles, TargetTypeEnum.SoftGround);
}
private void DisplayUnitInformation(IUnit unit, Tile tile)
{
Game.CurrentViewLevel = 3;
this.title.Text = unit.UnitName;
this.subtitle.Text = String.Format("{0} - {1} Target", unit.EquipmentSubClassEnum.ToString(), unit.TargetTypeEnum.ToString());
AddImageToInformationScreen(unit, tile);
if (unit is LandCombatUnit)
{
DisplayLandCombatUnitInformation();
}
if (unit is AirCombatUnit)
{
DisplayAirCombatUnitInformation();
}
if (unit is SeaCombatUnit)
{
DisplaySeaCombatUnitInformation();
}
if (unit is ITransportUnit)
{
DisplayTranportUnitInformation();
}
this.UpgradeButton.Visibility = System.Windows.Visibility.Collapsed;
this.RetireButton.Visibility = System.Windows.Visibility.Collapsed;
}
private void DisplayTileInformation(Tile tile)
{
Game.CurrentViewLevel = 3;
this.title.Text = tile.TileName.TileNameDescription;
this.subtitle.Text = String.Format("{0} - {1}", tile.Terrain.TerrainTypeEnum, Game.BoardFactory.ActiveTile.Terrain.TerrainGroupEnum);
AddImageToInformationScreen(null,tile);
SetTextBlock("Victory Indicator", tile.VictoryIndicator.ToString());
SetTextBlock("Supply Indicator", tile.SupplyIndicator.ToString());
if (tile.Nation != null)
{
SetTextBlock("Nation", tile.Nation.NationEnum.ToString());
}
this.UpgradeButton.Visibility = System.Windows.Visibility.Collapsed;
this.RetireButton.Visibility = System.Windows.Visibility.Collapsed;
}
public List<Tile> GetAdjacentTiles(Tile startTile, Int32 maxDepth, bool calculateDepth)
{
List<Tile> tiles = new List<Tile>();
int startingColumn = startTile.ColumnNumber - maxDepth;
int endingColumn = startTile.ColumnNumber + maxDepth;
AdjustColumnsForGridSize(ref startingColumn, ref endingColumn);
int startingRow = startTile.RowNumber - maxDepth;
int endingRow = startTile.RowNumber + maxDepth;
AdjustRowsForGridSize(ref startingRow, ref endingRow);
Tile tile = null;
int depth = 0;
for (int i = startingColumn; i <= endingColumn; i++)
{
for (int j = startingRow; j <= endingRow; j++)
{
tile = GetTile(i, j);
if (!tiles.Contains(tile))
{
depth = GetDepthBetweenTwoTiles(startTile, tile);
if (depth <= maxDepth)
{
if (calculateDepth)
{
tile.Depth = depth;
}
tiles.Add(tile);
}
}
}
}
tiles.Remove(startTile);
return tiles;
}
public void SetAttackableTiles(ICombatUnit unit, Tile tile)
{
if (unit is AirCombatUnit)
{
AirCombatUnit airUnit = (AirCombatUnit)unit;
unit.AttackableTiles = GetAirAttackableTiles(airUnit, tile);
}
else if (unit is SeaCombatUnit)
{
SeaCombatUnit seaUnit = (SeaCombatUnit)unit;
unit.AttackableTiles = GetSeaAttackableTiles(seaUnit, tile);
}
else if (unit is LandCombatUnit)
{
LandCombatUnit landUnit = (LandCombatUnit)unit;
unit.AttackableTiles = GetLandAttackableTiles(landUnit, tile);
}
}
private void MoveSeaCombatUnit(SeaCombatUnit seaCombatUnit, Tile currentTile)
{
Tile targetTile = null;
TargetAndJumpOffTile targetAndJumpOffTile = null;
targetAndJumpOffTile = DetermineSeaAttackJumpOffTile(seaCombatUnit, currentTile);
if (seaCombatUnit.CanAttack && targetAndJumpOffTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = seaCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(seaCombatUnit, currentTile, targetAndJumpOffTile.JumpOffTile);
Game.BoardFactory.ActiveTile = targetAndJumpOffTile.JumpOffTile;
if (seaCombatUnit.CanAttack)
{
Game.BoardFactory.CalculateBattleForComputerPlayer(targetAndJumpOffTile.TargetTile);
}
return;
}
targetTile = DetermineSeaWithdrawlTile(seaCombatUnit);
if (targetTile != null)
{
Game.BoardFactory.ActiveTile = currentTile;
Game.BoardFactory.ActiveUnit = seaCombatUnit;
Game.BoardFactory.MoveUnitForComputerPlayer(seaCombatUnit, currentTile, targetTile);
return;
}
}
public void SetVisibleTiles(IUnit unit, Tile tile)
{
unit.VisibleTiles = GetAdjacentTiles(tile, unit.Equipment.Spotting, true);
}
private static TargetAndJumpOffTile DetermineAirAttackJumpOffTile(AirCombatUnit airCombatUnit, Tile currentTile)
{
List<Tile> adjacentTiles = null;
List<TargetAndJumpOffTile> targetAndJumpOffTiles = new List<TargetAndJumpOffTile>();
TargetAndJumpOffTile targetAndJumpOffTile = null;
if (airCombatUnit.EquipmentClassEnum == EquipmentClassEnum.Fighter)
{
foreach (Tile tile in airCombatUnit.MoveableTiles)
{
adjacentTiles = Game.TileFactory.GetAdjacentTiles(tile, 1, false);
adjacentTiles = adjacentTiles.Where(t => t.AirUnit != null).ToList();
adjacentTiles = adjacentTiles.Where(t => t.AirUnit.SideEnum == SideEnum.Axis).ToList();
foreach (Tile potentialTargetTile in adjacentTiles)
{
targetAndJumpOffTile = new TargetAndJumpOffTile();
targetAndJumpOffTile.TargetTile = potentialTargetTile;
targetAndJumpOffTile.JumpOffTile = tile;
targetAndJumpOffTiles.Add(targetAndJumpOffTile);
}
}
return DetermineTarget(targetAndJumpOffTiles, TargetTypeEnum.Air);
}
else if(airCombatUnit.EquipmentClassEnum == EquipmentClassEnum.TacticalBomber)
{
foreach (Tile tile in airCombatUnit.MoveableTiles)
{
if (tile.GroundUnit != null)
{
if (tile.GroundUnit.SideEnum == SideEnum.Axis)
{
targetAndJumpOffTile = new TargetAndJumpOffTile();
targetAndJumpOffTile.TargetTile = tile;
targetAndJumpOffTile.JumpOffTile = tile;
targetAndJumpOffTiles.Add(targetAndJumpOffTile);
}
}
}
}
else if (airCombatUnit.EquipmentClassEnum == EquipmentClassEnum.StrategicBomber)
{
foreach (Tile tile in airCombatUnit.MoveableTiles)
{
if (tile.Nation.SideEnum == SideEnum.Axis && tile.VictoryIndicator == true)
{
targetAndJumpOffTile = new TargetAndJumpOffTile();
targetAndJumpOffTile.TargetTile = tile;
targetAndJumpOffTile.JumpOffTile = tile;
targetAndJumpOffTiles.Add(targetAndJumpOffTile);
}
}
}
return null;
}
private List<Tile> GetAirAttackableTiles(AirCombatUnit airUnit, Tile tile)
{
List<Tile> tiles = new List<Tile>();
switch(airUnit.EquipmentClassEnum)
{
case EquipmentClassEnum.Fighter:
//Air Target
tiles = GetAdjacentTiles(tile, 1, true);
tiles = tiles.Where(t => t.AirUnit != null).ToList();
tiles = tiles.Where(t => t.AirUnit.SideEnum != airUnit.SideEnum).ToList();
//Ground Target
if (tile.GroundUnit != null)
{
if (tile.GroundUnit.SideEnum != airUnit.SideEnum)
{
tiles.Add(tile);
}
}
break;
case EquipmentClassEnum.TacticalBomber:
//Air Target
tiles = GetAdjacentTiles(tile, 1, true);
tiles = tiles.Where(t => t.AirUnit != null).ToList();
tiles = tiles.Where(t => t.AirUnit.SideEnum != airUnit.SideEnum).ToList();
//Ground Target
if (tile.GroundUnit != null)
{
if (tile.GroundUnit.SideEnum != airUnit.SideEnum)
{
tiles.Add(tile);
}
}
break;
case EquipmentClassEnum.StrategicBomber:
//Ground Target
if (tile.GroundUnit != null)
{
if (tile.GroundUnit.SideEnum != airUnit.SideEnum)
{
tiles.Add(tile);
}
}
//Victory Tile Target
if (tile.VictoryIndicator == true)
{
if (tile.Nation.SideEnum != airUnit.Nation.SideEnum)
{
tiles.Add(tile);
}
}
break;
}
return tiles;
}
private Int32 CalculateAttackGrade(IUnit attackingUnit, IUnit defendingUnit, Tile defendingTile)
{
int attackerAttackGrade = 0;
switch (defendingUnit.TargetTypeEnum)
{
case TargetTypeEnum.SoftGround:
attackerAttackGrade = attackingUnit.Equipment.SoftAttack;
break;
case TargetTypeEnum.HardGround:
attackerAttackGrade = attackingUnit.Equipment.HardAttack;
break;
case TargetTypeEnum.Air:
attackerAttackGrade = attackingUnit.Equipment.AirAttack;
break;
case TargetTypeEnum.Sea:
attackerAttackGrade = attackingUnit.Equipment.NavalAttack;
break;
}
attackerAttackGrade += attackingUnit.CurrentNumberOfStars;
if (defendingTile.Terrain.RiverInd == true)
{
attackerAttackGrade += 4;
}
if (attackingUnit is IMotorizedUnit)
{
IMotorizedUnit motorizedUnit = (IMotorizedUnit)attackingUnit;
if (motorizedUnit.CurrentFuel == 0)
{
attackerAttackGrade = attackerAttackGrade / 2;
}
}
return attackerAttackGrade;
}
private int GetDepthBetweenTwoTiles(Tile startTile, Tile endTile)
{
int startColumnNumber = startTile.ColumnNumber;
int endColumnNumber = endTile.ColumnNumber;
int startRowNumber = startTile.RowNumber;
int endRowNumber = endTile.RowNumber;
startRowNumber = AdjustRowNumberForDiagnalGrid(startColumnNumber, startRowNumber);
endRowNumber = AdjustRowNumberForDiagnalGrid(endColumnNumber, endRowNumber);
return CalculateDepthBetweenTwoTiles(startColumnNumber, endColumnNumber, startRowNumber, endRowNumber);
}
private Int32 CalculateDefenseGrade(IUnit attackingUnit, IUnit defendingUnit,
Tile attackingTile, Tile defendingTile, TerrainCondition terrainCondition)
{
int defenderDefenseGrade = 0;
if (attackingUnit is IAirUnit)
{
defenderDefenseGrade = defendingUnit.Equipment.AirDefense;
}
else
{
defenderDefenseGrade = defendingUnit.Equipment.GroundDefense;
}
defenderDefenseGrade += defendingUnit.CurrentNumberOfStars;
if (attackingTile.Terrain.RiverInd == true)
{
defenderDefenseGrade += 4;
}
if (CalculateRuggedDefense(attackingUnit, defendingUnit))
{
defenderDefenseGrade += 4;
}
defenderDefenseGrade = DetermineDefenseGradeEntrenchment(attackingUnit, defendingUnit, defenderDefenseGrade);
defenderDefenseGrade = DetermineDefenseGradeOverrides(attackingUnit, defendingUnit, terrainCondition, defenderDefenseGrade);
return defenderDefenseGrade;
}
private List<Tile> GetSeaAttackableTiles(SeaCombatUnit seaUnit, Tile tile)
{
List<Tile> tiles = new List<Tile>();
switch(seaUnit.EquipmentClassEnum)
{
case EquipmentClassEnum.Submarine:
tiles = GetAdjacentTiles(tile, 1, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != seaUnit.SideEnum).ToList();
tiles = tiles.Where(t => t.Terrain.TerrainGroupEnum != TerrainGroupEnum.Land).ToList();
tiles = tiles.Where(t => t.GroundUnit.EquipmentClassEnum != EquipmentClassEnum.Submarine).ToList();
break;
case EquipmentClassEnum.Destroyer:
tiles = GetAdjacentTiles(tile, 1, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != seaUnit.SideEnum).ToList();
tiles = tiles.Where(t => t.Terrain.TerrainGroupEnum != TerrainGroupEnum.Land).ToList();
break;
case EquipmentClassEnum.CapitalShip:
tiles = GetAdjacentTiles(tile, seaUnit.Equipment.Range, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != seaUnit.SideEnum).ToList();
tiles = tiles.Where(t => t.GroundUnit.EquipmentClassEnum != EquipmentClassEnum.Submarine).ToList();
break;
}
return tiles;
}
private InitativeEnum CalculateInitiative(IUnit attackingUnit, IUnit defendingUnit, Tile battlefield, bool surprised)
{
TerrainType terrainType = battlefield.Terrain.TerrainType;
int attackingInitiative = DetermineInitativeCaps(attackingUnit.Equipment.Initative, terrainType.InitiativeCap);
int defendingInitiative = DetermineInitativeCaps(defendingUnit.Equipment.Initative, terrainType.InitiativeCap);
int attackingExperienceBonus = CalculateExperienceBonusForInitiative(attackingUnit.CurrentNumberOfStars);
int defendingExperienceBonus = CalculateExperienceBonusForInitiative(defendingUnit.CurrentNumberOfStars);
attackingInitiative = attackingInitiative + attackingExperienceBonus;
defendingInitiative = defendingInitiative + defendingExperienceBonus;
attackingInitiative = DetermineAttackingInitativeOverrides(attackingUnit, defendingUnit, attackingInitiative, defendingInitiative);
defendingInitiative = DetermineDefendingInitativeOverrides(attackingUnit, defendingUnit, attackingInitiative, defendingInitiative);
if (surprised)
attackingInitiative = 0;
Random random = new Random();
attackingInitiative = attackingInitiative + random.Next(3);
defendingInitiative = defendingInitiative + random.Next(3);
if (attackingInitiative > defendingInitiative)
return InitativeEnum.AttackerStrikesFirst;
else if (defendingInitiative > attackingInitiative)
return InitativeEnum.DefenderStrikesFirst;
else
return InitativeEnum.Simultanous;
}
private List<Tile> GetSeaMoveableTiles(ISeaUnit unit, Tile tile)
{
List<Tile> tiles;
int movementPoints = GetMaximumMovementPointsForAUnit(unit);
tiles = GetAdjacentTiles(tile, movementPoints, true);
tiles = AddMovementPointsToTiles(tiles, unit);
tiles = CalculateGroundReachableTiles(unit, tile, movementPoints);
tiles = RemoveUnitsFromLandReachableTiles(tiles);
return tiles;
}
private Volley CalculateVolley(IUnit attackingUnit, IUnit defendingUnit,
Tile attackingTile, Tile defendingTile, TerrainCondition terrainCondition)
{
Volley volley = new Volley();
volley.AttackerUnit = attackingUnit;
volley.AttackerTile = attackingTile;
volley.DefenderUnit = defendingUnit;
volley.DefenderTile = defendingTile;
int attackerAttackGrade = 0;
int defenderDefenseGrade = 0;
int netAttackGrade = 0;
int attackingUnitStartingStrength = attackingUnit.CurrentStrength;
int defendingUnitStartingStrength = defendingUnit.CurrentStrength;
attackerAttackGrade = CalculateAttackGrade(attackingUnit, defendingUnit, defendingTile);
defenderDefenseGrade = CalculateDefenseGrade(attackingUnit, defendingUnit,
attackingTile, defendingTile, terrainCondition);
netAttackGrade = attackerAttackGrade - defenderDefenseGrade;
SetVolleyResults(attackingUnit, defendingUnit, netAttackGrade);
int attackingUnitStrengthLoss = attackingUnitStartingStrength - attackingUnit.CurrentStrength;
int defendingUnitStrengthLoss = defendingUnitStartingStrength - defendingUnit.CurrentStrength;
if (attackingUnit is ICombatUnit)
{
ICombatUnit combatUnit = (ICombatUnit)attackingUnit;
combatUnit.CurrentAmmo += -1;
}
if (defendingUnit is ICombatUnit)
{
ICombatUnit combatUnit = (ICombatUnit)defendingUnit;
combatUnit.CurrentAmmo += -1;
}
if (attackingUnitStrengthLoss > 0 && defendingUnitStrengthLoss > 0)
{
volley.VollyOutcomeEnum= VolleyOutcomeEnum.AttackerHurt_DefenderHurt;
}
else if (attackingUnitStrengthLoss > 0 && defendingUnitStrengthLoss == 0)
{
volley.VollyOutcomeEnum = VolleyOutcomeEnum.AttackerHurt_DefenderUnhurt;
}
else if (attackingUnitStrengthLoss == 0 && defendingUnitStrengthLoss > 0)
{
volley.VollyOutcomeEnum = VolleyOutcomeEnum.AttackerUnhurt_DefenderHurt;
}
else
{
volley.VollyOutcomeEnum = VolleyOutcomeEnum.AttackerUnhurt_DefenderUnhurt;
}
return volley;
}
private IUnit DetermineSupportingVolleyUnit(IUnit aggressorUnit, Tile protectingTile)
{
List<Tile> tiles = null;
TileFactory tileFactory = Game.TileFactory;
if (aggressorUnit is IAirUnit)
{
tiles = tileFactory.GetAdjacentTiles(protectingTile, 1, true);
tiles = tiles.Where(t => t.AirUnit != null).ToList();
tiles = tiles.Where(t => t.AirUnit.EquipmentClassEnum == EquipmentClassEnum.Fighter).ToList();
tiles = tiles.Where(t => t.AirUnit.SideEnum != aggressorUnit.SideEnum).ToList();
if (tiles.Count > 0)
{
return tiles[0].AirUnit;
}
tiles = tileFactory.GetAdjacentTiles(protectingTile, 1, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.EquipmentClassEnum == EquipmentClassEnum.AirDefense).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != aggressorUnit.SideEnum).ToList();
if (tiles.Count > 0)
{
return tiles[0].GroundUnit;
}
}
else if (aggressorUnit is ILandUnit)
{
tiles = tileFactory.GetAdjacentTiles(protectingTile, 1, true);
tiles = tiles.Where(t => t.GroundUnit != null).ToList();
tiles = tiles.Where(t => t.GroundUnit.EquipmentClassEnum == EquipmentClassEnum.Artillery).ToList();
tiles = tiles.Where(t => t.GroundUnit.SideEnum != aggressorUnit.SideEnum).ToList();
if (tiles.Count > 0)
{
return tiles[0].GroundUnit;
}
}
return null;
}
public Hex GetHex(Tile tile)
{
Hex hex = new Hex();
AddTerrain(tile, hex);
return hex;
}
