public override void Refresh()
{
foreach (var projectRecord in new List <CityProjectRecord>(InstantiatedProjectRecords))
{
Destroy(projectRecord.gameObject);
}
InstantiatedProjectRecords.Clear();
if (ObjectToDisplay == null)
{
return;
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(ObjectToDisplay);
if (DisplayType == CityDisplayType.PlayMode)
{
AddUnitProjects(cityOwner);
AddBuildingProjects(
cityOwner, TechCanon.GetResearchedBuildings(cityOwner),
template => ObjectToDisplay.ActiveProject = ProjectFactory.ConstructProject(template)
);
}
else if (DisplayType == CityDisplayType.MapEditor)
{
AddBuildingProjects(
cityOwner, AllBuildingTemplates,
template => BuildingFactory.BuildBuilding(template, ObjectToDisplay)
);
}
}
private void OnCityGainedBuilding(Tuple <ICity, IBuilding> data)
{
var city = data.Item1;
var buildingTemplate = data.Item2.Template;
foreach (var freeTemplate in buildingTemplate.FreeBuildings)
{
if (BuildingValidityLogic.IsTemplateValidForCity(freeTemplate, city))
{
BuildingFactory.BuildBuilding(freeTemplate, city);
}
}
}
public void ApplyFreeBuildingToCity(IEnumerable <IBuildingTemplate> validTemplates, ICity city)
{
foreach (var template in validTemplates)
{
if (BuildingProductionValidityLogic.IsTemplateValidForCity(template, city))
{
BuildingFactory.BuildBuilding(template, city);
BestowedFreeBuildingsOfCity[city].Add(template);
return;
}
}
}
public void DecomposeBuildings(SerializableMapData mapData)
{
foreach (var buildingData in mapData.Buildings)
{
var templateToBuild = AllBuildingTemplates.Where(template => template.name.Equals(buildingData.Template)).First();
var cellAtCoords = Grid.GetCellAtCoordinates(buildingData.CityLocation);
var cityAtLocation = CityLocationCanon.GetPossessionsOfOwner(cellAtCoords).First();
var newBuilding = BuildingFactory.BuildBuilding(templateToBuild, cityAtLocation);
for (int i = 0; i < newBuilding.Slots.Count; i++)
{
var slot = newBuilding.Slots[i];
slot.IsOccupied = buildingData.IsSlotOccupied[i];
slot.IsLocked = buildingData.IsSlotLocked [i];
}
}
}
public void Execute(ICity targetCity)
{
if (BuildingToConstruct != null)
{
BuildingFactory.BuildBuilding(BuildingToConstruct, targetCity);
}
else
{
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(targetCity);
var cityLocation = CityLocationCanon.GetOwnerOfPossession(targetCity);
var newUnit = UnitFactory.BuildUnit(cityLocation, UnitToConstruct, cityOwner);
newUnit.Experience = StartingExperienceLogic.GetStartingExperienceForUnit(newUnit, targetCity);
foreach (var promotion in LocalPromotionLogic.GetLocalPromotionsForCity(targetCity))
{
newUnit.PromotionTree.AppendPromotion(promotion);
}
}
}
public void SetCapitalOfCiv(ICivilization civ, ICity newCapital)
{
if (civ == null)
{
throw new ArgumentNullException("civ");
}
if (!CanSetCapitalOfCiv(civ, newCapital))
{
throw new InvalidOperationException("CanSetCapitalOfCiv must return true on the given arguments");
}
ICity oldCapital;
CapitalDictionary.TryGetValue(civ, out oldCapital);
if (oldCapital != null)
{
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(oldCapital).ToArray())
{
if (CityConfig.CapitalTemplates.Contains(building.Template))
{
BuildingFactory.DestroyBuilding(building);
}
}
}
CapitalDictionary[civ] = newCapital;
if (newCapital != null)
{
var templatesInCapital = BuildingPossessionCanon.GetPossessionsOfOwner(newCapital).Select(building => building.Template);
foreach (var template in CityConfig.CapitalTemplates.Except(templatesInCapital))
{
BuildingFactory.BuildBuilding(template, newCapital);
}
}
}