private void PopulateImprovementList()
{
foreach (var improvementTemplate in AvailableImprovementTemplates)
{
var newRecord = Instantiate(ImprovementRecordPrefab);
newRecord.gameObject.SetActive(true);
newRecord.SetParent(ImprovementRecordContainer, false);
newRecord.GetComponentInChildren <Text>().text = improvementTemplate.name;
var recordToggle = newRecord.GetComponentInChildren <Toggle>();
var cachedTemplate = improvementTemplate;
recordToggle.onValueChanged.AddListener(delegate(bool isOn) {
if (isOn)
{
SelectedTemplate = cachedTemplate;
}
});
if (recordToggle.isOn)
{
SelectedTemplate = improvementTemplate;
}
if (SelectedTemplate == improvementTemplate)
{
recordToggle.isOn = true;
}
InstantiatedRecords.Add(newRecord);
}
}
public YieldSummary GetYieldOfImprovementTemplate(
IImprovementTemplate template, IResourceNode nodeAtLocation,
IEnumerable <IResourceDefinition> visibleResources,
IEnumerable <IImprovementModificationData> improvementModifications,
bool hasFreshWater
)
{
YieldSummary retval = YieldSummary.Empty;
if (nodeAtLocation == null || nodeAtLocation.Resource.Extractor != template ||
!visibleResources.Contains(nodeAtLocation.Resource)
)
{
retval += template.BonusYieldNormal;
}
foreach (var mod in improvementModifications)
{
if (mod.Template == template && (!mod.RequiresFreshWater || hasFreshWater))
{
retval += mod.BonusYield;
}
}
return(retval);
}
private IResourceDefinition BuildResource(IImprovementTemplate extractor)
{
var mockResource = new Mock <IResourceDefinition>();
mockResource.Setup(resource => resource.Extractor).Returns(extractor);
return(mockResource.Object);
}
private IImprovement BuildImprovement(IImprovementTemplate template)
{
var mockImprovement = new Mock <IImprovement>();
mockImprovement.Setup(improvement => improvement.Template).Returns(template);
return(mockImprovement.Object);
}
private IImprovement BuildImprovement(IImprovementTemplate template, bool isPillaged = false)
{
var mockImprovement = new Mock <IImprovement>();
mockImprovement.Setup(improvement => improvement.Template).Returns(template);
mockImprovement.Setup(improvement => improvement.IsPillaged).Returns(isPillaged);
return(mockImprovement.Object);
}
private void TryAddImprovementTo(IImprovementTemplate template, IHexCell location)
{
if (ImprovementValidityLogic.IsTemplateValidForCell(template, location, true) &&
ImprovementLocationCanon.CanPlaceImprovementOfTemplateAtLocation(template, location)
)
{
ImprovementFactory.BuildImprovement(template, location, 0, true, false);
}
}
public YieldSummary GetYieldOfImprovementTemplate(
IImprovementTemplate template, IResourceNode nodeAtLocation,
IEnumerable <IResourceDefinition> visibleResources,
IEnumerable <ITechDefinition> discoveredTechs, bool hasFreshWater
)
{
var improvementModification = discoveredTechs.SelectMany(tech => tech.ImprovementYieldModifications);
return(GetYieldOfImprovementTemplate(
template, nodeAtLocation, visibleResources, improvementModification, hasFreshWater
));
}
private IResourceDefinition BuildResourceDefinition(
IImprovementTemplate extractor, YieldSummary bonusYieldBase,
YieldSummary bonusYieldWhenImproved
)
{
var mockResource = new Mock <IResourceDefinition>();
mockResource.Setup(resource => resource.Extractor).Returns(extractor);
mockResource.Setup(resource => resource.BonusYieldBase).Returns(bonusYieldBase);
mockResource.Setup(resource => resource.BonusYieldWhenImproved).Returns(bonusYieldWhenImproved);
return(mockResource.Object);
}
private IImprovement BuildImprovement(
IImprovementTemplate template, bool isConstructed, bool isPillaged
)
{
var mockImprovement = new Mock <IImprovement>();
mockImprovement.Setup(improvement => improvement.IsConstructed).Returns(isConstructed);
mockImprovement.Setup(improvement => improvement.IsPillaged).Returns(isPillaged);
mockImprovement.Setup(improvement => improvement.Template).Returns(template);
var newImprovement = mockImprovement.Object;
return(newImprovement);
}
private ITechDefinition BuildTechDefinition(TechTestData testData,
IImprovementTemplate candidateImprovementTemplate
)
{
var mockTech = new Mock <ITechDefinition>();
mockTech
.Setup(tech => tech.ImprovementYieldModifications)
.Returns(testData.ImprovementModifications.Select(
yieldModData => BuildModificationData(yieldModData, candidateImprovementTemplate)
));
return(mockTech.Object);
}
private IImprovement BuildImprovement(IImprovementTemplate template, IHexCell location)
{
var mockImprovement = new Mock <IImprovement>();
mockImprovement.Setup(improvement => improvement.Template).Returns(template);
var newImprovement = mockImprovement.Object;
MockImprovementLocationCanon.Setup(canon => canon.GetPossessionsOfOwner(location))
.Returns(new List <IImprovement>()
{
newImprovement
});
return(newImprovement);
}
private YieldSummary GetYieldEstimateForCellWithImprovement(
IHexCell cell, IResourceNode nodeAtLocation, IEnumerable <IResourceDefinition> visibleResources,
IEnumerable <IImprovementModificationData> improvementModifications,
IEnumerable <ICellYieldModificationData> buildingYieldMods,
IImprovementTemplate improvement
)
{
var retval = YieldSummary.Empty;
if (nodeAtLocation != null)
{
HypotheticalImprovement hypothetical;
if (improvement == null)
{
hypothetical = NullHypotheticalImprovement;
}
else if (!HypotheticalForTemplate.TryGetValue(improvement, out hypothetical))
{
hypothetical = new HypotheticalImprovement(improvement);
HypotheticalForTemplate[improvement] = hypothetical;
}
retval += NodeYieldLogic.GetYieldFromNode(
nodeAtLocation, visibleResources, hypothetical
);
}
bool clearVegetation = false;
if (improvement != null)
{
retval += ImprovementYieldLogic.GetYieldOfImprovementTemplate(
improvement, nodeAtLocation, visibleResources, improvementModifications,
FreshWaterCanon.HasAccessToFreshWater(cell)
);
clearVegetation = improvement.ClearsVegetationWhenBuilt;
}
retval += InherentYieldLogic.GetInherentCellYield(cell, clearVegetation);
retval += YieldFromBuildingsLogic.GetBonusCellYieldFromYieldModifications(cell, buildingYieldMods);
return(retval + OneScience);
}
private IImprovementModificationData BuildModificationData(
ImprovementModificationTestData modData,
IImprovementTemplate candidateImprovementTemplate
)
{
var mockData = new Mock <IImprovementModificationData>();
mockData.Setup(data => data.BonusYield).Returns(modData.BonusYield);
mockData.Setup(data => data.RequiresFreshWater).Returns(modData.RequiresFreshWater);
if (modData.AppliesToImprovement)
{
mockData.Setup(data => data.Template).Returns(candidateImprovementTemplate);
}
return(mockData.Object);
}
public IImprovement BuildImprovement(
IImprovementTemplate template, IHexCell location, float workInvested,
bool isConstructed, bool isPillaged
)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
else if (location == null)
{
throw new ArgumentNullException("location");
}
var newGameObject = GameObject.Instantiate(ImprovementPrefab);
Container.InjectGameObject(newGameObject);
var newImprovement = newGameObject.GetComponent <Improvement>();
newImprovement.Template = template;
if (template.ClearsVegetationWhenBuilt && location.Vegetation != CellVegetation.None)
{
CellModificationLogic.ChangeVegetationOfCell(location, CellVegetation.None);
}
if (!ImprovementLocationCanon.CanChangeOwnerOfPossession(newImprovement, location))
{
throw new ImprovementCreationException("Cannot assign the new improvement to its intended location");
}
ImprovementLocationCanon.ChangeOwnerOfPossession(newImprovement, location);
if (isConstructed)
{
newImprovement.Construct();
}
else if (isPillaged)
{
newImprovement.Pillage();
}
allImprovements.Add(newImprovement);
return(newImprovement);
}
private IResourceNode BuildResourceNode(IHexCell location, IImprovementTemplate extractor)
{
var mockNode = new Mock <IResourceNode>();
var mockDefinition = new Mock <IResourceDefinition>();
mockDefinition.Setup(definition => definition.Extractor).Returns(extractor);
mockNode.Setup(node => node.Resource).Returns(mockDefinition.Object);
var newNode = mockNode.Object;
MockNodePositionCanon.Setup(canon => canon.GetPossessionsOfOwner(location))
.Returns(new List <IResourceNode>()
{
newNode
});
return(newNode);
}
public bool IsTemplateValidForCell(
IImprovementTemplate template, IHexCell cell, bool ignoreOwnership
)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
else if (cell == null)
{
throw new ArgumentNullException("cell");
}
if (!ignoreOwnership && CityLocationCanon.GetPossessionsOfOwner(cell).Count() > 0)
{
return(false);
}
var nodeAtCell = NodePositionCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
if (nodeAtCell != null && nodeAtCell.Resource.Extractor == template)
{
return(true);
}
else if (template.RequiresResourceToExtract)
{
return(false);
}
else if (template.FreshWaterAlwaysEnables && FreshWaterCanon.HasAccessToFreshWater(cell))
{
return(true);
}
var retval = cell.Feature == CellFeature.None &&
(template.RestrictedToTerrains.Count() == 0 || template.RestrictedToTerrains.Contains(cell.Terrain)) &&
(template.RestrictedToVegetations.Count() == 0 || template.RestrictedToVegetations.Contains(cell.Vegetation)) &&
(template.RestrictedToShapes.Count() == 0 || template.RestrictedToShapes.Contains(cell.Shape));
return(retval);
}
private IImprovement BuildImprovement(
IImprovementTemplate template, IHexCell location, int workInvested = 0,
bool isConstructed = false, bool isPillaged = false
)
{
var mockImprovement = new Mock <IImprovement>();
mockImprovement.SetupAllProperties();
mockImprovement.Setup(improvement => improvement.Template).Returns(template);
mockImprovement.Setup(improvement => improvement.IsConstructed).Returns(isConstructed);
mockImprovement.Setup(improvement => improvement.IsPillaged).Returns(isPillaged);
var newImprovement = mockImprovement.Object;
newImprovement.WorkInvested = workInvested;
MockImprovementLocationCanon.Setup(canon => canon.GetOwnerOfPossession(newImprovement))
.Returns(location);
LastImprovementCreated = newImprovement;
return(newImprovement);
}
public HypotheticalImprovement(IImprovementTemplate template)
{
Template = template;
}
public IImprovement BuildImprovement(IImprovementTemplate template, IHexCell location)
{
return(BuildImprovement(template, location, 0, false, false));
}
public bool CanPlaceImprovementOfTemplateAtLocation(IImprovementTemplate template, IHexCell location)
{
return(GetPossessionsOfOwner(location).Count() == 0);
}
