void Start()
{
//get the lobby manager script
LobbyMgr = FindObjectOfType(typeof(NetworkMapManager)) as NetworkMapManager;
//if it's a local player:
if (isLocalPlayer)
{
//set the local faction
SetupLocalFaction();
CmdAddPlayerToList();
}
else
{
//if it's not the local player:
SetupOtherFaction();
}
SetObjParent(); //set the lobby info object's parent.
if (FactionID == 0) //checking if this is the host's faction
//make sure that the kick button is not activated and that the host can't announce he's ready or not, only him can launch the game when all other players are ready.
{
ReadyToBeginButton.SetActive(false);
KickButton.SetActive(false);
}
//Show the kick buttons for the server only:
if (!isServer)
{
KickButton.SetActive(false);
}
}
void Start()
{
NetworkMapMgr = FindObjectOfType(typeof(NetworkMapManager)) as NetworkMapManager;
}
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.
}
