public override void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
var resourceChange = this.GetResourceChangeForPeriod(1, stats);
stats.Minerals += resourceChange.Minerals;
stats.Gas += resourceChange.Gas;
}
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);
}
}
}
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 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 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);
}
public void AdjustModulesStatsForStep(BuildItemStatistics stats)
{
foreach (var stepModule in this)
{
stepModule.AdjustModuleStatsForStep(stats);
}
}
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)));
}
public void DoAction(BuildItemStatistics statistics)
{
var currentCompareValue = statistics.GetStatValueByName(this.CompareStatisticName);
if (currentCompareValue == CompareValue)
{
statistics.ChangeItemCountForName(this.TargetStatisticName, this.ChangeValue);
}
}
private int GetGasPerMinute(BuildItemStatistics basePointStats)
{
return(this.CalculateResourcePerMinute(
basePointStats.BasesCount,
this.BuildManagerConfiguration.GlobalConstants.GasPatchesPerBase,
basePointStats.WorkersOnGas,
this.BuildManagerConfiguration.GlobalConstants.GasPerMinuteFrom3WorkersPerPatch,
this.BuildManagerConfiguration.GlobalConstants.GasPerMinuteFrom2WorkersPerPatch,
this.BuildManagerConfiguration.GlobalConstants.GasPerMinuteFrom1WorkerPerPatch));
}
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 void RunActions(List <IBuildItemAction> actions, BuildItemStatistics stats)
{
if (actions == null || actions.Count == 0)
{
return;
}
foreach (var action in actions)
{
action.DoAction(stats);
}
}
private ResourcesEntity GetResourceChangeForPeriod(int secondsInPeriod, BuildItemStatistics basePointStats)
{
var mineralsPerMinute = this.GetMineralsPerMinute(basePointStats);
var gasPerMinute = this.GetGasPerMinute(basePointStats);
var incomeInfo = new ResourcesEntity
{
Minerals = this.GetAdjustedWithMilliResourcePerPeriod(mineralsPerMinute, secondsInPeriod, Consts.CoreStatistics.MilliMinerals, basePointStats),
Gas = this.GetAdjustedWithMilliResourcePerPeriod(gasPerMinute, secondsInPeriod, Consts.CoreStatistics.MilliGas, basePointStats)
};
return(incomeInfo);
}
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));
}
}
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 AdjustModuleStatsForStep(BuildItemStatistics stats)
{
var startIdle = stats.GetStatValueByName(StartIdle);
if (startIdle > 0)
{
stats.ChangeItemCountForName(IdleTimer, 1);
}
else
{
stats.SetItemCountForName(IdleTimer, 0);
}
}
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);
}
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 int GetMineralsPerMinute(BuildItemStatistics basePointStats)
{
int result = this.CalculateResourcePerMinute(
basePointStats.BasesCount,
this.BuildManagerConfiguration.GlobalConstants.MineralsPatchesPerBase,
basePointStats.WorkersOnMinerals,
this.BuildManagerConfiguration.GlobalConstants.MineralsPerMinuteFrom3WorkersPerPatch,
this.BuildManagerConfiguration.GlobalConstants.MineralsPerMinuteFrom2WorkersPerPatch,
this.BuildManagerConfiguration.GlobalConstants.MineralsPerMinuteFrom1WorkerPerPatch);
if (basePointStats.MulesOnMinerals > 0)
{
result += basePointStats.MulesOnMinerals *
this.BuildManagerConfiguration.GlobalConstants.MineralsPerMinuteFrom1Mule;
}
return(result);
}
private void AdjustStatisticsByFinishedItems(int currentSecond, BuildItemStatistics currentStatistics)
{
var finishedItems = this.mBuildOrder.GetFinishedItemsClone(currentSecond);
if (finishedItems.Count == 0)
{
return;
}
foreach (var buildOrderItem in finishedItems)
{
var buildItem = this.mConfig.BuildItemsDictionary.GetItem(buildOrderItem.ItemName);
this.RunActions(buildItem.ProducedActions, currentStatistics);
}
this.mConfig.BuildManagerModules.AdjustModelStatsByFinishedItems(finishedItems, currentStatistics);
}
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);
}
public bool IsRequirementSatisfied(BuildItemStatistics stats)
{
if (this.LeftBuildItemRequirement == null && this.RightBuildItemRequirement != null)
{
return(this.RightBuildItemRequirement.IsRequirementSatisfied(stats));
}
if (this.LeftBuildItemRequirement != null && this.RightBuildItemRequirement == null)
{
return(this.LeftBuildItemRequirement.IsRequirementSatisfied(stats));
}
if (this.LeftBuildItemRequirement != null && this.RightBuildItemRequirement != null)
{
return(this.LeftBuildItemRequirement.IsRequirementSatisfied(stats) ||
this.RightBuildItemRequirement.IsRequirementSatisfied(stats));
}
return(true);
}
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 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.");
}
}
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 virtual void AdjustModuleStatsByFinishedItems(IEnumerable <BuildOrderProcessorItem> finishedItems, BuildItemStatistics stats)
{
}
public virtual void AdjustModuleStatsByStartedItem(BuildOrderProcessorItem boItem, BuildItemEntity item, BuildItemStatistics stats)
{
}
public virtual void AdjustModuleStatsForStep(BuildItemStatistics stats)
{
}
