void Start()
{
GameMgr = GameManager.Instance;
SelectionMgr = GameMgr.SelectionMgr;
PlacementMgr = GameMgr.PlacementMgr;
UIMgr = GameMgr.UIMgr;
ResourceMgr = GameMgr.ResourceMgr;
}
void Awake()
{
//one instance of this component per map
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(instance);
}
IsBuilding = false;
//find the scripts that we will need:
GameMgr = GameManager.Instance;
ResourceMgr = GameMgr.ResourceMgr;
SelectionMgr = GameMgr.SelectionMgr;
TerrainMgr = GameMgr.TerrainMgr;
}
public Color AttackSelectionColor = Color.red; //The color of the selection texture that will be flashed around the target unit/building that was chosen by the player to attack.
void Awake()
{
//set the instance:
if (Instance == null)
{
Instance = this;
}
else if (Instance != this)
{
Destroy(gameObject);
}
//Randomize player controlled faction:
RandomizePlayerFaction();
Time.timeScale = 1.0f; //In case it was not 1.0f in a previous scene.
CamMov = FindObjectOfType(typeof(CameraMovement)) as CameraMovement; //Find the camera movement script.
ResourceMgr = FindObjectOfType(typeof(ResourceManager)) as ResourceManager; //Find the resource manager script.
if (ResourceMgr != null)
{
ResourceMgr.GameMgr = this;
}
UIMgr = FindObjectOfType(typeof(UIManager)) as UIManager; //Find the UI manager script.
BuildingMgr = FindObjectOfType(typeof(BuildingPlacement)) as BuildingPlacement;
Events = FindObjectOfType(typeof(CustomEvents)) as CustomEvents;
TaskMgr = FindObjectOfType(typeof(TaskManager)) as TaskManager;
if (TaskMgr != null)
{
TaskMgr.GameMgr = this;
}
UnitMgr = FindObjectOfType(typeof(UnitManager)) as UnitManager;
SelectionMgr = FindObjectOfType(typeof(SelectionManager)) as SelectionManager;
PlacementMgr = FindObjectOfType(typeof(BuildingPlacement)) as BuildingPlacement;
MultiplayerGame = false; //We start by assuming it's a simple single player game.
//First check if there's a network manager component in the scene:
NetworkMgr = FindObjectOfType(typeof(NetworkMapManager)) as NetworkMapManager;
if (NetworkMgr != null) //If there's actually a network map manager, it means that the map was loaded from the multiplayer menu, meaning that this is a MP game.
{
ClearNPCManagers(); //clearing all the npc components in the map since it's a MP game.
MultiplayerGame = true; //we now recongize that this a multiplayer game.
//First we will search for all the lobby objects that held the info for the factions
MFactionsInfo = FindObjectsOfType(typeof(MFactionLobbyInfo)) as MFactionLobbyInfo[];
//This where we will set the settings for all the players:
//First check if we have enough faction slots available:
if (MFactionsInfo.Length <= Factions.Count)
{
//Loop through all the current factions and set up each faction slot:
for (int i = 0; i < MFactionsInfo.Length; i++)
{
MFactionLobbyInfo ThisFaction = NetworkMgr.lobbySlots [i].GetComponent <MFactionLobbyInfo> (); //this is the faction info that we will get from the faction lobby info.
//Set the info for the factions that we will use:
Factions [i].Name = ThisFaction.FactionName; //get the faction name
Factions [i].FactionColor = ThisFaction.FactionColor; //the faction color
//get the initial max population from the network manager (making it the same for all the players).
Factions [i].MaxPopulation = NetworkMgr.Maps[ThisFaction.MapID].InitialPopulation;
Factions [i].Lost = false;
Factions [i].MFactionLobby = ThisFaction; //linking the faction with its lobby info script.
Factions [i].CapitalPos = Factions [i].CapitalBuilding.transform.position; //setting the capital pos to spawn the capital building object at later.
Factions [i].FactionMgr = Factions [i].FactionMgr; //linking the faction with its faction manager.
Factions [i].Code = ThisFaction.FactionCode;
//Setting the local player faction ID:
if (ThisFaction.isLocalPlayer) //isLoclPlayer determines which lobby faction info script is owned by the player..
//therefore the faction linked to that script is the player controlled one.
{
PlayerFactionID = i;
Factions [i].PlayerControl = true;
PlayerFactionMgr = Factions [i].FactionMgr;
}
else
{
//all other factions will be defined as NPC but in the reality, they are controlled by other players through the network.
Factions [i].PlayerControl = false;
}
}
//loop through all the factions and destroy the default capital buildings because the server will spawn new ones for each faction.
for (int i = 0; i < Factions.Count; i++)
{
DestroyImmediate(Factions [i].CapitalBuilding.gameObject);
}
//if there are more slots than required.
while (MFactionsInfo.Length < Factions.Count)
{
//remove the extra slots:
Factions.RemoveAt(Factions.Count - 1);
}
}
else
{
Debug.LogError("Not enough slots available for all the factions!");
}
}
MapMgr = FindObjectOfType(typeof(MapManager)) as MapManager; //search for the map manager script.
//If there's a map manager script in the scene, it means that we just came from the single player menu, so we need to set the NPC players settings!
if (MapMgr != null)
{
//This where we will set the NPC settings using the info from the map manager:
//First check if we have enough faction slots available:
if (MapMgr.Factions.Count <= Factions.Count)
{
ClearNPCManagers(); //remove the current npc managers as they will be replaced by other ones.
//loop through the factions slots of this map:
for (int i = 0; i < MapMgr.Factions.Count; i++)
{
//Set the info for the factions that we will use:
Factions [i].Name = MapMgr.Factions[i].FactionName; //name
Factions [i].FactionColor = MapMgr.Factions [i].FactionColor; //color
Factions [i].PlayerControl = MapMgr.Factions [i].ControlledByPlayer; //is this faction controlled by the player?
Factions [i].MaxPopulation = MapMgr.Factions [i].InitialPopulation; //initial maximum population (which can be increased in the game).
Factions [i].Code = MapMgr.Factions[i].FactionCode; //the faction's code.
Factions [i].CapitalPos = Factions [i].CapitalBuilding.transform.position; //setting the capital pos to spawn the capital building object at later.
Factions [i].Lost = false;
int FactionTypeID = GetFactionTypeID(Factions [i].Code);
if (FactionTypeID >= 0 && FactionDef [FactionTypeID].CapitalBuilding != null) //if the faction to a certain type
{
DestroyImmediate(Factions [i].CapitalBuilding.gameObject); //destroy the default capital and spawn another one:
//we will spawn the capital building and remove the one that already came in the scene:
GameObject Capital = Instantiate(FactionDef[FactionTypeID].CapitalBuilding.gameObject);
//set the capital's settings:
Capital.GetComponent <Building> ().FactionID = i;
Capital.GetComponent <Building> ().FactionCapital = true;
Capital.GetComponent <Building> ().PlacedByDefault = true;
Capital.transform.position = Factions [i].CapitalPos; //set the capital's position on the map.
Factions [i].CapitalBuilding = Capital.GetComponent <Building> ();
}
//if this faction not controlled by the player
if (Factions [i].PlayerControl == false)
{
//Spawn the NPC managers setinngs for this faction:
GameObject NPCMgrObj = (GameObject)Instantiate(MapMgr.DifficultyLevels[MapMgr.Factions[i].NPCDifficulty], Vector3.zero, Quaternion.identity);
//NPC Army manager:
NPCMgrObj.GetComponent <NPCArmy> ().FactionID = i;
NPCMgrObj.GetComponent <NPCArmy> ().FactionMgr = Factions [i].FactionMgr;
Factions [i].FactionMgr.ArmyMgr = NPCMgrObj.GetComponent <NPCArmy> ();
//NPC Building placement manager:
NPCMgrObj.GetComponent <NPCBuildingPlacement> ().FactionID = i;
NPCMgrObj.GetComponent <NPCBuildingPlacement> ().FactionMgr = Factions [i].FactionMgr;
Factions [i].FactionMgr.BuildingMgr = NPCMgrObj.GetComponent <NPCBuildingPlacement> ();
//NPC Resource manager:
NPCMgrObj.GetComponent <NPCResource> ().FactionID = i;
NPCMgrObj.GetComponent <NPCResource> ().FactionMgr = Factions [i].FactionMgr;
Factions [i].FactionMgr.ResourceMgr = NPCMgrObj.GetComponent <NPCResource> ();
//NPC Unit spawner: (optional)
if (NPCMgrObj.GetComponent <NPCUnitSpawner> ())
{
NPCMgrObj.GetComponent <NPCUnitSpawner> ().FactionID = i;
NPCMgrObj.GetComponent <NPCUnitSpawner> ().FactionMgr = Factions [i].FactionMgr;
Factions [i].FactionMgr.UnitSpawner = NPCMgrObj.GetComponent <NPCUnitSpawner> ();
}
}
}
//if there are more slots than required.
while (MapMgr.Factions.Count < Factions.Count)
{
//remove the extra slots:
DestroyImmediate(Factions [Factions.Count - 1].CapitalBuilding.gameObject);
Factions.RemoveAt(Factions.Count - 1);
}
}
else
{
Debug.LogError("Not enough slots available for all the factions!");
}
//Destroy the map manager script because we don't really need it anymore:
DestroyImmediate(MapMgr.gameObject);
}
//If it's a multiplayer game, we still need to figure what's the local player faction ID.
if (MultiplayerGame == false)
{
PlayerFactionID = -1;
}
if (Factions.Count > 0)
{
//Create as many resource info slots as the amount of the spawned factions.
ResourceMgr.FactionResourcesInfo = new ResourceManager.FactionResourcesVars[Factions.Count];
//Loop through all the factions:
for (int i = 0; i < Factions.Count; i++)
{
//if it's not a multiplayer game:
if (MultiplayerGame == false)
{
//and this faction is controlled by the player:
if (Factions [i].PlayerControl == true)
{
//then define this as the player faction:
PlayerFactionID = i;
PlayerFactionMgr = Factions [i].FactionMgr;
}
}
//Only if it's a single player game we will be checking if the capital buildings have spawned, because in multiplayer, another script handles spawning these
if (MultiplayerGame == false)
{
if (Factions [i].CapitalBuilding == null)
{
Debug.LogError("Faction ID: " + i + " is missing the 'Capital Building'");
}
else
{
Factions [i].CapitalBuilding.FactionID = i;
Factions [i].CapitalBuilding.FactionCapital = true;
}
}
ResourceMgr.FactionResourcesInfo[i] = new ResourceManager.FactionResourcesVars();
//Associate each team with all available resources:
ResourceMgr.FactionResourcesInfo[i].ResourcesTypes = new ResourceManager.ResourcesVars[ResourceMgr.ResourcesInfo.Length];
//Loop through all the available resources and define them for each team.
for (int j = 0; j < ResourceMgr.FactionResourcesInfo[i].ResourcesTypes.Length; j++)
{
ResourceMgr.FactionResourcesInfo[i].ResourcesTypes[j] = new ResourceManager.ResourcesVars();
ResourceMgr.FactionResourcesInfo[i].ResourcesTypes[j].Name = ResourceMgr.ResourcesInfo[j].Name; //Name of the resource
ResourceMgr.FactionResourcesInfo[i].ResourcesTypes[j].Amount = ResourceMgr.ResourcesInfo[j].StartingAmount; //Starting amount of the resource for each team.
}
}
}
ResourceMgr.UpdateResourcesUI(); //right after setting up the resource settings above, refresh the resource UI.
//In order to avoid having buildings that are being placed by AI players and units collide, we will ignore physics between their two layers:
Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Hidden"), LayerMask.NameToLayer("Unit"));
//Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Unit"), LayerMask.NameToLayer("Unit"));
if (PeaceTime <= 0.0f)
{
//If there's no peace make factions pick their targets early:
SetFactionTargets();
}
//Set the amount of the active factions:
ActiveFactions = Factions.Count;
GameEnded = false; //false, of course, we just started.
}
public AudioSource GeneralAudioSource; //The audio source where audio will be played generally unless the audio is local. In that case, it will be played
void Awake()
{
//set the instance:
if (Instance == null)
{
Instance = this;
}
else if (Instance != this)
{
Destroy(gameObject);
}
Time.timeScale = 1.0f; //unfreeze game if it was frozen from a previous game.
allFactionsReady = false; //faction stats are not ready, yet
//Randomize player controlled faction:
RandomizePlayerFaction();
//Get components:
CamMov = FindObjectOfType(typeof(CameraMovement)) as CameraMovement; //Find the camera movement script.
ResourceMgr = FindObjectOfType(typeof(ResourceManager)) as ResourceManager; //Find the resource manager script.
if (ResourceMgr != null)
{
ResourceMgr.gameMgr = this;
}
UIMgr = FindObjectOfType(typeof(UIManager)) as UIManager; //Find the UI manager script.
BuildingMgr = FindObjectOfType(typeof(BuildingPlacement)) as BuildingPlacement;
Events = FindObjectOfType(typeof(CustomEvents)) as CustomEvents;
TaskMgr = FindObjectOfType(typeof(TaskManager)) as TaskManager;
UnitMgr = FindObjectOfType(typeof(UnitManager)) as UnitManager;
SelectionMgr = FindObjectOfType(typeof(SelectionManager)) as SelectionManager;
PlacementMgr = FindObjectOfType(typeof(BuildingPlacement)) as BuildingPlacement;
TerrainMgr = FindObjectOfType(typeof(TerrainManager)) as TerrainManager;
MvtMgr = FindObjectOfType(typeof(MovementManager)) as MovementManager;
MultiplayerGame = false; //We start by assuming it's a single player game.
InitFactionMgrs(); //create the faction managers components for the faction slots.
InitMultiplayerGame(); //to initialize a multiplayer game.
InitSinglePlayerGame(); //to initialize a single player game.
SetPlayerFactionID(); //pick the player faction ID.
InitFactionCapitals(); //init the faction capitals.
ResourceMgr.InitFactionResources(); //init resources for factions.
InitFactions(); //init the faction types.
//In order to avoid having buildings that are being placed by AI players and units collide, we will ignore physics between their two layers:
Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Hidden"), LayerMask.NameToLayer("Unit"));
//Set the amount of the active factions:
activeFactionsAmount = Factions.Count;
GameState = GameStates.Running; //the game state is now set to running
//reaching this point means that all faction info/stats in the game manager are ready:
allFactionsReady = true;
}