public void GenerateStage(ConstructionStage Stage, int StageNumber)
{
if (!ContainedObjects.ContainsKey(StageNumber))
{
ContainedObjects[StageNumber] = new List <ComponentData>();
}
foreach (var NeededObject in Stage.NeededParts)
{
if (Stage.IncludePartsInitialisation && GenerateComponents)
{
for (int i = 0; i < NeededObject.NumberNeeded; i++)
{
if (NeededObject.GameObject != null)
{
var _Object = PoolManager.PoolNetworkInstantiate(NeededObject.GameObject, this.transform.position, parent: this.transform.parent);
CustomNetTransform netTransform = _Object.GetComponent <CustomNetTransform>();
netTransform.DisappearFromWorldServer();
Stage.PresentParts.Add(_Object);
}
else if (NeededObject.CType != ConstructionElementType.Null)
{
var _Object = PoolManager.PoolNetworkInstantiate(StandardConstructionComponent, this.transform.position, parent: this.transform.parent);
CustomNetTransform netTransform = _Object.GetComponent <CustomNetTransform>();
netTransform.DisappearFromWorldServer();
_Object.GetComponent <ConstructionComponent>().setTypeLevel(NeededObject.CType, NeededObject.level);
Stage.PresentParts.Add(_Object);
}
}
NeededObject.NumberPresent = NeededObject.NumberNeeded;
}
ContainedObjects[StageNumber].Add(NeededObject);
}
}
private static void AssertConstructionStages(
UpliftVanCalculatorInput input, StabilityInput stabilityModel, SoilProfile soilProfile,
Waternet dailyWaternet, Waternet extremeWaternet, IDictionary <SoilLayer, LayerWithSoil> layerLookup)
{
Assert.AreEqual(2, stabilityModel.ConstructionStages.Count);
ConstructionStage dailyConstructionStage = stabilityModel.ConstructionStages.ElementAt(0);
Assert.AreSame(soilProfile, dailyConstructionStage.SoilProfile);
Assert.AreSame(dailyWaternet, dailyConstructionStage.Waternet);
CollectionAssert.AreEqual(FixedSoilStressCreator.Create(layerLookup),
dailyConstructionStage.FixedSoilStresses, new FixedSoilStressComparer());
CollectionAssert.AreEqual(PreconsolidationStressCreator.Create(input.SoilProfile.PreconsolidationStresses),
dailyConstructionStage.PreconsolidationStresses, new PreconsolidationStressComparer());
AssertMultiplicationFactors(dailyConstructionStage.MultiplicationFactorsCPhiForUplift.Single());
AssertIrrelevantValues(dailyConstructionStage);
ConstructionStage extremeConstructionStage = stabilityModel.ConstructionStages.ElementAt(1);
Assert.AreSame(soilProfile, extremeConstructionStage.SoilProfile);
Assert.AreSame(extremeWaternet, extremeConstructionStage.Waternet);
CollectionAssert.IsEmpty(extremeConstructionStage.FixedSoilStresses);
CollectionAssert.IsEmpty(extremeConstructionStage.PreconsolidationStresses);
AssertMultiplicationFactors(extremeConstructionStage.MultiplicationFactorsCPhiForUplift.Single());
AssertIrrelevantValues(extremeConstructionStage);
}
private static void AssertIrrelevantValues(ConstructionStage constructionStage)
{
CollectionAssert.IsEmpty(constructionStage.ConsolidationValues); // Irrelevant
Assert.IsNotNull(constructionStage.Earthquake); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.ForbiddenLines); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.Geotextiles); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.LineLoads); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.Nails); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.TreesOnSlope); // Irrelevant
CollectionAssert.IsEmpty(constructionStage.UniformLoads); // Irrelevant
Assert.IsNotNull(constructionStage.YieldStressField); // Irrelevant
}
public async Task <Guid> Handle(AddNewConstructionStageCommand cmd)
{
if (await _context.ConstructionStages.AnyAsync(s => s.Name == cmd.Name))
{
throw new NameAlreadyExistException(nameof(ConstructionStage), cmd.Name);
}
var constructionStage = ConstructionStage.New(cmd.Name, Enumeration.FromDisplayName <Color>(cmd.Color),
cmd.Icon, cmd.PlannedStartDate, cmd.PlannedFinishDate, cmd.ActualStartDate, cmd.ActualFinishDate);
await _context.ConstructionStages.AddAsync(constructionStage);
return(constructionStage.Id);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> is equal to <paramref name="expected"/>.
/// </summary>
/// <param name="expected">The expected collection of <see cref="ConstructionStage"/>.</param>
/// <param name="actual">The actual collection of <see cref="ConstructionStage"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// is not equal to <paramref name="expected"/>.</exception>
private static void AssertConstructionStages(ICollection <ConstructionStage> expected, ICollection <ConstructionStage> actual)
{
Assert.AreEqual(expected.Count, actual.Count);
for (var i = 0; i < expected.Count; i++)
{
ConstructionStage expectedConstructionStage = expected.ElementAt(i);
ConstructionStage actualConstructionStage = actual.ElementAt(i);
KernelInputAssert.AssertSoilProfile(expectedConstructionStage.SoilProfile, actualConstructionStage.SoilProfile);
Assert.AreEqual(expectedConstructionStage.Waternet, actualConstructionStage.Waternet);
CollectionAssert.AreEqual(expectedConstructionStage.FixedSoilStresses, actualConstructionStage.FixedSoilStresses, new FixedSoilStressComparer());
CollectionAssert.AreEqual(expectedConstructionStage.PreconsolidationStresses, actualConstructionStage.PreconsolidationStresses, new PreconsolidationStressComparer());
AssertMultiplicationFactorsCPhiForUplift(expectedConstructionStage.MultiplicationFactorsCPhiForUplift.Single(),
actualConstructionStage.MultiplicationFactorsCPhiForUplift.Single());
}
}
void IDailyUpdatableItem.DayUpdate()
{
if (_constructionStage == ConstructionStage.ResourceGathering)
{
if(_resourceRequirements.All(rr=>rr.IsFullfilled))
_constructionStage = ConstructionStage.Construction;
foreach (ResourceRequirement requirement in _resourceRequirements)
{
Resource resource = _location.Province.Resources.SingleOrDefault(r => r.Type == requirement.ResourceType);
if(resource == null)
continue;
double change = Math.Min(resource.StorageLevel, requirement.RemainingValue);
requirement.CurrentValue += change;
resource.StorageLevel -= change;
}
}
else
{
}
}
void IDailyUpdatableItem.DayUpdate()
{
if (_constructionStage == ConstructionStage.ResourceGathering)
{
if (_resourceRequirements.All(rr => rr.IsFullfilled))
{
_constructionStage = ConstructionStage.Construction;
}
foreach (ResourceRequirement requirement in _resourceRequirements)
{
Resource resource = _location.Province.Resources.SingleOrDefault(r => r.Type == requirement.ResourceType);
if (resource == null)
{
continue;
}
double change = Math.Min(resource.StorageLevel, requirement.RemainingValue);
requirement.CurrentValue += change;
resource.StorageLevel -= change;
}
}
else
{
}
}
void Update()
{
if (ConstructionSite == null)
{
return;
}
else
if (ConstructionSite.GetCompletionPercentage() >= 1f)
{
ConstructionSite = null;
SelectionPanel.RemoveSelection();
return;
}
if (ConstructionSite.Building != null)
{
if (firstShow ||
lastStage != ConstructionSite.Stage ||
lastTransitionState != ConstructionSite.TransitionToDeconstructionStage)
{
if (ConstructionSite.TransitionToDeconstructionStage)
{
if (ConstructionSite.Stage == ConstructionStage.Construction)
{
Text.text = GameManager.Instance.GetText("s_deconstruction_site");
}
else if (ConstructionSite.Stage == ConstructionStage.ScaffoldingConstruction)
{
Text.text = GameManager.Instance.GetText("s_scaffolding_deconstruction");
}
}
else
{
if (ConstructionSite.Stage == ConstructionStage.Construction)
{
Text.text = GameManager.Instance.GetText("s_construction_site");
}
else if (ConstructionSite.Stage == ConstructionStage.ScaffoldingConstruction)
{
Text.text = GameManager.Instance.GetText("s_scaffolding_construction");
}
else if (ConstructionSite.Stage == ConstructionStage.Deconstruction)
{
Text.text = GameManager.Instance.GetText("s_deconstruction_site");
}
else if (ConstructionSite.Stage == ConstructionStage.ScaffoldingDeconstruction)
{
Text.text = GameManager.Instance.GetText("s_scaffolding_deconstruction");
}
}
}
SubText.text = ConstructionSite.Building.Name;
}
float percentage = ConstructionSite.GetStageCompletionPercentage();
if (ConstructionSite.DeconstructionMode ||
(ConstructionSite.ConstructionMode &&
ConstructionSite.TransitionToDeconstructionStage))
{
percentage = 1f - percentage;
}
if (ConstructionSite.Halted)
{
ProgressBar.SetFillPercentageWithoutText(percentage);
ProgressBar.SetText(GameManager.Instance.GetText("s_halted"));
}
else
{
ProgressBar.SetFillPercentage(percentage);
}
if (firstShow ||
ConstructionSite.InputStorage.Changed ||
ConstructionSite.OutputStorage.Changed ||
lastStage != ConstructionSite.Stage ||
lastTransitionState != ConstructionSite.TransitionToDeconstructionStage)
{
if (firstShow)
{
firstShow = false;
}
if (ConstructionSite.InputStorage.Changed)
{
ConstructionSite.InputStorage.Changed = false;
}
if (ConstructionSite.OutputStorage.Changed)
{
ConstructionSite.OutputStorage.Changed = false;
}
lastStage = ConstructionSite.Stage;
lastTransitionState = ConstructionSite.TransitionToDeconstructionStage;
SelectionPanel.HideResourceIcons(icons, this.transform);
if (ConstructionSite.ConstructionMode)
{
if (ConstructionSite.Stage == ConstructionStage.ScaffoldingConstruction &&
ConstructionSite.Prototype.ResourcesForScaffoldingConstruction != null)
{
tempRequiredResources = SelectionPanel.GetResourcesList(ConstructionSite.Prototype.ResourcesForScaffoldingConstruction);
tempRequiredResources.Sort();
tempResources = SelectionPanel.GetResourcesList(ConstructionSite.InputStorage.Resources);
SelectionPanel.ShowIconsWithRequirements(slots, tempRequiredResources, tempResources, icons);
}
else if (ConstructionSite.Prototype.ConstructionResources != null)
{
tempRequiredResources = SelectionPanel.GetResourcesList(ConstructionSite.Prototype.ConstructionResources);
tempRequiredResources.Sort();
tempResources = SelectionPanel.GetResourcesList(ConstructionSite.InputStorage.Resources);
SelectionPanel.ShowIconsWithRequirements(slots, tempRequiredResources, tempResources, icons);
}
}
else
if (ConstructionSite.DeconstructionMode)
{
tempResources = SelectionPanel.GetResourcesList(ConstructionSite.OutputStorage.Resources);
tempResources.AddRange(SelectionPanel.GetResourcesList(ConstructionSite.OutputStorage.ReservedResources));
tempResources.Sort();
for (int index = 0; index < tempResources.Count; index++)
{
SelectionPanel.ShowResourceIcon(tempResources[index], slots[index], false, icons);
}
}
}
}
