public void selectCityHall()
{
selectedBuilding = cityHall;
buildingType = Building.BuildingType.CityHall;
action = true;
removing = false;
}
public void CheckBuilding(Building building)
{
Building.BuildingType bType = building.myBuildingType;
switch (bType)
{
case Building.BuildingType.house:
// apply Special House bonuses
break;
case Building.BuildingType.defense:
// add Soldier class
AddSurvivorClass(SurvivorClass.soldier);
break;
case Building.BuildingType.food:
AddSurvivorClass(SurvivorClass.farmer);
break;
case Building.BuildingType.workshop:
AddSurvivorClass(SurvivorClass.scientist);
break;
default:
print("Building of this type NOT FOUND!");
break;
}
}
public void selectHome()
{
selectedBuilding = home;
buildingType = Building.BuildingType.Home;
action = true;
removing = false;
}
public bool correctPlacement(BuildingPlatformController bpc)
{
foreach (SolutionItem si in solutions)
{
if (si.platform.Equals(bpc))
{
// If it is found, the correct type of building and upgrade should have been placed
Upgrade.UpgradeType uType = Upgrade.UpgradeType.None;
if (si.platform.upgrade != null)
{
uType = si.platform.upgrade.type;
}
Building.BuildingType bType = Building.BuildingType.None;
if (si.platform.building != null)
{
bType = si.platform.building.type;
}
if (si.upgrade == uType && si.building == bType)
{
return(true);
}
return(false);
}
}
// If it isn't defined as solution, it should be empty
if ((bpc.building == null || bpc.building.type == Building.BuildingType.None) &&
(bpc.upgrade == null || bpc.upgrade.type == Upgrade.UpgradeType.None))
{
return(true);
}
return(false);
}
public void OnBuild(GameObject building, Building.BuildingType buildingtype)
{
Debug.Log(buildingtype.ToString());
if (buildingtype == Building.BuildingType.House)
{
House house = building.GetComponent <House>();
MaxPopulation += house.Room;
es.MaxEnemies++;
buildings.Add(house);
HouseNumber++;
}
if (buildingtype == Building.BuildingType.Post)
{
Debug.Log("WTF4");
Towers.Add(building);
}
if (buildingtype == Building.BuildingType.TownCenter)
{
TownCenter = building;
}
if (buildingtype == Building.BuildingType.ResourceStorage)
{
buildings.Add(building.GetComponent <StorageArea>());
}
}
public void SetSelectedLocation(Location loc)
{
selectedLocation = loc;
selectedBuildingType = Building.BuildingType.Unassigned;
UIController.Instance.RefreshUI();
UIController.Instance.exploreUI.SwitchLocation();
}
public void ClickTile(Vector3Int position)
{
for (int i = 0; i < constructableGrid.Count; i++)
{
if (constructableGrid[i].Contains(position))
{
/// Prevent from immediately showing Building Information Panel after build.
Resources.FindObjectsOfTypeAll <BuildingShopPanel>()[0].gameObject.SetActive(false);
MainCanvas.FreezeCamera = true;
StartCoroutine(DelaySetCanvasActive(false));
/// -------------------------------------------------------------------------------
Vector2 adjustedPosition = CalculateBuildPosition(i);
Building.BuildingType type = (Building.BuildingType)Enum.Parse(typeof(Building.BuildingType), SelectedBuildingName);
Action <int> callback = (teamNumber) =>
{
TeamSelectorCallback(type, teamNumber, adjustedPosition, i);
};
Builder builder = new Builder(type);
ShowTeamSelectorPanel(builder, callback);
return;
}
}
}
public Builder(Building.BuildingType type, Vector3 pos, int level, GameObject representGameObject, Construction constructionStatus)
{
this.id = GenerateID();
this.type = type;
this.position = pos;
this.representGameObject = representGameObject;
this.level = level;
this.constructionStatus = constructionStatus;
InitializeData();
}
public void SetStatsText(Building.BuildingType type, int current, int next, string descr)
{
string damage = type == Building.BuildingType.Tower ? "damage" : "production";
string text = "Curent " + damage + ": " + current
+ "\nNext level " + damage + ": " + next;
_damageText.text = next > 0 ? _damageText.text = text : _damageText.text = String.Empty;
_descrText.text = descr;
}
public bool IsBuildingInProgress(Building.BuildingType buildingType)
{
foreach (Building building in unfinishedBuildings)
{
if (building.Type == buildingType)
{
return(true);
}
}
return(false);
}
void TeamSelectorCallback(Building.BuildingType type, int teamNumber, Vector2 position, int removingTileIndex)
{
if (BuildManager.Instance.CreateNewBuilding(type, teamNumber, position))
{
constructableGrid.RemoveAt(removingTileIndex);
}
buildPermission = false;
CancleShowAvailableTiles();
return;
}
void TeamSelectorCallback(Building.BuildingType type, int teamNumber, Vector2 position, int removingTileIndex)
{
if (BuildingManager.Instance.CreateNewBuilding(type, teamNumber, position))
{
constructableGrid.RemoveAt(removingTileIndex);
}
buildPermission = false;
CancleShowAvailableTiles();
GameManager.FindInActiveObjectByName("GUICanvas").SetActive(true);
return;
}
public bool AddBuilding(string name, GameObject go, Building.BuildingType t) //returns true if can add person else returns false
{
if (buildings.Count < _maxBuildings)
{
buildings.Add(new Building(name, go, t));
return(true);
}
else
{
return(false);
}
}
public Builder(Building.BuildingType type, Vector3 pos)
{
this.id = GenerateID();
this.type = type;
this.position = pos;
this.level = 0;
this.constructionStatus = new Construction {
isConstructing = true, constructPointRequired = 10
};
InitializeData();
}
public void SetClickedBuildingText(Building.BuildingType type)
{
string line1 = "Building Type: " + type + "\n";
string line2 = "" + "\n";
string line3 = "" + "\n";
string line4 = "" + "\n";
string line5 = "" + "\n";
string line6 = "" + "\n";
string line7 = "" + "\n";
layoutClickedText.text = line1 + line2 + line3 + line4 + line5 + line6 + line7;
}
public void undo(Building.BuildingType bt)
{
// for each buttons, if it equal bt then increment
for (int i = 0; i < buildingItems.Count; i++)
{
if (bt.Equals(buildingItems[i].prefab.type))
{
amountTexts[i].text = (int.Parse(amountTexts[i].text) + 1) + "";
return;
}
}
}
public List <Production> GetProductionAvailable(Building.BuildingType _type)
{
List <Production> retour = new List <Production>();
foreach (Schematic schem in unlocks)
{
if (schem.type == _type)
{
retour.Add(schem.production);
}
}
return(retour);
}
//Updates the resource upkeep of all buildings
void UpdateEconomyTick()
{
//income
_money += 100 * population_count;
//upkeep cost
foreach (var building_prefab in _buildingPrefabs)
{
Building.BuildingType type = building_prefab.GetComponent <Building>().type;
int upkeep = building_prefab.GetComponent <Building>().upkeep;
_money -= _buildingInstances[type] * upkeep;
}
}
public void onDestroy(GameObject building, Building.BuildingType buildingtype)
{
if (buildingtype == Building.BuildingType.House)
{
MaxPopulation -= building.GetComponent <House>().Room;
es.MaxEnemies--;
houses.Remove(building);
}
if (buildingtype == Building.BuildingType.Post)
{
Towers.Remove(building);
}
}
public int GetLevel(Building.BuildingType type)
{
int level = 0;
switch (type)
{
case Building.BuildingType.Main:
level = iMainLevel;
break;
case Building.BuildingType.GoldMine:
level = iGoldMineLevel;
break;
case Building.BuildingType.Farm:
level = iFarmLevel;
break;
case Building.BuildingType.Sawmill:
level = iSawmillLevel;
break;
case Building.BuildingType.Quarry:
level = iQuarryLevel;
break;
case Building.BuildingType.Archery:
level = iArcheryLevel;
break;
case Building.BuildingType.Barracks:
level = iBarracksLevel;
break;
case Building.BuildingType.Guard:
level = iGuardLevel;
break;
case Building.BuildingType.Storage:
level = iStorageLevel;
break;
case Building.BuildingType.Blacksmith:
level = iBlacksmithLevelLevel;
break;
}
return(level);
}
public bool CreateNewBuilding(Building.BuildingType type, int teamNumber, Vector2 position)
{
Builder laborCenter = allBuildings.SingleOrDefault(b => b.Type == Building.BuildingType.LaborCenter);
if ((laborCenter == null || laborCenter.Level == 0) && gameObject.transform.Find("TimerCanvas").childCount >= 1)
{
Debug.LogWarning("Please Create LaborCenter to perform more Building task !");
return(false);
}
if (!ConsumeBuildingCost(new Builder(type)))
{
Debug.LogWarning("Upgrade failed : Not enough Resources for upgrading");
return(false);
}
Builder builder = new Builder(type, position);
Building buildData = LoadManager.Instance.allBuildingData[builder.Type];
builder.constructionStatus = new Builder.Construction {
teamNumber = teamNumber, constructPointRequired = buildData.upgradePoint[builder.Level], isConstructing = true
};
InitiateBuilding(builder);
if (laborCenter != null)
{
laborCenter.TeamLockState.Add(teamNumber);
}
NotificationManager.Instance.AddActivity(new ActivityInformation()
{
activityName = $"CreateBuilding:{builder.Type}:{builder.ID}",
activityType = ActivityType.Build,
teamNumber = teamNumber,
builderReferenceID = laborCenter.ID,
requiredPoint = buildData.upgradePoint[builder.Level],
informationID = builder.ID
});
EventManager.Instance.BuildingModified(builder.ID);
Debug.Log("Create action complete.");
LoadManager.Instance.SavePlayerDataToFireBase();
return(true);
}
public void SetLevel(Building.BuildingType type, int level)
{
switch (type)
{
case Building.BuildingType.Main:
iMainLevel = level;
break;
case Building.BuildingType.GoldMine:
iGoldMineLevel = level;
break;
case Building.BuildingType.Farm:
iFarmLevel = level;
break;
case Building.BuildingType.Sawmill:
iSawmillLevel = level;
break;
case Building.BuildingType.Quarry:
iQuarryLevel = level;
break;
case Building.BuildingType.Archery:
iArcheryLevel = level;
break;
case Building.BuildingType.Barracks:
iBarracksLevel = level;
break;
case Building.BuildingType.Guard:
iGuardLevel = level;
break;
case Building.BuildingType.Storage:
iStorageLevel = level;
break;
case Building.BuildingType.Blacksmith:
iBlacksmithLevelLevel = level;
break;
}
}
public void RefreshPanel()
{
if (gameObject.activeSelf == false)
{
return;
}
Debug.Log("Refreshing Building Shop Panel . . .");
Transform container = transform.Find("BackGroundPanel/Container");
foreach (Transform buttonTranform in container)
{
Button button = buttonTranform.GetComponent <Button>();
button.interactable = true;
Building.BuildingType type = (Building.BuildingType)Enum.Parse(typeof(Building.BuildingType), button.name.Replace(":ShopButton", ""));
Builder builder = BuildingManager.Instance.AllBuildings.FirstOrDefault(b => b.Type == type);
Building buildingData = LoadManager.Instance.allBuildingData[type];
if (builder != default(Builder))
{
button.transform.Find("Information/Amount").GetComponent <Text>().text = $"{builder.CurrentActiveAmount}/{builder.maxActiveAmount}";
if (builder.CurrentActiveAmount == builder.maxActiveAmount)
{
button.interactable = false;
}
}
else
{
button.transform.Find("Information/Amount").GetComponent <Text>().text = $"0/{buildingData.maxActiveAmount}";
}
if (!ItemManager.Instance.IsAffordable(buildingData.buildingCost[0]))
{
button.image.color = new Color(1f, 0.5f, 0.5f, 1f);
button.interactable = false;
}
else
{
button.image.color = Color.white;
}
}
}
public void ForceCreateBuilding(Building.BuildingType type, int cellIndex)
{
MapManager mapManager = MapManager.Instance;
var position = mapManager.CalculateBuildPosition(cellIndex);
Builder builder = new Builder(type, position);
Building buildData = LoadManager.Instance.allBuildingData[builder.Type];
builder.constructionStatus = new Builder.Construction()
{
isConstructing = false
};
builder.Level = 1;
InitiateBuilding(builder);
mapManager.constructableGrid.RemoveAt(cellIndex);
}
void SpawnBuilding(Building.BuildingType buildingType)
{
Building building = null;
Vector2 pos = GenerateValidPosition();
if (pos == Vector2.zero)
{
return;
}
switch (buildingType)
{
case Building.BuildingType.Nexus:
building = Instantiate(Services.Prefabs.Nexus, Services.Main.transform).
GetComponent <Building>();
pos = nexusSpawnPos;
break;
case Building.BuildingType.Mine:
building = Instantiate(Services.Prefabs.Mine, Services.Main.transform).
GetComponent <Building>();
break;
case Building.BuildingType.SpeedBoost:
building = Instantiate(Services.Prefabs.SpeedBooster, Services.Main.transform).
GetComponent <Building>();
break;
case Building.BuildingType.Market:
building = Instantiate(Services.Prefabs.Market, Services.Main.transform).
GetComponent <Building>();
break;
default:
break;
}
building.Init(pos);
buildings.Add(building);
}
public bool hasPassed()
{
foreach (SolutionItem si in solutions)
{
Upgrade.UpgradeType uType = Upgrade.UpgradeType.None;
if (si.platform.upgrade != null)
{
uType = si.platform.upgrade.type;
}
Building.BuildingType bType = Building.BuildingType.None;
if (si.platform.building != null)
{
bType = si.platform.building.type;
}
if (!(si.upgrade == uType && si.building == bType))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Whether the building/upgrade placed here are allowed
/// </summary>
/// <returns></returns>
public bool isCorrect()
{
Building.BuildingType thisBType = Building.BuildingType.None;
if (building != null)
{
thisBType = building.type;
}
Upgrade.UpgradeType thisUType = Upgrade.UpgradeType.None;
if (upgrade != null)
{
thisUType = upgrade.type;
}
foreach (AllowedPlacement ap in allowedPlacements)
{
if ((ap.building == thisBType || ap.building == Building.BuildingType.Any) &&
(ap.upgrade == thisUType || ap.upgrade == Upgrade.UpgradeType.Any))
{
return(true);
}
}
return(thisBType == Building.BuildingType.None && thisUType == Upgrade.UpgradeType.None);
}
public static Building FindNearBuilding(Building.BuildingType typeBuilding, Vector3 currentPosition)
{
if (GameObject.FindObjectsOfType <Building>() == null)
{
return(null);
}
float distanse = float.MaxValue;
Building findBuilding = null;
Building[] buildings = GameObject.FindObjectsOfType <Building>();
for (int i = 0; i < buildings.Length; i++)
{
if (buildings[i].GetBuildingType() == typeBuilding)
{
Vector3 buildingsPosition = buildings[i].gameObject.transform.position;
if (Vector3.Distance(buildingsPosition, currentPosition) < distanse)
{
findBuilding = buildings[i];
distanse = Vector3.Distance(buildingsPosition, currentPosition);
}
}
}
return(findBuilding);
}
public BuildingData(string name, double Price, double Earnings, BasicGeoposition Position, bool Bought, Building.BuildingType Type, DateTime dateTimeAsDate)
{
this.name = name;
this.Price = Price;
this.Earnings = Earnings;
this.Position = Position;
this.Bought = Bought;
this.Type = Type;
this.dateTimeAsString = dateTimeAsDate.ToString();
}
public void SetSelectedBuildingType(Building.BuildingType type)
{
selectedBuildingType = type;
UIController.Instance.RefreshUI();
}
public void BuildBuilding(Building.BuildingType buildingType, Vector2 position)
{
peonObjective = PeonObjective.GoToBuild;
this.buildingType = buildingType;
MoveToLocation(position);
}
