/// <summary>
/// Returns a list of enemy units adjacent to the hex passed
/// </summary>
/// <param name="hex"></param>
/// <param name="defendingNationality"></param>
/// <returns></returns>
public List <GameObject> ReturnAdjacentEnemyUnits(GameObject hex, GlobalDefinitions.Nationality enemyNationality)
{
//GlobalDefinitions.writeToLogFile("returnAdjacentEnemyUnits: hex = " + hex.name);
List <GameObject> returnList = new List <GameObject>();
if (hex != null)
{
foreach (HexDefinitions.HexSides hexSides in Enum.GetValues(typeof(HexDefinitions.HexSides)))
{
if ((hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides] != null) &&
(hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().occupyingUnit.Count > 0) &&
(hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().occupyingUnit[0].GetComponent <UnitDatabaseFields>().nationality == enemyNationality))
{
// Need to check if an enemy is on an adjacent sea hex or that it is invading the hex selected
if ((hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().sea == false) ||
((hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().sea == true) &&
(hex == hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().invasionTarget)))
{
foreach (GameObject unit in hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().occupyingUnit)
{
returnList.Add(unit);
}
}
}
}
}
return(returnList);
}
/// <summary>
/// This routine selects the unit to be setup
/// </summary>
public GameObject GetUnitToSetup(GlobalDefinitions.Nationality nationality, GameObject selectedUnit)
{
if ((selectedUnit != null) && (selectedUnit.GetComponent <UnitDatabaseFields>().nationality == nationality))
{
// Change the color of the unit to yellow
GlobalDefinitions.HighlightUnit(selectedUnit);
}
else
{
selectedUnit = null;
}
return(selectedUnit);
}
/// <summary>
/// Highlights any units that must be attacked this turn. Returns true if it finds units
/// The shouldHighlight flag is needed because if being called by the AI units shouldn't be highlighted
/// </summary>
/// <param name="attackingNationality"></param>
/// <param name="hex"></param>
/// <param name="shouldHighlight"></param>
private static bool HighlightUnitsThatMustBeAttacked(GlobalDefinitions.Nationality attackingNationality, GameObject hex, bool shouldHighlight)
{
bool foundUnit = false;
foreach (HexDefinitions.HexSides hexSide in Enum.GetValues(typeof(HexDefinitions.HexSides)))
{
if ((hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide] != null) &&
(hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <BooleanArrayData>().exertsZOC[GlobalDefinitions.ReturnHexSideOpposide((int)hexSide)] == true) &&
(hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit.Count > 0) &&
(hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit[0].GetComponent <UnitDatabaseFields>().nationality != attackingNationality))
{
foreach (GameObject unit in hex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit)
{
if (!unit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack)
{
foundUnit = true;
if (shouldHighlight)
{
GlobalDefinitions.HighlightUnit(unit);
}
}
}
}
}
// Need to do a special case check here for being on a sea hex, the invasion target will be a mustBeAttacked even if it is a fortress
if (hex.GetComponent <HexDatabaseFields>().sea&& hex.GetComponent <HexDatabaseFields>().invasionTarget.GetComponent <HexDatabaseFields>().fortress)
{
// Any units in a fortress that has units attacking from the sea will should be attacked
foreach (GameObject unit in hex.GetComponent <HexDatabaseFields>().invasionTarget.GetComponent <HexDatabaseFields>().occupyingUnit)
{
if (!unit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack)
{
foundUnit = true;
if (shouldHighlight)
{
GlobalDefinitions.HighlightUnit(unit);
}
}
}
}
return(foundUnit);
}
/// <summary>
/// This routine pulls all the defenders and attackers based on the hex passed and then calls the combat selection GUI
/// </summary>
/// <param name="defendingNationality"></param>
public void PrepForCombatDisplay(GameObject hex, GlobalDefinitions.Nationality defendingNationality)
{
// First thing we need to do is check that the combat assignment gui isn't already active. If it is do not load anoether one.
if (GameObject.Find("CombatGUIInstance") != null)
{
GlobalDefinitions.GuiUpdateStatusMessage("Resolve current combat assignment before assigning another");
return;
}
GameObject singleCombat = new GameObject("prepForCombatDisplay");
singleCombat.AddComponent <Combat>();
// Check if the hex has uncommittted units of the right nationality on it and there are adjacent enemies
if ((hex != null) &&
(hex.GetComponent <HexDatabaseFields>().occupyingUnit.Count > 0) &&
(hex.GetComponent <HexDatabaseFields>().occupyingUnit[0].GetComponent <UnitDatabaseFields>().nationality == defendingNationality) &&
NonCommittedDefendersAvailable(hex) &&
(ReturnUncommittedUnits(ReturnAdjacentEnemyUnits(hex, GlobalDefinitions.ReturnOppositeNationality(defendingNationality))).Count > 0))
{
// Get all the available defending units
singleCombat.GetComponent <Combat>().defendingUnits = ReturnUncommittedUnits(hex.GetComponent <HexDatabaseFields>().occupyingUnit);
singleCombat.GetComponent <Combat>().attackingUnits = ReturnUncommittedUnits(ReturnAdjacentEnemyUnits(hex, GlobalDefinitions.ReturnOppositeNationality(defendingNationality)));
// Fianlly we have to get all potential defenders that are adjacent to the attackers
foreach (GameObject defender in ReturnUncommittedUnits(ReturnAdjacentDefenders(hex, singleCombat)))
{
if (!singleCombat.GetComponent <Combat>().defendingUnits.Contains(defender))
{
singleCombat.GetComponent <Combat>().defendingUnits.Add(defender);
}
}
CallCombatDisplay(singleCombat);
}
else
{
if (hex == null)
{
GlobalDefinitions.GuiUpdateStatusMessage("No valid hex selected for combat; hex selected must contain enemy units");
}
else if (hex.GetComponent <HexDatabaseFields>().occupyingUnit.Count == 0)
{
GlobalDefinitions.GuiUpdateStatusMessage("No units found on hex selected for combat; hex selected must contain enemy units");
}
else if (!NonCommittedDefendersAvailable(hex))
{
GlobalDefinitions.GuiUpdateStatusMessage("No uncommitted defenders found on hex selected; all units on hex are already assigned to combat. Cancel attacks and reassign combat to add additional attacking units.");
}
else if (ReturnUncommittedUnits(ReturnAdjacentEnemyUnits(hex, GlobalDefinitions.ReturnOppositeNationality(defendingNationality))).Count == 0)
{
GlobalDefinitions.GuiUpdateStatusMessage("No units are available to attack the hex selected");
}
//else if (hex.GetComponent<HexDatabaseFields>().occupyingUnit[0].GetComponent<UnitDatabaseFields>().nationality != defendingNationality)
else
{
GlobalDefinitions.GuiDisplayUnitsOnHex(hex);
}
if ((GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.name == "alliedMovementStateInstance") ||
(GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.name == "germanMovementStateInstance"))
{
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod =
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.GetComponent <MovementState>().ExecuteSelectUnit;
}
else if (GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.name == "alliedInvasionStateInstance")
{
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod =
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.GetComponent <AlliedInvasionState>().ExecuteSelectUnit;
}
else if (GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.name == "alliedAirborneStateInstance")
{
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod =
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.GetComponent <AlliedAirborneState>().ExecuteSelectUnit;
}
else
{
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod =
GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.GetComponent <CombatState>().ExecuteSelectUnit;
}
}
}
/// <summary>
/// Returns true if there are units that should be invovled in combat but aren't committed to an attack
/// Will highlight all units that are uncommitted but should be involved in an attack if the shouldHighlight flag is true
/// </summary>
/// <param name="attackingNationality"></param>
/// <param name="shouldHighlight"></param>
public static bool CheckIfRequiredUnitsAreUncommitted(GlobalDefinitions.Nationality attackingNationality, bool shouldHighlight)
{
//GlobalDefinitions.writeToLogFile("checkIfRequiredUnitsAreUncommitted: executing");
bool unitFound = false;
List <GameObject> attackingUnits;
// I'm going to turn off all unit highlighting here. It will be added back on when the gui is dismissed if needed
GlobalDefinitions.UnhighlightAllUnits();
if (attackingNationality == GlobalDefinitions.Nationality.German)
{
attackingUnits = GlobalDefinitions.germanUnitsOnBoard;
}
else
{
attackingUnits = GlobalDefinitions.alliedUnitsOnBoard;
}
foreach (GameObject unit in attackingUnits)
{
if (unit.GetComponent <UnitDatabaseFields>().nationality == GlobalDefinitions.Nationality.Allied)
{
// Add the clause below to check for a unit on a sea hex. This comes into play when a fortress is being attacked from
// the sea since it isn't in a ZOC.
if (unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().inGermanZOC ||
unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().sea)
{
// This is an allied unit that must perform an attack this turn
if (!unit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack)
{
unitFound = true;
if (shouldHighlight)
{
GlobalDefinitions.HighlightUnit(unit);
}
}
// Get the German units that exert ZOC to this unit
if (HighlightUnitsThatMustBeAttacked(GlobalDefinitions.Nationality.Allied, unit.GetComponent <UnitDatabaseFields>().occupiedHex, shouldHighlight))
{
unitFound = true;
}
}
}
else
{
if (unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().inAlliedZOC)
{
// This is a German unit that must perform an attack this turn
if (!unit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack)
{
unitFound = true;
if (shouldHighlight)
{
GlobalDefinitions.HighlightUnit(unit);
}
}
// Get the Allied units that exert ZOC to this unit
if (HighlightUnitsThatMustBeAttacked(GlobalDefinitions.Nationality.German, unit.GetComponent <UnitDatabaseFields>().occupiedHex, shouldHighlight))
{
unitFound = true;
}
}
}
}
// Need to check all existing attacks and see if they are cross river and bring in additional defenders that aren't being attacked
foreach (GameObject combat in GlobalDefinitions.allCombats)
{
if (CheckIfDefenderToBeAddedDueToCrossRiverAttack(combat.GetComponent <Combat>().attackingUnits, combat.GetComponent <Combat>().defendingUnits, shouldHighlight))
{
unitFound = true;
}
}
return(unitFound);
}
/// <summary>
/// Creates the state instances and sets up the state transitions for AI games
/// </summary>
/// <param name="nationalityBeingPlayed"></param>
public static void CreateStatesForAI(GlobalDefinitions.Nationality nationalityBeingPlayed)
{
GlobalDefinitions.WriteToLogFile("createStatesForAI: executing");
// The AI is playing the German side
if (nationalityBeingPlayed == GlobalDefinitions.Nationality.Allied)
{
setUpStateInstance = new GameObject("setUpStateInstance");
germanAIStateInstance = new GameObject("GermanAIStateInstance");
turnInitializationStateInstance = new GameObject("turnInitializationStateInstance");
alliedReplacementStateInstance = new GameObject("alliedReplacementStateInstance");
alliedSupplyStateInstance = new GameObject("alliedSupplyStateInstance");
alliedInvasionStateInstance = new GameObject("alliedInvasionStateInstance");
alliedAirborneStateInstance = new GameObject("alliedAirborneStateInstance");
alliedMovementStateInstance = new GameObject("alliedMovementStateInstance");
alliedCombatStateInstance = new GameObject("alliedCombatStateInstance");
alliedTacticalAirStateInstance = new GameObject("alliedTacticalAirStateInstance");
germanAISetupStateInstance = new GameObject("germanAIStateSetupInstance");
setUpStateInstance.AddComponent <SetUpState>();
germanAISetupStateInstance.AddComponent <GermanAISetupState>();
turnInitializationStateInstance.AddComponent <TurnInitializationState>();
alliedReplacementStateInstance.AddComponent <AlliedReplacementState>();
alliedSupplyStateInstance.AddComponent <SupplyState>();
alliedInvasionStateInstance.AddComponent <AlliedInvasionState>();
alliedAirborneStateInstance.AddComponent <AlliedAirborneState>();
alliedMovementStateInstance.AddComponent <MovementState>();
alliedCombatStateInstance.AddComponent <CombatState>();
alliedTacticalAirStateInstance.AddComponent <AlliedTacticalAirState>();
germanAIStateInstance.AddComponent <GermanAIState>();
// AI TESTING
germanCombatStateInstance = new GameObject("germanCombatStateInstance");
germanCombatStateInstance.AddComponent <CombatState>();
germanCombatStateInstance.GetComponent <CombatState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
// Set up the state transitions
setUpStateInstance.GetComponent <SetUpState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
germanAISetupStateInstance.GetComponent <GermanAISetupState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
turnInitializationStateInstance.GetComponent <TurnInitializationState>().nextGameState = alliedReplacementStateInstance.GetComponent <AlliedReplacementState>();
alliedReplacementStateInstance.GetComponent <AlliedReplacementState>().nextGameState = alliedSupplyStateInstance.GetComponent <SupplyState>();
alliedSupplyStateInstance.GetComponent <SupplyState>().nextGameState = alliedInvasionStateInstance.GetComponent <AlliedInvasionState>();
alliedInvasionStateInstance.GetComponent <AlliedInvasionState>().nextGameState = alliedAirborneStateInstance.GetComponent <AlliedAirborneState>();
alliedAirborneStateInstance.GetComponent <AlliedAirborneState>().nextGameState = alliedMovementStateInstance.GetComponent <MovementState>();
alliedMovementStateInstance.GetComponent <MovementState>().nextGameState = alliedCombatStateInstance.GetComponent <CombatState>();
alliedCombatStateInstance.GetComponent <CombatState>().nextGameState = alliedTacticalAirStateInstance.GetComponent <AlliedTacticalAirState>();
alliedTacticalAirStateInstance.GetComponent <AlliedTacticalAirState>().nextGameState = germanAIStateInstance.GetComponent <GermanAIState>();
germanAIStateInstance.GetComponent <GermanAIState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
// Set up the correct nationality for the game states that share
turnInitializationStateInstance.GetComponent <TurnInitializationState>().currentNationality = GlobalDefinitions.Nationality.Allied;
alliedMovementStateInstance.GetComponent <MovementState>().currentNationality = GlobalDefinitions.Nationality.Allied;
alliedCombatStateInstance.GetComponent <CombatState>().currentNationality = GlobalDefinitions.Nationality.Allied;
}
// The AI is playing the Allied side
else
{
setUpStateInstance = new GameObject("setUpStateInstance");
turnInitializationStateInstance = new GameObject("turnInitializationStateInstance");
alliedAIStateInstance = new GameObject("alliedAIStateInstance");
alliedCombatStateInstance = new GameObject("alliedCombatStateInstance");
alliedAITacticalAirStateInstance = new GameObject("alliedAITacticalAirStateInstance");
germanIsolationStateInstance = new GameObject("germanIsolationStateInstance");
germanReplacementStateInstance = new GameObject("germanReplacementStateInstance");
germanMovementStateInstance = new GameObject("germanMovementStateInstance");
germanCombatStateInstance = new GameObject("germanCombatStateInstance");
setUpStateInstance.AddComponent <SetUpState>();
turnInitializationStateInstance.AddComponent <TurnInitializationState>();
alliedAIStateInstance.AddComponent <AlliedAIState>();
alliedCombatStateInstance.AddComponent <CombatState>();
alliedAITacticalAirStateInstance.AddComponent <AlliedAITacticalAirState>();
germanIsolationStateInstance.AddComponent <GermanIsolationState>();
germanReplacementStateInstance.AddComponent <GermanReplacementState>();
germanMovementStateInstance.AddComponent <MovementState>();
germanCombatStateInstance.AddComponent <CombatState>();
setUpStateInstance.GetComponent <SetUpState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
turnInitializationStateInstance.GetComponent <TurnInitializationState>().nextGameState = alliedAIStateInstance.GetComponent <AlliedAIState>();
alliedAIStateInstance.GetComponent <AlliedAIState>().nextGameState = alliedCombatStateInstance.GetComponent <CombatState>();
alliedCombatStateInstance.GetComponent <CombatState>().nextGameState = alliedAITacticalAirStateInstance.GetComponent <AlliedAITacticalAirState>();
alliedAITacticalAirStateInstance.GetComponent <AlliedAITacticalAirState>().nextGameState = germanIsolationStateInstance.GetComponent <GermanIsolationState>();
germanIsolationStateInstance.GetComponent <GermanIsolationState>().nextGameState = germanReplacementStateInstance.GetComponent <GermanReplacementState>();
germanReplacementStateInstance.GetComponent <GermanReplacementState>().nextGameState = germanMovementStateInstance.GetComponent <MovementState>();
germanMovementStateInstance.GetComponent <MovementState>().nextGameState = germanCombatStateInstance.GetComponent <CombatState>();
germanCombatStateInstance.GetComponent <CombatState>().nextGameState = turnInitializationStateInstance.GetComponent <TurnInitializationState>();
// Set up the correct nationality for the game states that share
turnInitializationStateInstance.GetComponent <TurnInitializationState>().currentNationality = GlobalDefinitions.Nationality.Allied;
germanIsolationStateInstance.GetComponent <GermanIsolationState>().currentNationality = GlobalDefinitions.Nationality.German;
//alliedMovementStateInstance.GetComponent<MovementState>().currentNationality = GlobalDefinitions.Nationality.Allied;
alliedCombatStateInstance.GetComponent <CombatState>().currentNationality = GlobalDefinitions.Nationality.Allied;
germanMovementStateInstance.GetComponent <MovementState>().currentNationality = GlobalDefinitions.Nationality.German;
germanCombatStateInstance.GetComponent <CombatState>().currentNationality = GlobalDefinitions.Nationality.German;
}
}
