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; }