public override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
// if boost timer completed -> move it to not boosted nexus back and recalculate building time for currently building item
var chronoTimers = stats.GetStatsWithKeyContains("ChronoTimer");
foreach (var timer in chronoTimers)
{
if (timer.Value != 0)
{
stats.ChangeItemCountForName(timer.Key, -1);
}
}
var chronoBuzyTimers = stats.GetStatsWithKeyContains("ChronoBuzyTimer");
foreach (var timer in chronoBuzyTimers)
{
if (timer.Value != 0)
{
stats.ChangeItemCountForName(timer.Key, -1);
}
else
{
stats.ChangeItemCountForName("NexusBoostedBuzy", 1);
stats.RemoveStat(timer.Key);
}
}
}
public override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
var castTimers = stats.GetStatsWithKeyContains(CastTimer);
var castCounts = stats.GetStatsWithKeyContains(CastCount);
if (castTimers.Count == 0)
{
return;
}
foreach (var timer in castTimers)
{
var nexusName = timer.Key.Substring(0, timer.Key.Length - CastTimer.Length);
var castCountStat = castCounts.FirstOrDefault(p => p.Key.Contains(nexusName));
int castTimer = timer.Value;
if (castCountStat.Value < this.BuildManagerConfiguration.RaceConstants.EnergyCastLimitPerEnergyGenerator)
{
stats.ChangeItemCountForName(timer.Key, 1);
}
if (castTimer == this.BuildManagerConfiguration.RaceConstants.EnergyCastGenerateTime)
{
stats.ChangeItemCountForName(castCountStat.Key, 1);
stats.SetItemCountForName(timer.Key, 0);
}
}
this.ResetTotalCast(stats);
}
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);
}
private void ResetTotalLarva(BuildItemStatistics stats)
{
var larvaCounts = stats.GetStatsWithKeyContains("LarvaCount");
if (larvaCounts.Count == 0)
{
stats.SetItemCountForName("TotalLarva", 0);
}
else
{
stats.SetItemCountForName("TotalLarva", larvaCounts.Sum(p => p.Value));
}
}
private void ResetTotalCast(BuildItemStatistics stats)
{
var castCounts = stats.GetStatsWithKeyContains(CastCount);
if (castCounts.Count == 0)
{
stats.SetItemCountForName(TotalCasts, 0);
}
else
{
stats.SetItemCountForName(TotalCasts, castCounts.Sum(p => p.Value));
}
}
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 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 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 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)
{
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 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 override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
this.ChangeTimerForItems(stats.GetStatsWithKeyContains("ChronoTimer"), stats);
this.ChangeTimerForItems(stats.GetStatsWithKeyContains("ChronoBuzy"), stats);
this.ChangeTimerForItems(stats.GetStatsWithKeyContains("NormalBuzy"), stats);
}
