private void CheckForResourceChangePossibility(BuildItemEntity item, BuildItemStatistics statisticProvider)
{
if (item.CostSupply > 0 && (statisticProvider.CurrentSupply + item.CostSupply > statisticProvider.MaximumSupply))
{
if (statisticProvider.GetStatValueByName(Consts.CoreStatistics.BuildingNewSupply) == 0)
{
throw new ApplicationException("New item requires more supply but there is no supply changers in build order");
}
}
if (item.CostMinerals > 0)
{
if (statisticProvider.Minerals < item.CostMinerals && statisticProvider.GetStatValueByName(Consts.CoreStatistics.WorkersOnMinerals) == 0 &&
statisticProvider.GetStatValueByName("MineralScv" + Consts.BuildItemOnBuildingPostfix) == 0 &&
statisticProvider.GetStatValueByName(Consts.DefaultStateItemName + Consts.BuildItemOnBuildingPostfix) == 0)
{
throw new ApplicationException("New item requires minerals but there is no mineral harvesters applied in build order");
}
}
if (item.CostGas > 0)
{
if (statisticProvider.Gas < item.CostGas && statisticProvider.GetStatValueByName(Consts.CoreStatistics.WorkersOnGas) == 0 &&
statisticProvider.GetStatValueByName("GasScv" + Consts.BuildItemOnBuildingPostfix) == 0 &&
statisticProvider.GetStatValueByName(Consts.DefaultStateItemName + Consts.BuildItemOnBuildingPostfix) == 0)
{
throw new ApplicationException("New item requires gas but there is no gas harvesters applied in build order");
}
}
}
public BuildOrderProcessorItem(int secondInTimeLine, BuildItemEntity item, BuildItemStatistics statisticsProvider, int order)
{
this.SecondInTimeLine = secondInTimeLine;
this.StatisticsProvider = statisticsProvider;
this.FinishedSecond = secondInTimeLine + item.BuildTimeInSeconds;
this.ItemName = item.Name;
this.Order = order;
}
private bool IsRequirementsSatisfied(BuildItemEntity buildItem, BuildItemStatistics stats)
{
if (buildItem.ProduceRequirements == null || buildItem.ProduceRequirements.Count == 0)
{
return(true);
}
return(buildItem.ProduceRequirements.All(req => req.IsRequirementSatisfied(stats)));
}
private string GetProdBuildingNameForItem(BuildItemStatistics stats, BuildItemEntity item)
{
string result = this.GetFreeChronoboostedProdBuildingForItem(stats, item);
if (string.IsNullOrEmpty(result))
{
result = this.GetFirstNormalProdBuilding(stats, item);
}
return(result);
}
private BuildItemInfo ConvertEntityToInfo(BuildItemEntity entity)
{
var convertedItem = new BuildItemInfo
{
BuildTime = entity.BuildTimeInSeconds,
CostGas = entity.CostGas,
CostMinerals = entity.CostMinerals,
CostSupply = entity.CostSupply,
DisplayName = entity.DisplayName,
Name = entity.Name
};
return(convertedItem);
}
private void GetCurrentStateData(string buildItemName, out BuildItemEntity buildItem, out BuildItemStatistics statProvider)
{
buildItem = this.mConfig.BuildItemsDictionary.GetItem(buildItemName);
if (buildItem == null)
{
throw new ArgumentException("Unknown build item");
}
var previousStats = this.mBuildOrder.LastBuildItem != null
? this.mBuildOrder.LastBuildItem.StatisticsProvider.CloneItemsCountDictionary()
: new Dictionary <string, int>();
statProvider = new BuildItemStatistics(this.mConfig.RaceConstants, previousStats);
}
private void ProcessBoostPossibleItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
if (item.ItemType == BuildItemTypeEnum.Unit || item.ItemType == BuildItemTypeEnum.Upgrade)
{
var prodBuilding = this.GetProdBuildingNameForItem(stats, item);
if (!string.IsNullOrEmpty(prodBuilding))
{
this.ApplyBuzyTimers(boItem, item, stats, prodBuilding);
stats.SetItemCountForName("LastItemOrder", boItem.Order);
stats.SetItemCountForName("LastItemProdBuildingIndex", Convert.ToInt32(prodBuilding.Substring(item.ProductionBuildingName.Length)));
}
}
}
private void SetAvailableBoost(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
int boostLength = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem("Chronoboost").BuildTimeInSeconds;
int boostProdIndex = stats.GetStatValueByName("LastItemProdBuildingIndex");
int chronoTimer = stats.GetStatValueByName("ChronoTimer" + item.ProductionBuildingName + boostProdIndex);
int buildTime = boItem.FinishedSecond - boItem.SecondInTimeLine;
int availableCasts = buildTime <= chronoTimer ? 0 : (int)Math.Ceiling((double)(buildTime - chronoTimer) / boostLength);
int secondsToChronoboost;
bool isEnoughEnergy = this.IsChronoboostPossibleWhileBuilding(buildTime, stats, out secondsToChronoboost);
if (boItem.SecondInTimeLine + secondsToChronoboost >= boItem.FinishedSecond)
{
isEnoughEnergy = false;
}
stats.SetItemCountForName("ChronoboostAvailable", (availableCasts > 0 && isEnoughEnergy) ? 1 : 0);
}
private void ApplyBuzyTimers(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats, string prodBuilding)
{
int chronoTimer = stats.GetStatValueByName("ChronoTimer" + prodBuilding);
if (chronoTimer != 0)
{
boItem.FinishedSecond = boItem.SecondInTimeLine + this.CalculateBuildTimeForItem(item.BuildTimeInSeconds, chronoTimer);
int chronoBuzyTimer = (boItem.FinishedSecond - boItem.SecondInTimeLine) > chronoTimer
? chronoTimer
: (boItem.FinishedSecond - boItem.SecondInTimeLine);
stats.SetItemCountForName("ChronoBuzy" + prodBuilding, chronoBuzyTimer);
}
else
{
stats.SetItemCountForName("NormalBuzy" + prodBuilding, item.BuildTimeInSeconds);
}
}
public override void AdjustModuleStatsByUndoItem(BuildOrderProcessorItem undoBoItem, BuildOrderProcessorItem newLastItem)
{
if (undoBoItem.ItemName == "Chronoboost")
{
// Recalculate boosted item finish time
int boostItemOrder = newLastItem.StatisticsProvider.GetStatValueByName("LastItemOrder");
int boostProdIndex = newLastItem.StatisticsProvider.GetStatValueByName("LastItemProdBuildingIndex");
if (boostItemOrder == 0)
{
return;
}
BuildOrderProcessorItem boostBoItem = this.BuildOrder.GetBuildOrderItemsClone().First(p => p.Order == boostItemOrder);
BuildItemEntity boostItem = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem(boostBoItem.ItemName);
int previousChronoTimer = newLastItem.StatisticsProvider.GetStatValueByName("ChronoTimer" + boostItem.ProductionBuildingName + boostProdIndex);
boostBoItem.FinishedSecond = boostBoItem.SecondInTimeLine + this.CalculateBuildTimeForItem(boostItem.BuildTimeInSeconds, previousChronoTimer);
}
}
private string GetFirstNormalProdBuilding(BuildItemStatistics stats, BuildItemEntity item)
{
var totalBuzyProdBuilding = stats.GetStatValueByName(item.ProductionBuildingName + Consts.BuzyBuildItemPostfix);
var buzyChronoedProdBuildings = stats.GetStatsWithKeyContains("ChronoBuzy" + item.ProductionBuildingName);
var buzyNormalProdBuildings = stats.GetStatsWithKeyContains("NormalBuzy" + item.ProductionBuildingName);
var buzyProdNames = buzyNormalProdBuildings.Select(p => p.Key).ToList();
if (totalBuzyProdBuilding > buzyNormalProdBuildings.Count)
{
for (int i = 1; i <= totalBuzyProdBuilding; i++)
{
string tmpBuildingName = item.ProductionBuildingName + (buzyChronoedProdBuildings.Count + i);
if (!buzyProdNames.Contains(tmpBuildingName))
{
return(tmpBuildingName);
}
}
}
return(string.Empty);
}
public static BuildItemInfo Convert(BuildItemEntity item)
{
var result = new BuildItemInfo
{
BuildTimeInSeconds = item.BuildTimeInSeconds,
CostGas = item.CostGas,
CostMinerals = item.CostMinerals,
CostSupply = item.CostSupply,
DisplayName = item.DisplayName,
ImagePath = item.ImagePath,
ItemType = item.ItemType.ToString(),
Name = item.Name,
ProductionBuildingName = item.ProductionBuildingName
};
AddActions(item.OrderedActions, result.OrderedActions);
AddActions(item.ProducedActions, result.ProducedActions);
AddRequirements(item.OrderRequirements, result.OrderRequirements);
AddRequirements(item.ProduceRequirements, result.ProduceRequirements);
return(result);
}
public override void AdjustModuleStatsByUndoItem(BuildOrderProcessorItem undoBoItem, BuildOrderProcessorItem newLastItem)
{
if (undoBoItem.ItemName == "Chronoboost")
{
if (undoBoItem.SecondInTimeLine == undoBoItem.FinishedSecond)
{
return;
}
// Recalculate boosted item finish time
int boostItemOrder = newLastItem.StatisticsProvider.GetStatValueByName("LastItemOrder");
if (boostItemOrder == 0)
{
return;
}
BuildItemEntity boostItem = BuildManagerConfiguration.BuildItemsDictionary.GetItem(newLastItem.ItemName);
newLastItem.FinishedSecond = newLastItem.SecondInTimeLine + boostItem.BuildTimeInSeconds;
}
}
private void FindAppropriateSecondInTimeLine(BuildItemEntity buildItem, BuildItemStatistics stats, out int secondsToAppropriateItem)
{
secondsToAppropriateItem = 0;
while ((!this.IsCurrentSecondHasEnoughResourcesToBuildItem(buildItem, stats) ||
!this.HasFreeProductionBuilding(stats, buildItem) ||
!this.IsRequirementsSatisfied(buildItem, stats)) &&
secondsToAppropriateItem < this.mConfig.GlobalConstants.MaximumPeriodInSecondsForBuildPrediction)
{
secondsToAppropriateItem++;
this.mConfig.BuildManagerModules.AdjustModulesStatsForStep(stats);
this.AdjustStatisticsByFinishedItems(this.mBuildOrder.LastBuildItem.SecondInTimeLine + secondsToAppropriateItem, stats);
this.CheckForResourceChangePossibility(buildItem, stats);
}
if (secondsToAppropriateItem == this.mConfig.GlobalConstants.MaximumPeriodInSecondsForBuildPrediction)
{
throw new ApplicationException("There is no appropriate point in timeline when it is possible to build this item.");
}
}
private void AdjustAvailableBoost(BuildOrderProcessorItem lastAddedBoItem, BuildItemEntity lastAddedItem, BuildItemStatistics stats)
{
if (lastAddedItem.Name == Consts.DefaultStateItemName)
{
return;
}
BuildOrderProcessorItem boBoostedItem;
BuildItemEntity boostedItem;
if (lastAddedItem.ItemType == BuildItemTypeEnum.Unit || lastAddedItem.ItemType == BuildItemTypeEnum.Upgrade)
{
boBoostedItem = lastAddedBoItem;
boostedItem = lastAddedItem;
}
else
{
int boostItemOrder = stats.GetStatValueByName("LastItemOrder");
boBoostedItem = this.BuildOrder.GetBuildOrderItemsClone().First(p => p.Order == boostItemOrder);
boostedItem = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem(boBoostedItem.ItemName);
}
this.SetAvailableBoost(boBoostedItem, boostedItem, stats);
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
if (item.Name == "InjectLarva")
{
// TODO:
var injectedHatcheries = stats.GetStatsWithKeyContains("InjectedTimer");
int totalHatcheries = stats.GetStatValueByName("Hatchery");
if (injectedHatcheries.Count >= totalHatcheries)
{
throw new ApplicationException("All hatcheries are buzy");
}
var injectedHatchList = stats.GetStatsWithKeyContains("InjectedTimer").Select(p => p.Key.Substring(0, p.Key.Length - "InjectedTimer".Length)).ToList();
string hatchToInject = string.Empty;
for (int i = 1; i <= totalHatcheries; i++)
{
var hatchName = "Hatchery" + i;
if (!injectedHatchList.Contains(hatchName))
{
hatchToInject = hatchName;
break;
}
}
if (string.IsNullOrEmpty(hatchToInject))
{
throw new ApplicationException("All hatcheries are buzy");
}
stats.SetItemCountForName(hatchToInject + "InjectedTimer", 1);
return;
}
var larvaRequirement = item.ProduceRequirements.FirstOrDefault(p => p is LarvaRequirement) as LarvaRequirement;
if (larvaRequirement == null)
{
return;
}
int requiredLarva = larvaRequirement.RequiredValue;
var larvaCounts = stats.GetStatsWithKeyContains("LarvaCount");
foreach (var larvaCount in larvaCounts)
{
if (larvaCount.Value >= requiredLarva)
{
stats.SetItemCountForName(larvaCount.Key, larvaCount.Value - requiredLarva);
break;
}
requiredLarva = requiredLarva - larvaCount.Value;
stats.SetItemCountForName(larvaCount.Key, 0);
}
this.ResetTotalLarva(stats);
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
var startIdle = stats.GetStatValueByName(StartIdle);
if (startIdle == 0)
{
stats.SetItemCountForName(IdleTimer, 0);
}
}
private void ProcessChronoboostItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
if (item.ItemType == BuildItemTypeEnum.Special && item.Name == "Chronoboost")
{
if (stats.GetStatValueByName("ChronoboostAvailable") == 0)
{
throw new ApplicationException("It is not possible to apply chronoboost at this moment!");
}
// Apply chronoboost calculations
int boostItemOrder = stats.GetStatValueByName("LastItemOrder");
int boostProdIndex = stats.GetStatValueByName("LastItemProdBuildingIndex");
if (boostItemOrder == 0)
{
return;
}
int boostLength = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem("Chronoboost").BuildTimeInSeconds;
BuildOrderProcessorItem boostBoItem = this.BuildOrder.GetBuildOrderItemsClone().First(p => p.Order == boostItemOrder);
BuildItemEntity boostItem = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem(boostBoItem.ItemName);
int previousChronoTimer = stats.GetStatValueByName("ChronoTimer" + boostItem.ProductionBuildingName + boostProdIndex);
//int boostApplyPoint = boostBoItem.SecondInTimeLine + previousChronoTimer;
int buildTime = boostBoItem.FinishedSecond - (boostBoItem.SecondInTimeLine + previousChronoTimer);
int secondsToChronoboost;
bool isEnoughEnergy = this.IsChronoboostPossibleWhileBuilding(boostBoItem.FinishedSecond - boostBoItem.SecondInTimeLine, stats, out secondsToChronoboost);
if (!isEnoughEnergy)
{
throw new ApplicationException("Chronoboost is unavailable");
}
if (previousChronoTimer < secondsToChronoboost)
{
buildTime -= (secondsToChronoboost - previousChronoTimer);
}
int boostAmount = (buildTime - this.CalculateBuildTimeForItem(buildTime, boostLength));
boostBoItem.FinishedSecond -= boostAmount;
int normalBuzy = stats.GetStatValueByName("NormalBuzy" + boostItem.ProductionBuildingName + boostProdIndex);
if (normalBuzy - (boostLength + boostAmount) > 0)
{
stats.SetItemCountForName("NormalBuzy" + boostItem.ProductionBuildingName + boostProdIndex, normalBuzy - (boostLength + boostAmount));
}
else
{
stats.RemoveStat("NormalBuzy" + boostItem.ProductionBuildingName + boostProdIndex);
}
stats.SetItemCountForName("ChronoTimer" + boostItem.ProductionBuildingName + boostProdIndex, boostLength + previousChronoTimer);
int chronoBuzyTimer = (boostBoItem.FinishedSecond - boItem.SecondInTimeLine) > (boostLength + previousChronoTimer)
? (boostLength + previousChronoTimer)
: (boostBoItem.FinishedSecond - boItem.SecondInTimeLine);
stats.SetItemCountForName("ChronoBuzy" + boostItem.ProductionBuildingName + boostProdIndex, chronoBuzyTimer);
var castModule = this.BuildManagerConfiguration.BuildManagerModules.First(p => p is CastModule) as CastModule;
castModule.UseCast(stats);
}
}
private bool IsCurrentSecondHasEnoughResourcesToBuildItem(BuildItemEntity item, BuildItemStatistics stats)
{
return(stats.Minerals >= item.CostMinerals &&
stats.Gas >= item.CostGas &&
(item.CostSupply == 0 || (stats.CurrentSupply + item.CostSupply <= stats.MaximumSupply)));
}
private BuildOrderProcessorItem CreateBuildOrderItemWithAdjustedResourcesAndStatistics(int secondInTimeLine, BuildItemEntity item, BuildItemStatistics stats)
{
stats.CurrentSupply += item.CostSupply;
var newItem = new BuildOrderProcessorItem(secondInTimeLine, item, stats, this.GetBuildItemOrder());
this.RunActions(item.OrderedActions, stats);
this.mConfig.BuildManagerModules.AdjustModuleStatsByStartedItem(newItem, item, stats);
return(newItem);
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
if (item.Name == Consts.DefaultStateItemName)
{
int energyGeneratorCount = stats.GetStatValueByName(this.BuildManagerConfiguration.RaceConstants.EnergyGeneratorBuildItemName);
int energyForNewBase = this.BuildManagerConfiguration.RaceConstants.EnergyCastCountForNewEnergyGenerator;
string energyGeneratorName = this.BuildManagerConfiguration.RaceConstants.EnergyGeneratorBuildItemName;
stats.ChangeItemCountForName("TotalCasts", energyGeneratorCount * energyForNewBase);
for (int i = 0; i < energyGeneratorCount; i++)
{
stats.ChangeItemCountForName(energyGeneratorName + (i + 1) + "CastCount", energyForNewBase);
stats.ChangeItemCountForName(energyGeneratorName + (i + 1) + "CastTimer", 0);
}
}
var castRequirement = item.ProduceRequirements.FirstOrDefault(p => p is CastRequirement) as CastRequirement;
if (castRequirement == null)
{
return;
}
this.UseCast(stats);
}
private bool HasFreeProductionBuilding(BuildItemStatistics currentStatProvider, BuildItemEntity buildItem)
{
if (string.IsNullOrEmpty(buildItem.ProductionBuildingName))
{
return(true);
}
int productionBuildingsCount = currentStatProvider.GetStatValueByName(buildItem.ProductionBuildingName);
int buzyProdCount = currentStatProvider.GetStatValueByName(buildItem.ProductionBuildingName + Consts.BuzyBuildItemPostfix);
return(productionBuildingsCount > buzyProdCount);
}
public BuildOrderItemViewModel(BuildOrderProcessorItem model, BuildItemEntity buildItem)
: base(model)
{
this.mBuildItem = buildItem;
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
if (item.Name == "DefaultItem")
{
stats.ChangeItemCountForName("BoostedNexusCount", 1);
return;
}
if (item.ProductionBuildingName == "Nexus")
{
stats.SetItemCountForName("ChronoboostAvailable", 0);
int boostedNexus = stats.GetStatValueByName("BoostedNexusCount");
int boostedNexusBuzy = stats.GetStatValueByName("NexusBoostedBuzy");
if (boostedNexus > boostedNexusBuzy)
{
stats.ChangeItemCountForName("NexusBoostedBuzy", 1);
int secondsToCompleteBuilding = boItem.FinishedSecond - boItem.SecondInTimeLine;
int secondsToCompleteWithBoost = (int)Math.Round(secondsToCompleteBuilding - secondsToCompleteBuilding * 0.15);
boItem.FinishedSecond = boItem.SecondInTimeLine + secondsToCompleteWithBoost;
}
else
{
// We should try to find a moment in the build when chronoboost would be released if any of timers is in progress
var chronoTimers = stats.GetStatsWithKeyContains("ChronoTimer");
if (chronoTimers.Count > 0)
{
int fastestChronoRelease = chronoTimers.Min(p => p.Value);
if (item.BuildTimeInSeconds > fastestChronoRelease)
{
int boostedTime = boItem.FinishedSecond - boItem.SecondInTimeLine - fastestChronoRelease;
int boostedTimeWithBoost = (int)Math.Round(boostedTime - boostedTime * 0.15);
//var boostedTimeWithBoost = boostedTime / 1.5;
boItem.FinishedSecond = boItem.SecondInTimeLine + fastestChronoRelease + boostedTimeWithBoost;
stats.SetItemCountForName("ChronoBuzyTimer" + boItem.Order, fastestChronoRelease);
}
}
}
return;
}
if (item.Name == "Chronoboost")
{
stats.SetItemCountForName("ChronoboostAvailable", 0);
int boostItemOrder = stats.GetStatValueByName("LastItemOrder");
BuildOrderProcessorItem boItemToBeBoosted = null;
BuildItemEntity entityToBeBoosted = null;
for (int i = boostItemOrder; i > 0; i--)
{
boItemToBeBoosted = BuildOrder.GetBuildOrderItemsClone().First(p => p.Order == i);
entityToBeBoosted = BuildManagerConfiguration.BuildItemsDictionary.GetItem(boItemToBeBoosted.ItemName);
if (boItemToBeBoosted.FinishedSecond < boItem.SecondInTimeLine)
{
return;
}
if (entityToBeBoosted.ProductionBuildingName == "Nexus")
{
continue;
}
if (entityToBeBoosted.ItemType == BuildItemTypeEnum.Unit || entityToBeBoosted.ItemType == BuildItemTypeEnum.Upgrade)
{
break;
}
boItemToBeBoosted = null;
entityToBeBoosted = null;
}
if (boItemToBeBoosted == null || entityToBeBoosted == null)
{
throw new ApplicationException("Build processor were unable to find item to be boosted");
}
int unbooStedTime = 0;
if (boItem.SecondInTimeLine > boItemToBeBoosted.SecondInTimeLine)
{
unbooStedTime = boItem.SecondInTimeLine - boItemToBeBoosted.SecondInTimeLine;
}
int boostedTime = boItemToBeBoosted.FinishedSecond - boItem.SecondInTimeLine;
int boostedTimeWithBoost = (int)Math.Round(boostedTime - boostedTime * 0.15);
boItemToBeBoosted.FinishedSecond = boItemToBeBoosted.SecondInTimeLine + unbooStedTime + boostedTimeWithBoost;
boItem.FinishedSecond = boItemToBeBoosted.FinishedSecond;
stats.ChangeItemCountForName("BoostedNexusCount", -1);
stats.SetItemCountForName("ChronoTimer" + boostItemOrder, boItemToBeBoosted.FinishedSecond - boItem.SecondInTimeLine);
return;
}
if (item.ItemType == BuildItemTypeEnum.Unit || item.ItemType == BuildItemTypeEnum.Upgrade)
{
stats.SetItemCountForName("LastItemOrder", boItem.Order);
stats.SetItemCountForName("ChronoboostAvailable", 1);
}
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
this.ProcessBoostPossibleItem(boItem, item, stats);
this.ProcessChronoboostItem(boItem, item, stats);
this.AdjustAvailableBoost(boItem, item, stats);
}
private string GetFreeChronoboostedProdBuildingForItem(BuildItemStatistics stats, BuildItemEntity item)
{
string prodBuilding = string.Empty;
var chronoedProdBuildings = stats.GetStatsWithKeyContains("ChronoTimer" + item.ProductionBuildingName);
var buzyChronoedProdBuildings = stats.GetStatsWithKeyContains("ChronoBuzy" + item.ProductionBuildingName);
if (chronoedProdBuildings.Count > buzyChronoedProdBuildings.Count)
{
// Use free chronoed building with maximum chronoTimer
var chronoTimer = 0;
var buzyProdNames = buzyChronoedProdBuildings.Select(p => p.Key).ToList();
foreach (var chronoedProdBuilding in chronoedProdBuildings)
{
if (!buzyProdNames.Contains(chronoedProdBuilding.Key) && chronoedProdBuilding.Value > chronoTimer)
{
chronoTimer = chronoedProdBuilding.Value;
prodBuilding = chronoedProdBuilding.Key.Substring("ChronoTimer".Length);
}
}
}
return(prodBuilding);
}
public virtual void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
stats.Gas -= item.CostGas;
stats.Minerals -= item.CostMinerals;
}
