/// <summary> /// Write out the current configuration settings to the configuration file /// </summary> /// <param name="difficultySetting"></param> /// <param name="aggresivenessSetting"></param> public void WriteSettingsFile(int difficultySetting, int aggressiveSetting) { if (File.Exists(GlobalGameFields.settingsFile)) { File.Delete(GlobalGameFields.settingsFile); } StreamWriter fileWriter = new StreamWriter(GlobalGameFields.settingsFile); GlobalDefinitions.WriteToLogFile("writeSettingsFile: creating file = " + GlobalGameFields.settingsFile); if (fileWriter == null) { GlobalDefinitions.GuiUpdateStatusMessage("Unable to create the settings file " + GameControl.path + "TGCSettingsFile.txt"); } else { GlobalDefinitions.difficultySetting = Convert.ToInt32(difficultySetting); GlobalDefinitions.aggressiveSetting = Convert.ToInt32(aggressiveSetting); fileWriter.WriteLine("Difficulty " + difficultySetting); GlobalDefinitions.WriteToLogFile("writeSettingsFile: Difficulty = " + difficultySetting); fileWriter.WriteLine("Aggressive " + aggressiveSetting); GlobalDefinitions.WriteToLogFile("writeSettingsFile: Aggressive = " + aggressiveSetting); fileWriter.Close(); } }
/// <summary> /// Reads the configuration settings from the configuration file /// </summary> public void ReadSettingsFile() { char[] delimiterChars = { ' ' }; string line; string[] switchEntries; StreamReader theReader = new StreamReader(GlobalGameFields.settingsFile); using (theReader) { do { line = theReader.ReadLine(); if (line != null) { switchEntries = line.Split(delimiterChars); switch (switchEntries[0]) { case "Difficulty": GlobalDefinitions.WriteToLogFile("readSettingsFile: " + line); GlobalDefinitions.difficultySetting = Convert.ToInt32(switchEntries[1]); break; case "Aggressive": GlobalDefinitions.WriteToLogFile("readSettingsFile: " + line); GlobalDefinitions.aggressiveSetting = Convert.ToInt32(switchEntries[1]); break; } } }while (line != null); theReader.Close(); } }
/// <summary> /// Used to toggle the air support option on the combat gui in network games /// </summary> public void ToggleAirSupport() { GlobalDefinitions.WriteToCommandFile(GlobalDefinitions.TOGGLEAIRSUPPORTCOMBATTOGGLE + " " + name); if (this.GetComponent <Toggle>().isOn) { if (GlobalDefinitions.tacticalAirMissionsThisTurn < GlobalDefinitions.maxNumberOfTacticalAirMissions) { currentCombat.GetComponent <Combat>().attackAirSupport = true; GlobalDefinitions.WriteToLogFile("toggleAirSupport: incrementing GlobalDefinitions.tacticalAirMissionsThisTurn"); GlobalDefinitions.tacticalAirMissionsThisTurn++; } else { GlobalDefinitions.WriteToLogFile("No more air missions available"); this.GetComponent <Toggle>().isOn = false; } } else { currentCombat.GetComponent <Combat>().attackAirSupport = false; GlobalDefinitions.tacticalAirMissionsThisTurn--; } UpdateOddsText(); }
public void NewSavedGameOK() { if (GlobalDefinitions.newGameToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.WriteToLogFile("newSavedGameOK: Starting new game"); GUIRoutines.RemoveGUI(transform.parent.gameObject); GameControl.setUpStateInstance.GetComponent <SetUpState>().ExecuteNewGame(); } else if (GlobalDefinitions.savedGameToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.WriteToLogFile("newSavedGameOK: Starting saved game"); // Since at this point we know we are starting a new game and not running the command file, remove the command file if (!GlobalDefinitions.commandFileBeingRead) { GlobalDefinitions.DeleteCommandFile(); } GUIRoutines.RemoveGUI(transform.parent.gameObject); GameControl.setUpStateInstance.GetComponent <SetUpState>().ExecuteSavedGame(); } else if (GlobalDefinitions.commandFileToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.WriteToLogFile("newSavedGameOK: Executing command file"); GUIRoutines.RemoveGUI(transform.parent.gameObject); GameControl.setUpStateInstance.GetComponent <SetUpState>().ReadCommandFile(); } }
/// <summary> /// Draws a line between the two points passed /// </summary> /// <param name="point1"></param> /// <param name="point2"></param> public static void DrawLineBetweenTwoPoints(Vector3 point1, Vector3 point2, float width, UnityEngine.Color color) { Material lineMaterial = Resources.Load("LineMaterial", typeof(Material)) as Material; GameObject line = new GameObject("DrawLineBetweenTwoPoints"); if (lineMaterial == null) { GlobalDefinitions.WriteToLogFile("DrawLineBetweenTwoPoints: ERROR - Material returned null from Resources"); } line.layer = LayerMask.NameToLayer("Lines"); line.transform.SetParent(GameObject.Find("Lines").transform); Vector3[] linePositions = new Vector3[2]; linePositions[0] = point1; linePositions[1] = point2; line.AddComponent <LineRenderer>(); line.GetComponent <LineRenderer>().useWorldSpace = true; line.GetComponent <LineRenderer>().startColor = color; line.GetComponent <LineRenderer>().endColor = color; line.GetComponent <LineRenderer>().positionCount = 2; line.GetComponent <LineRenderer>().startWidth = 0.5f; line.GetComponent <LineRenderer>().endWidth = 0.5f; line.GetComponent <LineRenderer>().numCapVertices = 10; line.GetComponent <LineRenderer>().material = lineMaterial; line.GetComponent <LineRenderer>().SetPositions(linePositions); line.GetComponent <LineRenderer>().sortingLayerName = "Lines"; line.GetComponent <LineRenderer>().startWidth = width; line.GetComponent <LineRenderer>().endWidth = width; }
/// <summary> /// This routine is called when a unit decides to attack from a fortress. It toggles all units that would be in the unit's ZOC if it wasn't in a fortress. /// </summary> /// <param name="fortressHex"></param> public void AddDefendersOfFortressAttack(GameObject fortressHex) { foreach (HexDefinitions.HexSides hexSide in Enum.GetValues(typeof(HexDefinitions.HexSides))) { if (fortressHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide] != null) { if (!fortressHex.GetComponent <BooleanArrayData>().riverSides[(int)hexSide] && !fortressHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().fortress) { if ((fortressHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit.Count > 0) && (fortressHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit[0].GetComponent <UnitDatabaseFields>().nationality != fortressHex.GetComponent <HexDatabaseFields>().occupyingUnit[0].GetComponent <UnitDatabaseFields>().nationality)) { // If we get here then the unit should be highlighted since it is adjacent and isn't separated by a river or it isn't a fortress foreach (GameObject unit in fortressHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSide].GetComponent <HexDatabaseFields>().occupyingUnit) { GlobalDefinitions.HighlightUnit(unit); foreach (Transform childTransform in transform.parent.transform) { if ((childTransform.gameObject.GetComponent <CombatToggleRoutines>() != null) && (childTransform.gameObject.GetComponent <CombatToggleRoutines>().unit == unit)) { // Turn on the defenders toggle to show that the unit must be attacked GlobalDefinitions.WriteToLogFile("addDefendersOfFortressAttack: adding unit " + unit.name + " as defender of attack from fortress"); childTransform.GetComponent <Toggle>().isOn = true; // The only way to turn the toggle off will be to click off the attacking unit childTransform.GetComponent <Toggle>().interactable = false; } } } } } } } }
/// <summary> /// Creates the state instances and sets up the state transitions for network or hotseat games /// </summary> public static void CreateStatesForHotSeatOrNetwork() { GlobalDefinitions.WriteToLogFile("createStatesForHotSeatOrNetwork: executing"); setUpStateInstance = new GameObject("setUpStateInstance"); 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"); germanIsolationStateInstance = new GameObject("germanIsolationStateInstance"); germanReplacementStateInstance = new GameObject("germanReplacementStateInstance"); germanMovementStateInstance = new GameObject("germanMovementStateInstance"); germanCombatStateInstance = new GameObject("germanCombatStateInstance"); setUpStateInstance.AddComponent <SetUpState>(); turnInitializationStateInstance.AddComponent <TurnInitializationState>(); alliedReplacementStateInstance.AddComponent <AlliedReplacementState>(); alliedSupplyStateInstance.AddComponent <SupplyState>(); alliedInvasionStateInstance.AddComponent <AlliedInvasionState>(); alliedAirborneStateInstance.AddComponent <AlliedAirborneState>(); alliedMovementStateInstance.AddComponent <MovementState>(); alliedCombatStateInstance.AddComponent <CombatState>(); alliedTacticalAirStateInstance.AddComponent <AlliedTacticalAirState>(); germanIsolationStateInstance.AddComponent <GermanIsolationState>(); germanReplacementStateInstance.AddComponent <GermanReplacementState>(); germanMovementStateInstance.AddComponent <MovementState>(); germanCombatStateInstance.AddComponent <CombatState>(); // Set up the state transitions setUpStateInstance.GetComponent <SetUpState>().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 = 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; }
/// <summary> /// This routine is used to adjust the unit limits when a unit is landed from Britain /// </summary> /// <param name="unit"></param> public void IncrementInvasionUnitLimits(GameObject unit) { int invasionAreaIndex = unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().invasionAreaIndex; if ((GlobalDefinitions.invasionAreas[invasionAreaIndex].invaded) && ((GlobalDefinitions.invasionAreas[invasionAreaIndex].turn == 1) || (GlobalDefinitions.invasionAreas[invasionAreaIndex].turn == 2))) { if (unit.GetComponent <UnitDatabaseFields>().armor) { GlobalDefinitions.invasionAreas[invasionAreaIndex].armorUnitsUsedThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn++; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn++; } else if (unit.GetComponent <UnitDatabaseFields>().infantry) { // First check if infantry should be used against the armor limits if (GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUnitsUsedThisTurn == ReturnMaxInfantryUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[invasionAreaIndex])) { // If so then increment the armor and the decrement the infantry used as armor GlobalDefinitions.invasionAreas[invasionAreaIndex].armorUnitsUsedThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUsedAsArmorThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn++; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn++; } else { GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUnitsUsedThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn++; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn++; } } else if (unit.GetComponent <UnitDatabaseFields>().airborne) { // Airborne landed over a beach counts against the infantry limits GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUnitsUsedThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].airborneUsedAsInfantryThisTurn++; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn++; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn++; } else { GlobalDefinitions.WriteToLogFile("incrementInvasionLimits: ERROR - unit = " + unit.name + " Most likely due to an HQ being landed during the first two turns.. This should never be executed"); } } else { // Note that a unit being landed in a non-invasion area so use the turn three limits GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn++; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn++; } }
/// <summary> /// Sets the global variables related to an invasion site /// </summary> /// <param name="invadedAreaSectionIndex"></param> public void SetInvasionArea(int invadedAreaSectionIndex) { GlobalDefinitions.WriteToLogFile("setInvasionArea: executing with index " + invadedAreaSectionIndex); GlobalDefinitions.numberInvasionsExecuted++; if (GlobalDefinitions.turnNumber == 1) { GlobalDefinitions.firstInvasionAreaIndex = invadedAreaSectionIndex; GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].invaded = true; GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].turn = 1; } else { GlobalDefinitions.secondInvasionAreaIndex = invadedAreaSectionIndex; GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].invaded = true; GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].turn = 1; } }
// Called when the user select to change the status of air support on the combat resolution gui public void AddAttackAirSupport() { if (GetComponent <Toggle>().isOn) { GlobalDefinitions.WriteToCommandFile(GlobalDefinitions.ADDCOMBATAIRSUPPORTKEYWORD + " " + name); if (GlobalDefinitions.tacticalAirMissionsThisTurn < GlobalDefinitions.maxNumberOfTacticalAirMissions) { curentCombat.GetComponent <Combat>().attackAirSupport = true; GlobalDefinitions.WriteToLogFile("addAttackAirSupport: incrementing GlobalDefinitions.tacticalAirMissionsThisTurn"); GlobalDefinitions.tacticalAirMissionsThisTurn++; attackFactorTextGameObject.GetComponent <TextMeshProUGUI>().text = CalculateBattleOddsRoutines.CalculateAttackFactor( curentCombat.GetComponent <Combat>().attackingUnits, curentCombat.GetComponent <Combat>().attackAirSupport).ToString(); oddsTextGameObject.GetComponent <TextMeshProUGUI>().text = GlobalDefinitions.ConvertOddsToString( CalculateBattleOddsRoutines.ReturnCombatOdds(curentCombat.GetComponent <Combat>().defendingUnits, curentCombat.GetComponent <Combat>().attackingUnits, curentCombat.GetComponent <Combat>().attackAirSupport)); } else { GlobalDefinitions.GuiUpdateStatusMessage("No more air support missions left to assign"); GetComponent <Toggle>().isOn = false; } } else { GlobalDefinitions.WriteToCommandFile(GlobalDefinitions.REMOVECOMBATAIRSUPPORTKEYWORD + " " + name); curentCombat.GetComponent <Combat>().attackAirSupport = false; GlobalDefinitions.tacticalAirMissionsThisTurn--; attackFactorTextGameObject.GetComponent <TextMeshProUGUI>().text = CalculateBattleOddsRoutines.CalculateAttackFactor( curentCombat.GetComponent <Combat>().attackingUnits, curentCombat.GetComponent <Combat>().attackAirSupport).ToString(); oddsTextGameObject.GetComponent <TextMeshProUGUI>().text = GlobalDefinitions.ConvertOddsToString( CalculateBattleOddsRoutines.ReturnCombatOdds( curentCombat.GetComponent <Combat>().defendingUnits, curentCombat.GetComponent <Combat>().attackingUnits, curentCombat.GetComponent <Combat>().attackAirSupport)); } }
private int ReturnMaxInfantryUnitsForInvasionAreaThisTurn(InvasionArea targetArea) { if (targetArea.turn == 0) { GlobalDefinitions.WriteToLogFile("returnMaxInfantryUnitsForInvasionAreaThisTurn: Something is wrong - invasion area with turn set to 0"); return(0); } else if (targetArea.turn == 1) { return(targetArea.firstTurnInfantry); } else if (targetArea.turn == 2) { return(targetArea.secondTurnInfantry); } else { return(targetArea.divisionsPerTurn); } }
/// <summary> /// Routine pulls up a list of the invasion areas for the user to select from. /// </summary> /// <returns></returns> public void SelectInvasionArea() { GlobalDefinitions.WriteToLogFile("selectInvasionArea: executing"); Canvas invasionAreaSelectionCanvasInstance = new Canvas(); float panelWidth = 3 * 1.25f * GlobalDefinitions.GUIUNITIMAGESIZE; float panelHeight = 9 * GlobalDefinitions.GUIUNITIMAGESIZE; GlobalDefinitions.invasionAreaSelectionGUIInstance = GUIRoutines.CreateGUICanvas("InvasionAreaSelectionGUIInstance", panelWidth, panelHeight, ref invasionAreaSelectionCanvasInstance, 0.16f, 0.16f); GlobalDefinitions.invasionAreaSelectionGUIInstance.GetComponent <RectTransform>().anchorMin = new Vector2(0.16f, 0.5f); GUIRoutines.CreateUIText("Select invasion area", "InvasionAreaSelectionText", (3) * 1.25f * GlobalDefinitions.GUIUNITIMAGESIZE, 1 * GlobalDefinitions.GUIUNITIMAGESIZE, 1.5f * GlobalDefinitions.GUIUNITIMAGESIZE - 0.5f * panelWidth, (8) * GlobalDefinitions.GUIUNITIMAGESIZE - 0.5f * panelHeight, Color.white, invasionAreaSelectionCanvasInstance, 0.16f, 0.16f, 0.5f, 0.5f); for (int index = 0; index < 7; index++) { Toggle tempToggle; GUIRoutines.CreateUIText(GlobalDefinitions.invasionAreas[index].name, "InvasionAreaSelectionText", 2 * GlobalDefinitions.GUIUNITIMAGESIZE, GlobalDefinitions.GUIUNITIMAGESIZE, GlobalDefinitions.GUIUNITIMAGESIZE * 1.25f - 0.5f * panelWidth, (index + 1) * GlobalDefinitions.GUIUNITIMAGESIZE - 0.5f * panelHeight, Color.white, invasionAreaSelectionCanvasInstance, 0.16f, 0.16f, 0.5f, 0.5f); tempToggle = GUIRoutines.CreateToggle("InvasionAreaSelectionToggle" + index, 2 * 1.25f * GlobalDefinitions.GUIUNITIMAGESIZE - 0.5f * panelWidth, (index + 1) * GlobalDefinitions.GUIUNITIMAGESIZE - 0.5f * panelHeight, invasionAreaSelectionCanvasInstance, 0.16f, 0.16f, 0.5f, 0.5f).GetComponent <Toggle>(); tempToggle.gameObject.AddComponent <InvasionSelectionToggleRoutines>(); tempToggle.GetComponent <InvasionSelectionToggleRoutines>().index = index; tempToggle.onValueChanged.AddListener((bool value) => tempToggle.GetComponent <InvasionSelectionToggleRoutines>().InvadedAreaSelected()); } }
/// <summary> /// Executes when the OK button is selected /// </summary> public void OkGameMode() { if (MainMenuRoutines.hotseatToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.WriteToLogFile("okGameMode: Setting up hotseat mode"); GlobalDefinitions.gameMode = GlobalDefinitions.GameModeValues.Hotseat; GlobalDefinitions.commandFileHeader = "Hotseat"; GameControl.CreateStatesForHotSeatOrNetwork(); GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState = GameControl.setUpStateInstance.GetComponent <SetUpState>(); GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.Initialize(); GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod(GameControl.inputMessage.GetComponent <InputMessage>()); GlobalDefinitions.gameStarted = true; GlobalDefinitions.SwitchLocalControl(true); GUIRoutines.RemoveGUI(transform.parent.gameObject); } else if (MainMenuRoutines.AIToggle.GetComponent <Toggle>().isOn) { // Note: unlike hotseat or network the state transitions in AI are determined by the side being played so the state creation is called in the button routines // that are invoked by the user selecting the side to play GlobalDefinitions.WriteToLogFile("okGameMode: Setting up AI mode"); GlobalDefinitions.commandFileHeader = "AI"; GlobalDefinitions.AskUserWhichSideToPlay(); GUIRoutines.RemoveGUI(transform.parent.gameObject); } //else if (MainMenuRoutines.peerToPeerNetworkToggle.GetComponent<Toggle>().isOn) //{ // GlobalDefinitions.WriteToLogFile("okGameMode: Setting up Peer to Peer Network mode"); // GlobalDefinitions.gameMode = GlobalDefinitions.GameModeValues.Peer2PeerNetwork; // GlobalDefinitions.commandFileHeader = "Peer2PeerNetwork"; // GameControl.CreateStatesForHotSeatOrNetwork(); // //GameControl.fileTransferServerInstance.GetComponent<FileTransferServer>().initiateFileTransferServer(); // MainMenuRoutines.NetworkSettingsUI(); // GUIRoutines.RemoveGUI(transform.parent.gameObject); //} }
/// <summary> /// This routine goes through a series of checks to see if the units are setup properly. /// </summary> /// <returns></returns> public static bool UpdateHexFields() { bool returnState = true; // Do an initial load of the GermanUnitsOnBoardList GlobalDefinitions.germanUnitsOnBoard.Clear(); // Clear it out first in case multiple passes are made. foreach (Transform unit in GameObject.Find("Units On Board").transform) { if (unit.GetComponent <UnitDatabaseFields>().nationality == GlobalDefinitions.Nationality.German) { GlobalDefinitions.germanUnitsOnBoard.Add(unit.gameObject); } } GlobalDefinitions.WriteToLogFile("updateHexFields: executing ... number of German units on board = " + GlobalDefinitions.germanUnitsOnBoard.Count); foreach (GameObject unit in GlobalDefinitions.germanUnitsOnBoard) { // Unhighlight the unit so that if all units pass they will be unhighlighted GlobalDefinitions.UnhighlightUnit(unit); // Not sure if this is needed. Can't really be in "Units On Board" without a hex assignment if (unit.GetComponent <UnitDatabaseFields>().occupiedHex == null) { GlobalDefinitions.GuiUpdateStatusMessage("Internal Error - Unit " + unit.GetComponent <UnitDatabaseFields>().name + " is not assigned a hex locunit.GetComponent<UnitDatabaseFields>().ation"); GlobalDefinitions.HighlightUnit(unit); returnState = false; } // German static units must be on a coast or inland port hex else if (unit.GetComponent <UnitDatabaseFields>().germanStatic&& !unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().coast&& !unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().inlandPort&& !unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().coastalPort) { GlobalDefinitions.GuiUpdateStatusMessage(unit.GetComponent <UnitDatabaseFields>().unitDesignation + " is a static unit and must start on a coast hex, a port, or an inland port"); GlobalDefinitions.HighlightUnit(unit); returnState = false; } else if (((unit.name == "Armor-German-3SS") || (unit.name == "Armor-German-9SS") || (unit.name == "Armor-German-25SS") || (unit.name == "Armor-German-49SS") || (unit.name == "Armor-German-51SS") || (unit.name == "Armor-German-106") || (unit.name == "Armor-German-15SS")) && (!unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().germanRepalcement)) { GlobalDefinitions.GuiUpdateStatusMessage(unit.GetComponent <UnitDatabaseFields>().unitDesignation + " must start on a replacement hex (hexes in Germany with a star on them"); GlobalDefinitions.HighlightUnit(unit); returnState = false; } // Setup the ZOC for the hex and its neighbors. Note that I did not bother to do this while the user was moving // units around since I think it makes sense to just do it once when he is done. unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().inGermanZOC = true; foreach (HexDefinitions.HexSides hexSides in Enum.GetValues(typeof(HexDefinitions.HexSides))) { if ((unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides] != null) && (unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <BooleanArrayData>().exertsZOC[(int)hexSides])) { unit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().Neighbors[(int)hexSides].GetComponent <HexDatabaseFields>().inGermanZOC = true; } } } if (!returnState) { GlobalDefinitions.GuiUpdateStatusMessage("Cannot exit setup until all issues are resolved"); } return(returnState); }
/// <summary> /// This routine is called to add back to limits when a unit returns to Britain by an undo action /// </summary> /// <param name="unit"></param> public void DecrementInvasionUnitLimits(GameObject unit) { // When returning a unit back to Britain, it only impacts the limits if it is being returned on the turn that it was landed. // Otherwise sending units back will allow the player to replace them with other units and still bring in the full // complement of units available for that turn. The way that I can determine if the unit is being returned on the same turn // that it was landed is whetehr or not it has a beginning hex set. If it does that means it started the turn on the board. if (unit.GetComponent <UnitDatabaseFields>().beginningTurnHex != null) { // No limits should be adjusted for landing this turn since the unit started the turn on the board return; } // The otehr special case I have to check for is an airborne unit being returned to Britain that did an airborne drop this turn. // The way that I can tell this is the case is that the airborne unit will not have an invasion index set to -1 if (unit.GetComponent <UnitDatabaseFields>().airborne&& (unit.GetComponent <UnitDatabaseFields>().invasionAreaIndex == -1)) { GlobalDefinitions.currentAirborneDropsThisTurn--; return; } // Now the only units left are ones that were landed by land this turn int invasionAreaIndex = unit.GetComponent <UnitDatabaseFields>().invasionAreaIndex; if ((GlobalDefinitions.invasionAreas[invasionAreaIndex].invaded) && ((GlobalDefinitions.invasionAreas[invasionAreaIndex].turn == 1) || (GlobalDefinitions.invasionAreas[invasionAreaIndex].turn == 2))) { if (unit.GetComponent <UnitDatabaseFields>().armor) { GlobalDefinitions.invasionAreas[invasionAreaIndex].armorUnitsUsedThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn--; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn--; } // Note airborne counts against the infantry limit if brought in through the beach - which is silly because I've weeded out airborne units before this point else if (unit.GetComponent <UnitDatabaseFields>().infantry) { // First check if the infantry used armor limits to land this turn if (GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUsedAsArmorThisTurn > 0) { GlobalDefinitions.invasionAreas[invasionAreaIndex].armorUnitsUsedThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUsedAsArmorThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn--; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn--; } else { GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUnitsUsedThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn--; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn--; } } else if (unit.GetComponent <UnitDatabaseFields>().airborne) { // We've already taken care of airborne units that were dropped this turn so this unit has to have been landed GlobalDefinitions.invasionAreas[invasionAreaIndex].infantryUnitsUsedThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].airborneUsedAsInfantryThisTurn--; GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn--; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn--; } else { GlobalDefinitions.WriteToLogFile("decrementInvasionUnitLimits: ERROR - Most likely due to an HQ being landed during the first two turns.. This should never be executed"); } } else { // This is a unit being landed in a non-invasion area so use the turn three limits GlobalDefinitions.invasionAreas[invasionAreaIndex].totalUnitsUsedThisTurn--; GlobalDefinitions.numberAlliedReinforcementsLandedThisTurn--; } }
public void ExchangeOKSelected() { List <GameObject> unitsToDelete = new List <GameObject>(); // Determine if the user has selected enough factors if (GlobalDefinitions.exchangeFactorsSelected >= GlobalDefinitions.exchangeFactorsToLose) { GlobalDefinitions.WriteToCommandFile(GlobalDefinitions.OKEXCHANGEKEYWORD + " " + name); GlobalDefinitions.WriteToLogFile("exchangeOKSelected: attackerHadMostFactors = " + attackerHadMostFactors + " Units selected for exchange:"); foreach (GameObject unit in GlobalDefinitions.unitsToExchange) { GlobalDefinitions.WriteToLogFile(" unit " + unit.name); unitsToDelete.Add(unit); } if (attackerHadMostFactors) { foreach (GameObject unit in defendingUnits) { GlobalDefinitions.UnhighlightUnit(unit); GlobalDefinitions.MoveUnitToDeadPile(unit); } defendingUnits.Clear(); foreach (GameObject unit in unitsToDelete) { attackingUnits.Remove(unit); // This is needed to see if there are any attackers left at the end for post-combat movement GlobalDefinitions.UnhighlightUnit(unit); GlobalDefinitions.MoveUnitToDeadPile(unit); } } else { foreach (GameObject unit in attackingUnits) { GlobalDefinitions.UnhighlightUnit(unit); GlobalDefinitions.MoveUnitToDeadPile(unit); } attackingUnits.Clear(); foreach (GameObject unit in unitsToDelete) { GlobalDefinitions.UnhighlightUnit(unit); GlobalDefinitions.MoveUnitToDeadPile(unit); } } GUIRoutines.RemoveGUI(GlobalDefinitions.ExchangeGUIInstance); if (attackerHadMostFactors && (GlobalDefinitions.hexesAvailableForPostCombatMovement.Count > 0) && (attackingUnits.Count > 0)) { CombatResolutionRoutines.SelectUnitsForPostCombatMovement(attackingUnits); } else { // The CombatResolution table will be activated after the post movement combat units are selected which is why this check is needed. GlobalDefinitions.combatResolutionGUIInstance.SetActive(true); } GlobalDefinitions.unitsToExchange.Clear(); } else { GlobalDefinitions.WriteToLogFile("exchangeOKSelected: ERROR - Not enough factors selected"); } }
/// <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; } }
/// <summary> /// This routine sets the game state to the side who is in control /// </summary> /// <param name="currentSide"></param> this is the side that is passed in the saved game file that should be in control public static void SetGameState(string currentSide) { if (Convert.ToString(currentSide) == "German") { // This executes when the German side is in control after the saved file is read in if (GlobalDefinitions.gameMode == GlobalDefinitions.GameModeValues.AI) { if (GlobalDefinitions.nationalityUserIsPlaying == GlobalDefinitions.Nationality.Allied) { // Check if this is a setup file that was read in. The control will be for the German to play for when the player is // playing the German side in order to give him a chance to update the setup. But if the AI is playing the German then // just go to the Allied invasion state if (GlobalDefinitions.turnNumber == 0) { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to turnInitializationStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = turnInitializationStateInstance.GetComponent <TurnInitializationState>(); } else { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to germanAIStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = germanAIStateInstance.GetComponent <GermanAIState>(); } } else { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to germanIsolationStateInstance turn number = " + GlobalDefinitions.turnNumber); // Check if this is a setup file in order to allow the player to update the setup if he wants to if (GlobalDefinitions.turnNumber == 0) { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to setUpStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = setUpStateInstance.GetComponent <SetUpState>(); } else { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to germanIsolationStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = germanIsolationStateInstance.GetComponent <GermanIsolationState>(); } } } else { // Do not set the currentSidePlaying variable if it is an AI game since it will already have been set during the game selection // This is being set for network play since it has no meaning in hotseat GlobalDefinitions.nationalityUserIsPlaying = GlobalDefinitions.Nationality.German; // Check if this is a setup file in order to allow the player to update the setup if he wants to if (GlobalDefinitions.turnNumber == 0) { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to setUpStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = setUpStateInstance.GetComponent <SetUpState>(); } else { GlobalDefinitions.WriteToLogFile("setGameState: setting game state to germanIsolationStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = germanIsolationStateInstance.GetComponent <GermanIsolationState>(); } } } else { // The game state is for the Allied player to be in control // Note we don't need to check for a setup file here since that would indicate that the German side is in control GlobalDefinitions.WriteToLogFile("setGameState: Allied in control, setting game state to turnInitializationStateInstance"); gameStateControlInstance.GetComponent <GameStateControl>().currentState = turnInitializationStateInstance.GetComponent <TurnInitializationState>(); if (GlobalDefinitions.gameMode != GlobalDefinitions.GameModeValues.AI) { // Do not set the currentSidePlaying variable if it is an AI game since it will already have been set during the game selection // This is being set for network play since it has no meaning in hotseat GlobalDefinitions.nationalityUserIsPlaying = GlobalDefinitions.Nationality.Allied; } } }
/// <summary> /// This routine is what processes the message received from the opponent computer or from the saved command file when restarting a game /// </summary> /// <param name="message"></param> public static void ProcessCommand(string message) { char[] delimiterChars = { ' ' }; string[] switchEntries = message.Split(delimiterChars); string[] lineEntries = message.Split(delimiterChars); // I am going to use the same routine to read records that is used when reading from a file. // In order to do this I need to drop the first word on the line since the files don't have key words for (int index = 0; index < (lineEntries.Length - 1); index++) { lineEntries[index] = lineEntries[index + 1]; } switch (switchEntries[0]) { case GlobalDefinitions.PLAYSIDEKEYWORD: if (switchEntries[1] == "German") { GlobalDefinitions.sideControled = GlobalDefinitions.Nationality.German; } else { GlobalDefinitions.sideControled = GlobalDefinitions.Nationality.Allied; } break; case GlobalDefinitions.PASSCONTROLKEYWORK: GlobalDefinitions.SwitchLocalControl(true); GlobalDefinitions.WriteToLogFile("processNetworkMessage: Message received to set local control"); break; case GlobalDefinitions.SETCAMERAPOSITIONKEYWORD: Camera.main.transform.position = new Vector3(float.Parse(switchEntries[1]), float.Parse(switchEntries[2]), float.Parse(switchEntries[3])); Camera.main.GetComponent <Camera>().orthographicSize = float.Parse(switchEntries[4]); break; case GlobalDefinitions.MOUSESELECTIONKEYWORD: if (switchEntries[1] != "null") { GameControl.inputMessage.GetComponent <InputMessage>().hex = GameObject.Find(switchEntries[1]); } else { GameControl.inputMessage.GetComponent <InputMessage>().hex = null; } if (switchEntries[2] != "null") { GameControl.inputMessage.GetComponent <InputMessage>().unit = GameObject.Find(switchEntries[2]); } else { GameControl.inputMessage.GetComponent <InputMessage>().unit = null; } GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod(GameControl.inputMessage.GetComponent <InputMessage>()); break; case GlobalDefinitions.MOUSEDOUBLECLICKIONKEYWORD: GlobalDefinitions.Nationality passedNationality; if (switchEntries[2] == "German") { passedNationality = GlobalDefinitions.Nationality.German; } else { passedNationality = GlobalDefinitions.Nationality.Allied; } if (GlobalDefinitions.selectedUnit != null) { GlobalDefinitions.UnhighlightUnit(GlobalDefinitions.selectedUnit); } foreach (Transform hex in GameObject.Find("Board").transform) { GlobalDefinitions.UnhighlightHex(hex.gameObject); } GlobalDefinitions.selectedUnit = null; GameControl.movementRoutinesInstance.GetComponent <MovementRoutines>().CallMultiUnitDisplay(GameObject.Find(switchEntries[1]), passedNationality); break; case GlobalDefinitions.DISPLAYCOMBATRESOLUTIONKEYWORD: CombatResolutionRoutines.CombatResolutionDisplay(); break; case GlobalDefinitions.NEXTPHASEKEYWORD: GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.ExecuteQuit(); break; case GlobalDefinitions.EXECUTETACTICALAIROKKEYWORD: TacticalAirToggleRoutines.TacticalAirOK(); break; case GlobalDefinitions.ADDCLOSEDEFENSEKEYWORD: GameObject.Find("CloseDefense").GetComponent <TacticalAirToggleRoutines>().AddCloseDefenseHex(); break; case GlobalDefinitions.CANCELCLOSEDEFENSEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().CancelCloseDefense(); break; case GlobalDefinitions.LOCATECLOSEDEFENSEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().LocateCloseDefense(); break; case GlobalDefinitions.ADDRIVERINTERDICTIONKEYWORD: GameObject.Find("RiverInterdiction").GetComponent <TacticalAirToggleRoutines>().AddRiverInterdiction(); break; case GlobalDefinitions.CANCELRIVERINTERDICTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().CancelRiverInterdiction(); break; case GlobalDefinitions.LOCATERIVERINTERDICTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().LocateRiverInterdiction(); break; case GlobalDefinitions.ADDUNITINTERDICTIONKEYWORD: GameObject.Find("UnitInterdiction").GetComponent <TacticalAirToggleRoutines>().AddInterdictedUnit(); break; case GlobalDefinitions.CANCELUNITINTERDICTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().CancelInterdictedUnit(); break; case GlobalDefinitions.LOCATEUNITINTERDICTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().LocateInterdictedUnit(); break; case GlobalDefinitions.TACAIRMULTIUNITSELECTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <TacticalAirToggleRoutines>().MultiUnitSelection(); break; case GlobalDefinitions.MULTIUNITSELECTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.MULTIUNITSELECTIONCANCELKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <MultiUnitMovementToggleRoutines>().CancelGui(); break; case GlobalDefinitions.LOADCOMBATKEYWORD: GameObject GUIButtonInstance = new GameObject("GUIButtonInstance"); GUIButtonInstance.AddComponent <GUIButtonRoutines>(); GUIButtonInstance.GetComponent <GUIButtonRoutines>().LoadCombat(); break; case GlobalDefinitions.SETCOMBATTOGGLEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.RESETCOMBATTOGGLEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = false; break; case GlobalDefinitions.COMBATGUIOKKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CombatGUIOK>().OkCombatGUISelection(); break; case GlobalDefinitions.COMBATGUICANCELKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CombatGUIOK>().CancelCombatGUISelection(); break; case GlobalDefinitions.ADDCOMBATAIRSUPPORTKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.REMOVECOMBATAIRSUPPORTKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = false; break; case GlobalDefinitions.COMBATRESOLUTIONSELECTEDKEYWORD: // Load the combat results; the die roll is on the Global variable //GlobalDefinitions.writeToLogFile("Die Roll 1 = " + GlobalDefinitions.dieRollResult1); //GlobalDefinitions.writeToLogFile("Die Roll 2 = " + GlobalDefinitions.dieRollResult2); GameObject.Find(switchEntries[1]).GetComponent <CombatResolutionButtonRoutines>().ResolutionSelected(); break; case GlobalDefinitions.COMBATLOCATIONSELECTEDKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CombatResolutionButtonRoutines>().LocateAttack(); break; case GlobalDefinitions.COMBATCANCELKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CombatResolutionButtonRoutines>().CancelAttack(); break; case GlobalDefinitions.COMBATOKKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CombatResolutionButtonRoutines>().Ok(); break; case GlobalDefinitions.CARPETBOMBINGRESULTSSELECTEDKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.RETREATSELECTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.SELECTPOSTCOMBATMOVEMENTKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.DESELECTPOSTCOMBATMOVEMENTKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = false; break; case GlobalDefinitions.ADDEXCHANGEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.REMOVEEXCHANGEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = false; break; case GlobalDefinitions.OKEXCHANGEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <ExchangeOKRoutines>().ExchangeOKSelected(); break; case GlobalDefinitions.POSTCOMBATOKKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <PostCombatMovementOkRoutines>().ExecutePostCombatMovement(); break; case GlobalDefinitions.DISPLAYALLIEDSUPPLYKEYWORD: if (switchEntries[1] == "True") { GameControl.supplyRoutinesInstance.GetComponent <SupplyRoutines>().CreateSupplySourceGUI(true); } else { GameControl.supplyRoutinesInstance.GetComponent <SupplyRoutines>().CreateSupplySourceGUI(false); } break; case GlobalDefinitions.SETSUPPLYKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.RESETSUPPLYKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = false; break; case GlobalDefinitions.LOCATESUPPLYKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <SupplyButtonRoutines>().LocateSupplySource(); break; case GlobalDefinitions.OKSUPPLYKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <SupplyButtonRoutines>().OkSupply(); break; case GlobalDefinitions.OKSUPPLYWITHENDPHASEKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <SupplyButtonRoutines>().OkSupplyWithEndPhase(); break; case GlobalDefinitions.CHANGESUPPLYSTATUSKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.YESBUTTONSELECTEDKEYWORD: GameObject.Find("YesButton").GetComponent <YesNoButtonRoutines>().YesButtonSelected(); break; case GlobalDefinitions.NOBUTTONSELECTEDKEYWORD: GameObject.Find("NoButton").GetComponent <YesNoButtonRoutines>().NoButtonSelected(); break; case GlobalDefinitions.SAVEFILENAMEKEYWORD: if (File.Exists(GameControl.path + "TGCOutputFiles\\TGCRemoteSaveFile.txt")) { File.Delete(GameControl.path + "TGCOutputFiles\\TGCRemoteSaveFile.txt"); } break; case GlobalDefinitions.SENDSAVEFILELINEKEYWORD: using (StreamWriter saveFile = File.AppendText(GameControl.path + "TGCOutputFiles\\TGCRemoteSaveFile.txt")) { for (int index = 1; index < (switchEntries.Length); index++) { saveFile.Write(switchEntries[index] + " "); } saveFile.WriteLine(); } break; case GlobalDefinitions.PLAYNEWGAMEKEYWORD: GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState = GameControl.setUpStateInstance.GetComponent <SetUpState>(); GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.Initialize(); // Set the global parameter on what file to use, can't pass it to the executeNoResponse since it is passed as a method delegate elsewhere GlobalDefinitions.germanSetupFileUsed = Convert.ToInt32(switchEntries[1]); GameControl.setUpStateInstance.GetComponent <SetUpState>().ExecuteNewGame(); break; case GlobalDefinitions.INVASIONAREASELECTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.CARPETBOMBINGSELECTIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <Toggle>().isOn = true; break; case GlobalDefinitions.CARPETBOMBINGLOCATIONKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CarpetBombingToggleRoutines>().LocateCarpetBombingHex(); break; case GlobalDefinitions.CARPETBOMBINGOKKEYWORD: GameObject.Find(switchEntries[1]).GetComponent <CarpetBombingOKRoutines>().CarpetBombingOK(); break; case GlobalDefinitions.DIEROLLRESULT1KEYWORD: GlobalDefinitions.dieRollResult1 = Convert.ToInt32(switchEntries[1]); break; case GlobalDefinitions.DIEROLLRESULT2KEYWORD: GlobalDefinitions.dieRollResult2 = Convert.ToInt32(switchEntries[1]); break; case GlobalDefinitions.UNDOKEYWORD: GameControl.GUIButtonRoutinesInstance.GetComponent <GUIButtonRoutines>().ExecuteUndo(); break; case GlobalDefinitions.CHATMESSAGEKEYWORD: string chatMessage = ""; for (int index = 0; index < (switchEntries.Length - 1); index++) { chatMessage += switchEntries[index + 1] + " "; } GlobalDefinitions.WriteToLogFile("Chat message received: " + chatMessage); GlobalDefinitions.AddChatMessage(chatMessage); break; //case GlobalDefinitions.SENDTURNFILENAMEWORD: // // This command tells the remote computer what the name of the file is that will provide the saved turn file // // The file name could have ' ' in it so need to reconstruct the full name // string receivedFileName; // receivedFileName = switchEntries[1]; // for (int i = 2; i < switchEntries.Length; i++) // receivedFileName = receivedFileName + " " + switchEntries[i]; // GameControl.fileTransferServerInstance.GetComponent<FileTransferServer>().InitiateFileTransferServer(); // GlobalDefinitions.WriteToLogFile("Received name of save file, calling FileTransferServer: fileName = " + receivedFileName + " path to save = " + GameControl.path); // GameControl.fileTransferServerInstance.GetComponent<FileTransferServer>().RequestFile(TransportScript.remoteComputerIPAddress, receivedFileName, GameControl.path, true); // break; case GlobalDefinitions.DISPLAYALLIEDSUPPLYRANGETOGGLEWORD: if (GameObject.Find("AlliedSupplyToggle").GetComponent <Toggle>().isOn) { GameObject.Find("AlliedSupplyToggle").GetComponent <Toggle>().isOn = false; } else { GameObject.Find("AlliedSupplyToggle").GetComponent <Toggle>().isOn = true; } break; case GlobalDefinitions.DISPLAYGERMANSUPPLYRANGETOGGLEWORD: if (GameObject.Find("GermanSupplyToggle").GetComponent <Toggle>().isOn) { GameObject.Find("GermanSupplyToggle").GetComponent <Toggle>().isOn = false; } else { GameObject.Find("GermanSupplyToggle").GetComponent <Toggle>().isOn = true; } break; case GlobalDefinitions.DISPLAYMUSTATTACKTOGGLEWORD: if (GlobalDefinitions.MustAttackToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.MustAttackToggle.GetComponent <Toggle>().isOn = false; } else { GlobalDefinitions.MustAttackToggle.GetComponent <Toggle>().isOn = true; } break; case GlobalDefinitions.TOGGLEAIRSUPPORTCOMBATTOGGLE: { if (GlobalDefinitions.combatAirSupportToggle != null) { if (GlobalDefinitions.combatAirSupportToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.combatAirSupportToggle.GetComponent <Toggle>().isOn = false; } else { GlobalDefinitions.combatAirSupportToggle.GetComponent <Toggle>().isOn = true; } } break; } case GlobalDefinitions.TOGGLECARPETBOMBINGCOMBATTOGGLE: { if (GlobalDefinitions.combatCarpetBombingToggle != null) { if (GlobalDefinitions.combatCarpetBombingToggle.GetComponent <Toggle>().isOn) { GlobalDefinitions.combatCarpetBombingToggle.GetComponent <Toggle>().isOn = false; } else { GlobalDefinitions.combatCarpetBombingToggle.GetComponent <Toggle>().isOn = true; } } break; } case GlobalDefinitions.DISCONNECTFROMREMOTECOMPUTER: { // Quit the game and go back to the main menu GameObject guiButtonInstance = new GameObject("GUIButtonInstance"); guiButtonInstance.AddComponent <GUIButtonRoutines>(); guiButtonInstance.GetComponent <GUIButtonRoutines>().YesMain(); break; } case GlobalDefinitions.ALLIEDREPLACEMENTKEYWORD: GameControl.movementRoutinesInstance.GetComponent <MovementRoutines>().SelectAlliedReplacementUnit(GameObject.Find(switchEntries[1])); break; case GlobalDefinitions.GERMANREPLACEMENTKEYWORD: GameControl.movementRoutinesInstance.GetComponent <MovementRoutines>().SelectGermanReplacementUnit(GameObject.Find(switchEntries[1])); break; case GlobalDefinitions.AGGRESSIVESETTINGKEYWORD: GlobalDefinitions.aggressiveSetting = Convert.ToInt32(switchEntries[1]); break; case GlobalDefinitions.DIFFICULTYSETTINGKEYWORD: GlobalDefinitions.difficultySetting = Convert.ToInt32(switchEntries[1]); break; default: GlobalDefinitions.WriteToLogFile("processCommand: Unknown network command received: " + message); break; } }
/// <summary> /// This routine is called when a new defender is added to the attack and updates the toggles on the combat gui /// </summary> private void RefreshAttackersBasedOnDefenders() { // First go through and enable all the attacking units since if I don't once a unit is disabled it will never be enabled again and this way // I don't have to explicitly check for adjacency to all defenders foreach (GameObject attackingUnit in currentCombat.GetComponent <Combat>().attackingUnits) { foreach (Transform childTransform in transform.parent.transform) { if ((childTransform.gameObject.GetComponent <CombatToggleRoutines>() != null) && (childTransform.gameObject.GetComponent <CombatToggleRoutines>().unit == attackingUnit)) { // check if there is an invasion taking place and if so do not turn the check back on. if (!GameControl.combatRoutinesInstance.GetComponent <CombatRoutines>().CheckForInvadingAttacker(childTransform.gameObject.GetComponent <CombatToggleRoutines>().unit)) { childTransform.gameObject.GetComponent <Toggle>().interactable = true; } } } } // Go through each of the defenders and gray out any attacker that isn't adjacent. By going through each of the defenders I am left // with only attackers that are adjacent to all defending units foreach (GameObject defendingUnit in currentCombat.GetComponent <Combat>().defendingUnits) { // Only check for adjacency if the defnder is selected // When this is called because of the code changing a toggle status, the routine is called before the committed variable is set (since it is event triggered // I used to check the isCommittedToAttack variable but this doesn't work in complex situations. Therefore I will check if the unit is committed to the attack by // checking the unit's toggle status bool defendererIsCommitted = false; foreach (Transform defenderChildTransform in transform.parent.transform) { if ((defenderChildTransform.gameObject.GetComponent <CombatToggleRoutines>() != null) && (defenderChildTransform.gameObject.GetComponent <CombatToggleRoutines>().unit == defendingUnit)) { if (defenderChildTransform.gameObject.GetComponent <Toggle>().isOn) { defendererIsCommitted = true; } } } if (defendererIsCommitted) { foreach (GameObject attackingUnit in currentCombat.GetComponent <Combat>().attackingUnits) { if (!GlobalDefinitions.TwoUnitsAdjacent(attackingUnit, defendingUnit)) { // The attacking unit is not adjacent to the defending unit so it needs to be greyed out and disabled in the display foreach (Transform childTransform in transform.parent.transform) { if ((childTransform.gameObject.GetComponent <CombatToggleRoutines>() != null) && (childTransform.gameObject.GetComponent <CombatToggleRoutines>().unit == attackingUnit)) { GlobalDefinitions.WriteToLogFile("refreshAttackersBasedOnDefenders: decommitting attacker and making non-interactable " + attackingUnit.name); GlobalDefinitions.UnhighlightUnit(attackingUnit); attackingUnit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack = false; childTransform.gameObject.GetComponent <Toggle>().isOn = false; childTransform.gameObject.GetComponent <Toggle>().interactable = false; } } } } } } }
/// <summary> /// This routine reads a single record for a unit /// </summary> /// <param name="entries"></param> public void ProcessUnitRecord(string[] entries) { GameObject unit; unit = GameObject.Find(entries[0]); if (entries[1] == "null") { unit.GetComponent <UnitDatabaseFields>().occupiedHex = null; } else { unit.GetComponent <UnitDatabaseFields>().occupiedHex = GameObject.Find(entries[1]); } if (entries[2] == "null") { unit.GetComponent <UnitDatabaseFields>().beginningTurnHex = null; } else { unit.GetComponent <UnitDatabaseFields>().beginningTurnHex = GameObject.Find(entries[2]); } unit.GetComponent <UnitDatabaseFields>().inBritain = GlobalDefinitions.ReturnBoolFromSaveFormat(entries[3]); unit.GetComponent <UnitDatabaseFields>().unitInterdiction = GlobalDefinitions.ReturnBoolFromSaveFormat(entries[4]); unit.GetComponent <UnitDatabaseFields>().invasionAreaIndex = Convert.ToInt32(entries[5]); unit.GetComponent <UnitDatabaseFields>().availableForStrategicMovement = GlobalDefinitions.ReturnBoolFromSaveFormat(entries[6]); unit.GetComponent <UnitDatabaseFields>().inSupply = GlobalDefinitions.ReturnBoolFromSaveFormat(entries[7]); // Need to adjust the highlighting of the unit if it is out of supply GlobalDefinitions.UnhighlightUnit(unit); if (entries[8] == "null") { unit.GetComponent <UnitDatabaseFields>().supplySource = null; } else { unit.GetComponent <UnitDatabaseFields>().supplySource = GameObject.Find(entries[8]); } unit.GetComponent <UnitDatabaseFields>().supplyIncrementsOutOfSupply = Convert.ToInt32(entries[9]); unit.GetComponent <UnitDatabaseFields>().unitEliminated = GlobalDefinitions.ReturnBoolFromSaveFormat(entries[10]); if (unit.GetComponent <UnitDatabaseFields>().occupiedHex != null) { GeneralHexRoutines.PutUnitOnHex(unit, unit.GetComponent <UnitDatabaseFields>().occupiedHex); unit.transform.parent = GlobalDefinitions.allUnitsOnBoard.transform; } else if (unit.GetComponent <UnitDatabaseFields>().unitEliminated) { unit.transform.parent = GameObject.Find("Units Eliminated").transform; unit.transform.position = unit.GetComponent <UnitDatabaseFields>().OOBLocation; } else if (unit.GetComponent <UnitDatabaseFields>().inBritain) { unit.transform.parent = GameObject.Find("Units In Britain").transform; unit.transform.position = unit.GetComponent <UnitDatabaseFields>().locationInBritain; } else { GlobalDefinitions.WriteToLogFile("processUnitRecord: Unit read error - " + entries[1] + ": found no location to place this unit"); } if (!unit.GetComponent <UnitDatabaseFields>().unitEliminated&& !unit.GetComponent <UnitDatabaseFields>().inBritain) { if (unit.GetComponent <UnitDatabaseFields>().nationality == GlobalDefinitions.Nationality.Allied) { GlobalDefinitions.alliedUnitsOnBoard.Add(unit); } else { GlobalDefinitions.germanUnitsOnBoard.Add(unit); } } }
// Use this for initialization void Start() { GlobalDefinitions.InitializeFileNames(); // Set up the log file path = System.IO.Directory.GetCurrentDirectory() + "\\"; // Put the log and command file in a try block since an exception will be thrown if the game was installed in an un-writeable folder try { if (File.Exists(path + GlobalGameFields.logfile)) { File.Delete(path + GlobalGameFields.logfile); } using (StreamWriter logFile = File.AppendText(GameControl.path + GlobalGameFields.logfile)) { logFile.WriteLine("Starting game at: " + DateTime.Now); logFile.WriteLine("GameControl start(): path = " + System.IO.Directory.GetCurrentDirectory() + "\\"); } } catch { MessageBox.Show("ERROR: Cannot access log file - cannot continue"); GlobalDefinitions.GuiUpdateStatusMessage("Internal Error - Cannot access log file - cannot continue"); } GlobalDefinitions.WriteToLogFile("Game Version " + GlobalDefinitions.releaseVersion); // There are three files that should have been installed with the game. Note, I could get rid of all three of these and just have the // board and the units built into the game rather than reading them. But I haven't done this based on a somewhat vauge idea that this will // make future games easier to build. // The three files are: // TGCBoardSetup.txt - this has been split into four files, each checked at time of execution 7/25/20 // TGCBritainUnitLocation.txt // TGCGermanSetup.txt // Check here that the files exist. If they don't then exit out now if (!File.Exists(path + GlobalGameFields.britainUnitLocationFile)) { MessageBox.Show("ERROR: " + GlobalGameFields.britainUnitLocationFile + " file not found - cannot continue"); UnityEngine.Application.Quit(); } else { GlobalGameFields.britainUnitLocationFile = path + GlobalGameFields.britainUnitLocationFile; } //if (!File.Exists(path + "TGCGermanSetup.txt")) if (!File.Exists(path + "GermanSetup//TGCGermanSetup1.txt")) { MessageBox.Show("ERROR: TGCGermanSetup1.txt file not found - cannot continue"); UnityEngine.Application.Quit(); } GlobalDefinitions.nextPhaseButton.GetComponent <UnityEngine.UI.Button>().interactable = false; GlobalDefinitions.undoButton.GetComponent <UnityEngine.UI.Button>().interactable = false; GlobalDefinitions.MustAttackToggle.GetComponent <Toggle>().interactable = false; GlobalDefinitions.AssignCombatButton.GetComponent <UnityEngine.UI.Button>().interactable = false; GlobalDefinitions.DisplayAllCombatsButton.GetComponent <UnityEngine.UI.Button>().interactable = false; GlobalDefinitions.AlliedSupplyRangeToggle.GetComponent <Toggle>().interactable = false; GlobalDefinitions.GermanSupplyRangeToggle.GetComponent <Toggle>().interactable = false; GlobalDefinitions.AlliedSupplySourcesButton.GetComponent <UnityEngine.UI.Button>().interactable = false; // Hide the chat screen. We will turn it back on if the user selects a network game GameObject.Find("ChatInputField").GetComponent <InputField>().onEndEdit.AddListener(delegate { GlobalDefinitions.ExecuteChatMessage(); }); GlobalDefinitions.chatPanel = GameObject.Find("ChatPanel"); GlobalDefinitions.chatPanel.SetActive(false); // Add a canvas to add UI elements (i.e. text) to the board GlobalDefinitions.mapText = new GameObject(); GlobalDefinitions.mapText.name = "Map Text"; GlobalDefinitions.mapText.transform.SetParent(GameObject.Find("Map Graphics").transform); GlobalDefinitions.mapGraphicCanvas = GlobalDefinitions.mapText.AddComponent <Canvas>(); GlobalDefinitions.mapText.AddComponent <CanvasScaler>(); GlobalDefinitions.mapGraphicCanvas.renderMode = RenderMode.WorldSpace; GlobalDefinitions.mapGraphicCanvas.sortingLayerName = "Text"; // The first thing that needs to be done is store the locations of the units. They // are sitting on the order of battle sheet and this will be their "dead" location GlobalDefinitions.WriteToLogFile("Setting unit OOB locations"); foreach (Transform unit in GameObject.Find("Units Eliminated").transform) { unit.GetComponent <UnitDatabaseFields>().OOBLocation = unit.position; } GlobalDefinitions.WriteToLogFile("GameControl start(): Creating Singletons"); // Create singletons of each of the routine classes CreateSingletons(); GlobalDefinitions.WriteToLogFile("GameControl start(): Setting up the map"); // Set up the map from the read location createBoardInstance.GetComponent <CreateBoard>().ReadMapSetup(); // Load the global for storing all hexes on the board //foreach (Transform hex in GameObject.Find("Board").transform) // HexDefinitions.allHexesOnBoard.Add(hex.gameObject); // Deal with the configuration settings GlobalGameFields.settingsFile = path + GlobalGameFields.settingsFile; // Check if the setting file is present, if it isn't write out a default if (!File.Exists(GlobalGameFields.settingsFile)) { GlobalDefinitions.difficultySetting = 5; GlobalDefinitions.aggressiveSetting = 3; readWriteRoutinesInstance.GetComponent <ReadWriteRoutines>().WriteSettingsFile(5, 3); } else { // If the file exists read the configuration settings readWriteRoutinesInstance.GetComponent <ReadWriteRoutines>().ReadSettingsFile(); } // Reset the min/max odds since the aggressiveness has just been read CombatResolutionRoutines.AdjustAggressiveness(); AIRoutines.SetIntrinsicHexValues(); // AI TESTING hexValueGuiInstance = new GameObject(); Canvas hexValueCanvas = hexValueGuiInstance.AddComponent <Canvas>(); hexValueGuiInstance.AddComponent <CanvasScaler>(); hexValueCanvas.renderMode = RenderMode.WorldSpace; hexValueCanvas.sortingLayerName = "Hex"; hexValueGuiInstance.name = "hexValueGuiInstance"; // AI TESTING //foreach (GameObject hex in HexDefinitions.allHexesOnBoard) // GlobalDefinitions.createHexText(Convert.ToString(hex.GetComponent<HexDatabaseFields>().hexValue), hex.name + "HexValueText", 20, 20, hex.position.x, hex.position.y, 14, hexValueCanvas); GlobalDefinitions.WriteToLogFile("GameControl start(): Putting Allied units in Britain - reading from file: " + GlobalGameFields.britainUnitLocationFile); // When restarting a game the units won't have their Britain location loaded so this needs to be done before a restart file is read createBoardInstance.GetComponent <CreateBoard>().ReadBritainPlacement(GlobalGameFields.britainUnitLocationFile); GlobalDefinitions.WriteToLogFile("GameControl start(): Setting up invasion areas"); createBoardInstance.GetComponent <CreateBoard>().SetupInvasionAreas(); // Make sure the game doesn't start with selected unit or hex GlobalDefinitions.selectedUnit = null; GlobalDefinitions.startHex = null; // Reset the list of active GUI's GUIRoutines.guiList.Clear(); gameStateControlInstance = new GameObject("gameStateControl"); gameStateControlInstance.AddComponent <GameStateControl>(); inputMessage = new GameObject("inputMessage"); inputMessage.AddComponent <InputMessage>(); GlobalDefinitions.allUnitsOnBoard = GameObject.Find("Units On Board"); // Turn off the background of the unit display panel GameObject.Find("UnitDisplayPanel").GetComponent <CanvasGroup>().alpha = 0; // Setup the state for when victory is achieved victoryState = new GameObject("victoryState"); victoryState.AddComponent <VictoryState>(); // At this point everything has been setup. Call up GUI to have the user select the type of game being played GlobalDefinitions.WriteToLogFile("GameControl start(): calling getGameModeUI()"); MainMenuRoutines.GetGameModeUI(); }
/// <summary> /// This routine reads the contents of a save file /// </summary> /// <param name="fileName"></param> public void ReadTurnFile(string fileName) { char[] delimiterChars = { ' ' }; string line; string[] lineEntries; string[] switchEntries; GlobalDefinitions.WriteToLogFile("readTurnFile: executing - passed file = " + fileName); StreamReader theReader = new StreamReader(fileName); using (theReader) { do { line = theReader.ReadLine(); if (line != null) { switchEntries = line.Split(delimiterChars); switch (switchEntries[0]) { case "Turn": GlobalDefinitions.turnNumber = Convert.ToInt32(switchEntries[1]); GlobalDefinitions.GuiUpdateTurn(); break; case "Game_Control": GameControl.SetGameState(switchEntries[1]); break; case "Global_Definitions": ReadGlobalVariables(switchEntries); break; case "Hexes": line = theReader.ReadLine(); lineEntries = line.Split(delimiterChars); while (lineEntries[0] != "End") { string[] entries = line.Split(delimiterChars); ProcessHexRecord(entries); line = theReader.ReadLine(); lineEntries = line.Split(delimiterChars); } break; case "Units": line = theReader.ReadLine(); lineEntries = line.Split(delimiterChars); while (lineEntries[0] != "End") { string[] entries = line.Split(delimiterChars); ProcessUnitRecord(entries); line = theReader.ReadLine(); lineEntries = line.Split(delimiterChars); } break; } } }while (line != null); theReader.Close(); GlobalDefinitions.WriteToLogFile("readTurnFile: File read complete. Initialize Game State"); // If we just read a setup file, put the player into the setup state so that he can update the setup if he wants. if ((GlobalDefinitions.turnNumber == 0) && (GlobalDefinitions.nationalityUserIsPlaying == GlobalDefinitions.Nationality.German)) { GlobalDefinitions.nextPhaseButton.GetComponent <Button>().interactable = true; GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.executeMethod = GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.GetComponent <SetUpState>().ExecuteSelectUnit; } // Otherwise, execute the init for the next state else { GameControl.gameStateControlInstance.GetComponent <GameStateControl>().currentState.Initialize(); } } }
/// <summary> /// Executes when the user indicates he wants to go to main menu /// </summary> public void YesMain() { List <GameObject> removeUnitList = new List <GameObject>(); // If this is a network game I've already checked that the player is in control //if (GlobalDefinitions.gameMode == GlobalDefinitions.GameModeValues.Peer2PeerNetwork) //{ // GlobalDefinitions.WriteToLogFile("YesMain: Calling ResetConnection()"); // //byte error; // //NetworkTransport.Disconnect(TransportScript.receivedHostId, TransportScript.gameConnectionId, out error); // //Network.Disconnect(); // TransportScript.ResetConnection(TransportScript.computerId); //} // Copy list so the guis can be removed List <GameObject> removeList = new List <GameObject>(); foreach (GameObject gui in GUIRoutines.guiList) { removeList.Add(gui); } // Get rid of all active guis foreach (GameObject gui in removeList) { GUIRoutines.RemoveGUI(gui); } // Put all the units back on the OOB sheet foreach (Transform unit in GlobalDefinitions.allUnitsOnBoard.transform) { unit.GetComponent <UnitDatabaseFields>().unitInterdiction = false; unit.GetComponent <UnitDatabaseFields>().isCommittedToAnAttack = false; unit.GetComponent <UnitDatabaseFields>().hasMoved = false; unit.GetComponent <UnitDatabaseFields>().unitEliminated = false; unit.GetComponent <UnitDatabaseFields>().occupiedHex = null; unit.GetComponent <UnitDatabaseFields>().beginningTurnHex = null; unit.GetComponent <UnitDatabaseFields>().invasionAreaIndex = -1; unit.GetComponent <UnitDatabaseFields>().inSupply = true; unit.GetComponent <UnitDatabaseFields>().supplySource = null; unit.GetComponent <UnitDatabaseFields>().supplyIncrementsOutOfSupply = 0; unit.GetComponent <UnitDatabaseFields>().remainingMovement = unit.GetComponent <UnitDatabaseFields>().movementFactor; if (unit.GetComponent <UnitDatabaseFields>().occupiedHex != null) { GlobalDefinitions.UnhighlightUnit(unit.gameObject); GeneralHexRoutines.RemoveUnitFromHex(unit.gameObject, unit.GetComponent <UnitDatabaseFields>().occupiedHex); unit.GetComponent <UnitDatabaseFields>().occupiedHex = null; } removeUnitList.Add(unit.gameObject); } foreach (GameObject unit in removeUnitList) { GlobalDefinitions.ReturnUnitToOOBShet(unit); } // Clear out the lists keeping track of both side's units on board GlobalDefinitions.alliedUnitsOnBoard.Clear(); GlobalDefinitions.germanUnitsOnBoard.Clear(); // Go through the hexes and reset all highlighting foreach (GameObject hex in HexDefinitions.allHexesOnBoard) { hex.GetComponent <HexDatabaseFields>().riverInterdiction = false; hex.GetComponent <HexDatabaseFields>().closeDefenseSupport = false; hex.GetComponent <HexDatabaseFields>().successfullyInvaded = false; hex.GetComponent <HexDatabaseFields>().alliedControl = false; hex.GetComponent <HexDatabaseFields>().inAlliedZOC = false; hex.GetComponent <HexDatabaseFields>().inGermanZOC = false; hex.GetComponent <HexDatabaseFields>().occupyingUnit.Clear(); hex.GetComponent <HexDatabaseFields>().unitsExertingZOC.Clear(); hex.GetComponent <HexDatabaseFields>().availableForMovement = false; hex.GetComponent <HexDatabaseFields>().strategicRemainingMovement = 0; hex.GetComponent <HexDatabaseFields>().remainingMovement = 0; hex.GetComponent <HexDatabaseFields>().supplySources.Clear(); hex.GetComponent <HexDatabaseFields>().unitsThatCanBeSupplied.Clear(); hex.GetComponent <HexDatabaseFields>().closeDefenseSupport = false; hex.GetComponent <HexDatabaseFields>().riverInterdiction = false; hex.GetComponent <HexDatabaseFields>().carpetBombingActive = false; GlobalDefinitions.UnhighlightHex(hex.gameObject); } GlobalDefinitions.WriteToLogFile("Putting Allied units in Britain"); // When restarting a game the units won't have their Britain location loaded so this needs to be done before a restart file is read GameControl.createBoardInstance.GetComponent <CreateBoard>().ReadBritainPlacement(GlobalGameFields.britainUnitLocationFile); GlobalDefinitions.ResetAllGlobalDefinitions(); // Turn the button back on GlobalDefinitions.mainMenuButton.GetComponent <Button>().interactable = true; MainMenuRoutines.GetGameModeUI(); }
/// <summary> /// This routine gets an invading unit from Britain /// </summary> /// <returns></returns> public GameObject GetInvadingUnit(GameObject selectedUnit) { GlobalDefinitions.WriteToLogFile("getInvadingUnit: executing for unit = " + selectedUnit.name); // Check for valid unit if (selectedUnit == null) { GlobalDefinitions.GuiUpdateStatusMessage("No unit selected; select a unit in Britain that is available to invade this turn"); } // Check if the unit is on a sea hex, this would make it a unit that has already been deployed for an invasion // The user may be picking it in order to undo the selection. else if ((selectedUnit.GetComponent <UnitDatabaseFields>().occupiedHex != null) && (selectedUnit.GetComponent <UnitDatabaseFields>().occupiedHex.GetComponent <HexDatabaseFields>().sea)) { // Hghlight the unit GlobalDefinitions.HighlightUnit(selectedUnit); return(selectedUnit); } // If the unit selected isn't in Britain than display the units in the gui else if (!selectedUnit.GetComponent <UnitDatabaseFields>().inBritain) { if (selectedUnit.GetComponent <UnitDatabaseFields>().occupiedHex != null) { GlobalDefinitions.GuiDisplayUnitsOnHex(selectedUnit.GetComponent <UnitDatabaseFields>().occupiedHex); } } else if (selectedUnit.GetComponent <UnitDatabaseFields>().HQ) { GlobalDefinitions.GuiUpdateStatusMessage("HQ units are not allowed to invade"); } else if (selectedUnit.GetComponent <UnitDatabaseFields>().turnAvailable > GlobalDefinitions.turnNumber) { GlobalDefinitions.GuiUpdateStatusMessage("Unit selected is not available until turn " + selectedUnit.GetComponent <UnitDatabaseFields>().turnAvailable); } else { // Check if the unit is available for the first invasion area if (GlobalDefinitions.turnNumber == 1) { if (GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].totalUnitsUsedThisTurn < ReturnMaxTotalUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex])) { if (selectedUnit.GetComponent <UnitDatabaseFields>().armor) { if (GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].armorUnitsUsedThisTurn < ReturnMaxArmorUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex])) { // Valid unit so highlight the hexes available in the invasion area GlobalDefinitions.HighlightUnit(selectedUnit); HighlightAvailableInvasionHexes(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex]); return(selectedUnit); } } else if (selectedUnit.GetComponent <UnitDatabaseFields>().infantry || selectedUnit.GetComponent <UnitDatabaseFields>().airborne) { //GlobalDefinitions.writeToLogFile("getInvadingUnit: infantry units used this turn = " + GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].infantryUnitsUsedThisTurn); //GlobalDefinitions.writeToLogFile("getInvadingUnit: max infantry units this turn = " + returnMaxInfantryUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex])); // Need to check for using infantry against the armor limit if ((GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].infantryUnitsUsedThisTurn < ReturnMaxInfantryUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex])) || (GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex].armorUnitsUsedThisTurn < ReturnMaxArmorUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex]))) { // Valid unit so highlight the hexes available in the invasion area GlobalDefinitions.HighlightUnit(selectedUnit); HighlightAvailableInvasionHexes(GlobalDefinitions.invasionAreas[GlobalDefinitions.firstInvasionAreaIndex]); return(selectedUnit); } } else { // Don't know why we would ever get here but if we do return a null GlobalDefinitions.GuiUpdateStatusMessage("Internal Error - Selected unit is not recognized as armor, infantry, or airborne"); } } } else { // Need to check the second invasion area if (GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].totalUnitsUsedThisTurn < ReturnMaxTotalUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex])) { if (selectedUnit.GetComponent <UnitDatabaseFields>().armor) { if (GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].armorUnitsUsedThisTurn < ReturnMaxArmorUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex])) { // Valid unit so highlight the hexes available in the invasion area GlobalDefinitions.HighlightUnit(selectedUnit); HighlightAvailableInvasionHexes(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex]); return(selectedUnit); } } else if (selectedUnit.GetComponent <UnitDatabaseFields>().infantry || selectedUnit.GetComponent <UnitDatabaseFields>().airborne) { // Need to check for using infantry against the armor limit if ((GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].infantryUnitsUsedThisTurn < ReturnMaxInfantryUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex])) || (GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex].armorUnitsUsedThisTurn < ReturnMaxArmorUnitsForInvasionAreaThisTurn(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex]))) { // Valid unit so highlight the hexes available in the invasion area GlobalDefinitions.HighlightUnit(selectedUnit); HighlightAvailableInvasionHexes(GlobalDefinitions.invasionAreas[GlobalDefinitions.secondInvasionAreaIndex]); return(selectedUnit); } } } } } return(null); }