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; }