public IBuilding BuildBuilding(IBuildingTemplate template, ICity city)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
else if (city == null)
{
throw new ArgumentNullException("city");
}
var newBuilding = new Building(template);
var slots = new List <IWorkerSlot>();
for (int i = 0; i < template.SpecialistCount; i++)
{
slots.Add(WorkerSlotFactory.BuildSlot(newBuilding));
}
newBuilding.Slots = slots.AsReadOnly();
if (!PossessionCanon.CanChangeOwnerOfPossession(newBuilding, city))
{
throw new BuildingCreationException("The building produced from this template cannot be placed into this city");
}
PossessionCanon.ChangeOwnerOfPossession(newBuilding, city);
allBuildings.Add(newBuilding);
return(newBuilding);
}
public bool IsTemplateValidForCity(IBuildingTemplate template, ICity city, ICivilization cityOwner)
{
if (template.Type != BuildingType.NationalWonder && template.Type != BuildingType.WorldWonder)
{
return(true);
}
var citiesOfOwner = CityPossessionCanon.GetPossessionsOfOwner(cityOwner);
foreach (var otherCity in citiesOfOwner)
{
if (otherCity != city && otherCity.ActiveProject != null && otherCity.ActiveProject.BuildingToConstruct == template)
{
return(false);
}
}
IEnumerable <ICity> citiesToCheck = template.Type == BuildingType.NationalWonder ? citiesOfOwner : CityFactory.AllCities;
foreach (var otherCity in citiesToCheck)
{
var buildingsOf = BuildingPossessionCanon.GetPossessionsOfOwner(otherCity);
if (buildingsOf.Any(building => building.Template == template))
{
return(false);
}
}
return(true);
}
private IBuilding BuildBuilding(IBuildingTemplate template)
{
var mockBuilding = new Mock <IBuilding>();
mockBuilding.Setup(building => building.Template).Returns(template);
return(mockBuilding.Object);
}
private IProductionProject BuildProject(IBuildingTemplate buildingToConstruct)
{
var mockProject = new Mock <IProductionProject>();
mockProject.Setup(project => project.BuildingToConstruct).Returns(buildingToConstruct);
return(mockProject.Object);
}
public ProductionProject(IBuildingTemplate buildingToConstruct, IBuildingFactory buildingFactory)
{
if (buildingToConstruct == null)
{
throw new ArgumentNullException("buildingToConstruct");
}
BuildingToConstruct = buildingToConstruct;
BuildingFactory = buildingFactory;
}
private IProductionProject BuildBuildingProject(
IBuildingTemplate template, int progress, out Mock <IProductionProject> mock
)
{
mock = new Mock <IProductionProject>();
mock.Setup(project => project.BuildingToConstruct).Returns(template);
mock.Setup(project => project.Progress).Returns(progress);
return(mock.Object);
}
public bool IsBuildingResearchedForCiv(IBuildingTemplate template, ICivilization civilization)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
else if (civilization == null)
{
throw new ArgumentNullException("civilization");
}
return(GetResearchedBuildings(civilization).Contains(template));
}
private IProductionProject BuildProject(IBuildingTemplate building, IUnitTemplate unit, int progress)
{
var mockProject = new Mock <IProductionProject>();
mockProject.SetupAllProperties();
mockProject.Setup(project => project.BuildingToConstruct).Returns(building);
mockProject.Setup(project => project.UnitToConstruct).Returns(unit);
var newProject = mockProject.Object;
newProject.Progress = progress;
return(newProject);
}
private bool DoAllCitiesHaveTemplate(IBuildingTemplate template, ICivilization owner)
{
var allCities = CityPossessionCanon.GetPossessionsOfOwner(owner);
foreach (var city in allCities)
{
var templatesOf = BuildingPossessionCanon.GetPossessionsOfOwner(city).Select(building => building.Template);
if (!templatesOf.Contains(template))
{
return(false);
}
}
return(true);
}
/// <inheritdoc/>
public bool IsTemplateValidForCity(IBuildingTemplate template, ICity city)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
else if (city == null)
{
throw new ArgumentNullException("city");
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
return(template.CanBeConstructed &&
BuildingRestrictions.All(restriction => restriction.IsTemplateValidForCity(template, city, cityOwner)));
}
public bool IsTemplateValidForCity(IBuildingTemplate template, ICity city, ICivilization cityOwner)
{
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
if (template.RequiresAdjacentRiver && !RiverCanon.HasRiver(cityLocation))
{
return(false);
}
if (template.RequiresCoastalCity &&
!Grid.GetNeighbors(cityLocation).Any(neighbor => neighbor.Terrain.IsWater())
)
{
return(false);
}
return(true);
}
private bool IsConditionMetByBuilding(IBuildingTemplate building)
{
if (BuildingRestriction == BuildingRestrictionCategory.OfType)
{
bool hasArguedType = BuildingTypeArguments.Contains(building.Type);
return(Restriction == RestrictionType.MustBe ? hasArguedType : !hasArguedType);
}
else if (BuildingRestriction == BuildingRestrictionCategory.OfName)
{
bool isArguedName = NameArguments.Any(name => name.Equals(building.name));
return(Restriction == RestrictionType.MustBe ? isArguedName : !isArguedName);
}
else
{
return(false);
}
}
private IBuilding BuildBuilding(IBuildingTemplate template, ICity owner)
{
var mockBuilding = new Mock <IBuilding>();
var slots = new List <IWorkerSlot>();
for (int i = 0; i < template.SpecialistCount; i++)
{
slots.Add(BuildWorkerSlot());
}
mockBuilding.Setup(building => building.Template).Returns(template);
mockBuilding.Setup(building => building.Slots).Returns(slots.AsReadOnly());
var newBuilding = mockBuilding.Object;
MockBuildingPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newBuilding)).Returns(owner);
AllBuildings.Add(newBuilding);
return(newBuilding);
}
public bool IsTemplateValidForCity(
IBuildingTemplate template, ICity city, ICivilization cityOwner
)
{
foreach (var resource in template.ResourcesConsumed)
{
if (FreeResourcesLogic.GetFreeCopiesOfResourceForCiv(resource, cityOwner) <= 0)
{
return(false);
}
}
var cellsOfCity = CellPossessionCanon.GetPossessionsOfOwner(city);
if (template.PrerequisiteResourcesNearCity.Any() && !template.PrerequisiteResourcesNearCity.Any(
prereq => cellsOfCity.Any(cell => DoesCellHaveNodeOfResource(cell, prereq))
))
{
return(false);
}
return(true);
}
public bool IsTemplateValidForCity(IBuildingTemplate template, ICity city, ICivilization cityOwner)
{
var templatesAlreadyThere = BuildingPossessionCanon.GetPossessionsOfOwner(city).Select(building => building.Template);
bool templateAlreadyExists = templatesAlreadyThere.Any(
existingTemplate => existingTemplate == template
);
bool allPrerequisitesExist = template.PrerequisiteBuildings.All(
prerequisite => templatesAlreadyThere.Contains(prerequisite)
);
bool meetsGlobalBuildingPrerequisites = true;
if (template.GlobalPrerequisiteBuildings.Any())
{
meetsGlobalBuildingPrerequisites = template.GlobalPrerequisiteBuildings.All(
globalPrereq => DoAllCitiesHaveTemplate(globalPrereq, cityOwner)
);
}
return(meetsGlobalBuildingPrerequisites && !templateAlreadyExists && allPrerequisitesExist);
}
private IBuilding BuildBuilding(IBuildingTemplate template)
{
return(BuildBuilding(template, BuildCity(BuildHexCell(new HexCoordinates(0, 0)))));
}
public Building(IBuildingTemplate template)
{
Template = template;
}
/// <inheritdoc/>
public IProductionProject ConstructProject(IBuildingTemplate template)
{
return(new ProductionProject(template, BuildingFactory));
}
public void SetDescriptionFrom(IBuildingTemplate template)
{
DescriptionField.text = template.Description;
}
private ProductionProject BuildProductionProject(IBuildingTemplate buildingToConstruct)
{
return(new ProductionProject(buildingToConstruct, MockBuildingFactory.Object));
}
