private int GetAdjustedWithMilliResourcePerPeriod(int resourcePerMinute, int secondsInPeriod,
string milliResourceStatName,
BuildItemStatistics basePointStats)
{
int resultResource = 0;
if (resourcePerMinute < 60)
{
int milliValue = (resourcePerMinute * 100 / 60);
basePointStats.ChangeItemCountForName(milliResourceStatName, milliValue);
if (basePointStats.GetStatValueByName(milliResourceStatName) > 100)
{
resultResource = 1;
basePointStats.ChangeItemCountForName(milliResourceStatName, -100);
}
}
else
{
resultResource = resourcePerMinute > 0 ? (resourcePerMinute / 60) * secondsInPeriod : 0;
var milliValue = resourcePerMinute - resultResource * 60;
basePointStats.ChangeItemCountForName(milliResourceStatName, milliValue);
if (basePointStats.GetStatValueByName(milliResourceStatName) > 100)
{
resultResource++;
basePointStats.ChangeItemCountForName(milliResourceStatName, -100);
}
}
return(resultResource);
}
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 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);
}
public void DoAction(BuildItemStatistics statistics)
{
int valueToAdd = this.ChangeValue;
if (!string.IsNullOrEmpty(this.LimitStatisticName))
{
var previousValue = statistics.GetStatValueByName(this.TargetStatisticName);
var limitStatValue = statistics.GetStatValueByName(this.LimitStatisticName);
if (previousValue + this.ChangeValue > limitStatValue)
{
valueToAdd = limitStatValue - previousValue;
}
}
statistics.ChangeItemCountForName(this.TargetStatisticName, valueToAdd);
}
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");
}
}
}
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);
}
public void DoAction(BuildItemStatistics statistics)
{
var currentCompareValue = statistics.GetStatValueByName(this.CompareStatisticName);
if (currentCompareValue == CompareValue)
{
statistics.ChangeItemCountForName(this.TargetStatisticName, this.ChangeValue);
}
}
public override void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
var startIdle = stats.GetStatValueByName(StartIdle);
if (startIdle == 0)
{
stats.SetItemCountForName(IdleTimer, 0);
}
}
public override void AdjustModuleStatsByFinishedItems(IEnumerable <BuildOrderProcessorItem> finishedItems, BuildItemStatistics stats)
{
foreach (var item in finishedItems)
{
if (item.ItemName == "Nexus")
{
stats.ChangeItemCountForName("BoostedNexusCount", 1);
continue;
}
var entity = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem(item.ItemName);
if (entity.ProductionBuildingName == "Nexus")
{
int initialBuildTime = entity.BuildTimeInSeconds;
int realBuildTime = item.FinishedSecond - item.SecondInTimeLine;
if (realBuildTime < initialBuildTime)
{
stats.ChangeItemCountForName("NexusBoostedBuzy", -1);
}
}
}
var chronoTimers = stats.GetStatsWithKeyContains("ChronoTimer");
foreach (var timer in chronoTimers)
{
if (timer.Value == 0)
{
var boostedNexusCount = stats.GetStatValueByName("BoostedNexusCount");
var nexusCount = stats.GetStatValueByName("Nexus");
if (nexusCount > boostedNexusCount)
{
stats.ChangeItemCountForName("BoostedNexusCount", 1);
// recalculate current building item from unboosted nexus
}
stats.RemoveStat(timer.Key);
}
}
}
public override void AdjustModuleStatsByFinishedItems(IEnumerable <BuildOrderProcessorItem> finishedItems, BuildItemStatistics stats)
{
var finishedHatcheries = finishedItems.Where(p => p.ItemName == "Hatchery").ToList();
int hatcheryCount = stats.GetStatValueByName("Hatchery");
foreach (var finishedHatchery in finishedHatcheries)
{
var hatchOrder = finishedHatchery.ItemName + (hatcheryCount++).ToString(CultureInfo.InvariantCulture);
stats.SetItemCountForName(hatchOrder + "LarvaCount", 1);
stats.SetItemCountForName(hatchOrder + "LarvaTimer", 0);
}
}
private void ChangeTimerForItems(IEnumerable <KeyValuePair <string, int> > list, BuildItemStatistics stats)
{
foreach (var prodBuilding in list)
{
stats.ChangeItemCountForName(prodBuilding.Key, -1);
if (stats.GetStatValueByName(prodBuilding.Key) == 0)
{
stats.RemoveStat(prodBuilding.Key);
}
}
}
public override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
var startIdle = stats.GetStatValueByName(StartIdle);
if (startIdle > 0)
{
stats.ChangeItemCountForName(IdleTimer, 1);
}
else
{
stats.SetItemCountForName(IdleTimer, 0);
}
}
public override void AdjustModuleStatsByFinishedItems(IEnumerable <BuildOrderProcessorItem> finishedItems, BuildItemStatistics stats)
{
var finishedenergyGenerators = finishedItems.Where(p => p.ItemName == this.BuildManagerConfiguration.RaceConstants.EnergyGeneratorBuildItemName).ToList();
if (finishedenergyGenerators.Count == 0)
{
return;
}
int energyGeneratorCount = stats.GetStatValueByName(this.BuildManagerConfiguration.RaceConstants.EnergyGeneratorBuildItemName);
foreach (var finishedGenerator in finishedenergyGenerators)
{
var energyGeneratorOrder = finishedGenerator.ItemName + (energyGeneratorCount++).ToString(CultureInfo.InvariantCulture);
stats.SetItemCountForName(energyGeneratorOrder + CastCount, this.BuildManagerConfiguration.RaceConstants.EnergyCastCountForNewEnergyGenerator);
stats.SetItemCountForName(energyGeneratorOrder + CastTimer, 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);
}
}
private bool IsChronoboostPossibleWhileBuilding(int buildTime, BuildItemStatistics stats, out int secondsToPossibleChronoboost)
{
var castModule = this.BuildManagerConfiguration.BuildManagerModules.First(p => p is CastModule);
var tempStats = new BuildItemStatistics(this.BuildManagerConfiguration.RaceConstants, stats.CloneItemsCountDictionary());
for (int i = 0; i < buildTime; i++)
{
castModule.AdjustModuleStatsForStep(tempStats);
if (tempStats.GetStatValueByName(CastModule.TotalCasts) > 0)
{
secondsToPossibleChronoboost = i;
return(true);
}
}
secondsToPossibleChronoboost = 0;
return(false);
}
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 void UseCast(BuildItemStatistics stats)
{
var castCounts = stats.GetStatsWithKeyContains(CastCount);
string castBuilding = string.Empty;
int castCountValue = 0;
foreach (var castCount in castCounts)
{
if (castCount.Value >= 1)
{
castBuilding = castCount.Key;
castCountValue = castCount.Value;
break;
}
}
if (string.IsNullOrEmpty(castBuilding))
{
var castTimers = stats.GetStatsWithKeyContains(CastTimer);
if (castTimers.Count == 0)
{
throw new ApplicationException("Energy generators are unavailable");
}
var maxTimer = castTimers.Max(p => p.Value);
castBuilding = castTimers.First(p => p.Value == maxTimer).Key;
castBuilding = castBuilding.Substring(0, castBuilding.Length - CastTimer.Length);
castCountValue = stats.GetStatValueByName(castBuilding + CastCount);
castBuilding = castBuilding + CastCount;
}
stats.SetItemCountForName(castBuilding, castCountValue - 1);
this.ResetTotalCast(stats);
}
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 bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName("TotalLarva") >= this.RequiredValue);
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName(this.LeftStatName) >= (stats.GetStatValueByName(this.RightStatName) + this.AdditionValue));
}
public void DoAction(BuildItemStatistics statistics)
{
var sourceValue = statistics.GetStatValueByName(this.SourceStatisticName);
statistics.ChangeItemCountForName(this.TargetStatisticName, sourceValue);
}
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 bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName(this.TargetItemName) > 0 || stats.GetStatValueByName(this.TargetItemName + Consts.BuildItemOnBuildingPostfix) > 0);
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName(this.TargetStatName) >= this.Value);
}
public override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
var larvaTimers = stats.GetStatsWithKeyContains("LarvaTimer");
var larvaCounts = stats.GetStatsWithKeyContains("LarvaCount");
var injectedTimer = stats.GetStatsWithKeyContains("InjectedTimer");
if (larvaTimers.Count == 0 && injectedTimer.Count == 0)
{
return;
}
foreach (var timer in larvaTimers)
{
var hatcheryName = timer.Key.Substring(0, timer.Key.Length - "LarvaTimer".Length);
var larvaCountStat = larvaCounts.FirstOrDefault(p => p.Key.Contains(hatcheryName));
if (larvaCountStat.Value < 3)
{
stats.ChangeItemCountForName(timer.Key, 1);
}
else
{
stats.SetItemCountForName(timer.Key, 0);
}
var newTime = stats.GetStatValueByName(timer.Key);
if (newTime == SpawnLarvaTime)
{
stats.ChangeItemCountForName(larvaCountStat.Key, 1);
stats.SetItemCountForName(timer.Key, 0);
}
}
foreach (var injectTimer in injectedTimer)
{
string hatcheryName = injectTimer.Key.Substring(0, injectTimer.Key.Length - "InjectedTimer".Length);
int larvaCount = stats.GetStatValueByName(hatcheryName + "LarvaCount");
stats.ChangeItemCountForName(hatcheryName + "InjectedTimer", 1);
var newInjectTimerValue = stats.GetStatValueByName(injectTimer.Key);
int injectTime = this.BuildManagerConfiguration.BuildItemsDictionary.GetItem("InjectLarva").BuildTimeInSeconds;
if (newInjectTimerValue > injectTime)
{
int larvaChange = InjectedLarvaAdd;
if ((larvaCount + larvaChange) > 19)
{
larvaChange = 19 - larvaCount;
}
stats.ChangeItemCountForName(hatcheryName + "LarvaCount", larvaChange);
stats.ChangeItemCountForName("TotalLarva", larvaChange);
stats.RemoveStat(hatcheryName + "InjectedTimer");
}
}
this.ResetTotalLarva(stats);
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName(CastModule.TotalCasts) >= this.RequiredValue);
}
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);
}
}
private int CalculateAddition(BuildItemStatistics statistics, IEnumerable <string> statsToAddition)
{
return(statsToAddition.Sum(stat => statistics.GetStatValueByName(stat)));
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName(this.LeftStatistic) < stats.GetStatValueByName(this.RightStatistic));
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
return(stats.GetStatValueByName("IdleSeconds") == 0);
}
