/// <summary> /// Constructs a comparison that orders cells based on the amount of a particular /// resource type they generate for the argued city. /// </summary> /// <remarks> /// The effective yield is ordered from smallest expected yield to largest. /// Unlike <ref>CellComparisonUtil.BuildFocusedComparisonAscending</ref>, no /// additional comparisons are made beyond the yield of the specified resource /// </remarks> /// <param name="sourceCity">The city whose hypothetical yield is being considered</param> /// <param name="focusedYield">The YieldType to be maximized</param> /// <param name="generationLogic">The IResourceGenerationLogic used to determine the yield for the argued city</param> /// <returns>A Comparison that'll sort IHexCells from least to most yield of the focused resource</returns> public static Comparison <IHexCell> BuildYieldComparisonAscending( YieldType focusedYield, ICity sourceCity, IYieldGenerationLogic generationLogic ) { return(delegate(IHexCell firstCell, IHexCell secondCell) { var firstYield = generationLogic.GetYieldOfCellForCity(firstCell, sourceCity); var secondYield = generationLogic.GetYieldOfCellForCity(secondCell, sourceCity); return firstYield[focusedYield].CompareTo(secondYield[focusedYield]); }); }
/// <summary> /// Constructs a comparison that orders slots based on the amount of a particular /// resource type they generate for the argued city. /// </summary> /// <remarks> /// The effective yield is ordered from smallest expected yield to largest. /// Unlike <ref>SlotComparisonUtil.BuildFocusedComparisonAscending</ref>, no /// additional comparisons are made beyond the yield of the specified resource /// </remarks> /// <param name="sourceCity">The city whose hypothetical yield is being considered</param> /// <param name="focusedYield">The ResourceType to be maximized</param> /// <param name="generationLogic">The IResourceGenerationLogic used to determine the yield for the argued city</param> /// <returns>A Comparison that'll sort IWorkerSlots from least to most yield of the focused resource</returns> public static Comparison <IWorkerSlot> BuildYieldComparisonAscending( YieldType focusedYield, ICity sourceCity, IYieldGenerationLogic generationLogic ) { return(delegate(IWorkerSlot firstSlot, IWorkerSlot secondSlot) { var firstYield = GetSlotYield(firstSlot, sourceCity, generationLogic); var secondYield = GetSlotYield(secondSlot, sourceCity, generationLogic); return firstYield[focusedYield].CompareTo(secondYield[focusedYield]); }); }
public override double CalcYield(YieldType type, Tile tile) { double result = 0; // ReSharper disable once LoopCanBeConvertedToQuery - high frequenzy code! even tho its test code foreach (var modifer in _modifers) { if (modifer.IsApplicable(tile)) { result = modifer.Modify(type, tile, result); } } return(result); }
public float this[YieldType index] { get { switch (index) { case YieldType.Food: return(Food); case YieldType.Production: return(Production); case YieldType.Gold: return(Gold); case YieldType.Culture: return(Culture); case YieldType.Science: return(Science); case YieldType.GreatArtist: return(GreatArtist); case YieldType.GreatEngineer: return(GreatEngineer); case YieldType.GreatMerchant: return(GreatMerchant); case YieldType.GreatScientist: return(GreatScientist); default: throw new IndexOutOfRangeException(); } } set { switch (index) { case YieldType.Food: Food = value; break; case YieldType.Production: Production = value; break; case YieldType.Gold: Gold = value; break; case YieldType.Culture: Culture = value; break; case YieldType.Science: Science = value; break; case YieldType.GreatArtist: GreatArtist = value; break; case YieldType.GreatEngineer: GreatEngineer = value; break; case YieldType.GreatMerchant: GreatMerchant = value; break; case YieldType.GreatScientist: GreatScientist = value; break; default: throw new IndexOutOfRangeException(); } } }
private void BringYieldTypeToMin( YieldType type, float minYield, HomelandData homelandData, ref YieldSummary currentYield ) { float yieldDeficit = minYield - currentYield[type]; var strategyWeightsByRegion = new Dictionary <MapRegion, Dictionary <IBalanceStrategy, int> >(); foreach (var region in homelandData.AllRegions) { strategyWeightsByRegion[region] = homelandData.GetDataOfRegion(region).GetBalanceStrategyWeights(); } int iterations = homelandData.AllRegions.Count() * 10; List <MapRegion> regions = homelandData.AllRegions.ToList(); while (yieldDeficit > 0 && iterations-- > 0) { if (regions.Count == 0) { regions = homelandData.AllRegions.ToList(); } var region = regions.Random(); regions.Remove(region); var strategyWeights = strategyWeightsByRegion[region]; var strategy = GetStrategy(strategyWeights); YieldSummary yieldAdded; if (strategy.TryIncreaseYield(region, homelandData.GetDataOfRegion(region), type, out yieldAdded)) { yieldDeficit -= yieldAdded[type]; currentYield += yieldAdded; } } if (currentYield[type] < minYield) { Debug.LogWarningFormat("Failed to bring yield type {0} to min yield {1}", type, minYield); } }
public bool TryIncreaseYield( MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded ) { var availableResources = BonusResourcesWithYield[type].ToList(); while (availableResources.Count > 0) { var chosenResource = ResourceRandomSampler.SampleElementsFromSet( availableResources, 1, GetResourceSelectionWeightFunction(region, regionData) ).FirstOrDefault(); if (chosenResource == null) { break; } var cell = CellRandomSampler.SampleElementsFromSet( region.Cells, 1, GetCellPlacementWeightFunction(chosenResource) ).FirstOrDefault(); if (cell != null) { var oldYield = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs); int copies = chosenResource.Type == ResourceType.Strategic ? StrategicCopiesLogic.GetWeightedRandomCopies() : 0; ResourceNodeFactory.BuildNode(cell, chosenResource, copies); yieldAdded = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs) - oldYield; return(true); } else { availableResources.Remove(chosenResource); } } yieldAdded = YieldSummary.Empty; return(false); }
/// <summary> /// Constructs a comparison that orders cells based on the amount of a particular /// resource type they would generate for the argued city, with other considerations /// in case of ties. /// </summary> /// <remarks> /// The effective yield is ordered from the smallest expected yield to the largest. /// Ties are broken first by the amount of food the resources yield, then by total /// yield on the tile. Both tiebreakers are organized in ascending order /// </remarks> /// <param name="sourceCity">The city whose hypothetical yield is being considered</param> /// <param name="focusedResource">The ResourceType to be maximized</param> /// <param name="generationLogic">The IResourceGenerationLogic used to determine the yield for the argued city</param> /// <returns>A Comparison that'll sort IHexCells from least to most yield of the focused resource</returns> public static Comparison <IHexCell> BuildFocusedComparisonAscending(ICity sourceCity, YieldType focusedResource, IYieldGenerationLogic generationLogic) { return(delegate(IHexCell firstCell, IHexCell secondCell) { var firstYield = generationLogic.GetYieldOfCellForCity(firstCell, sourceCity); var secondYield = generationLogic.GetYieldOfCellForCity(secondCell, sourceCity); var focusComparison = firstYield[focusedResource].CompareTo(secondYield[focusedResource]); if (focusComparison == 0) { focusComparison = firstYield[YieldType.Food].CompareTo(secondYield[YieldType.Food]); } if (focusComparison == 0) { focusComparison = firstYield.Total.CompareTo(secondYield.Total); } return focusComparison; }); }
/// <summary> /// Constructs a comparison that orders slots based on the amount of a particular /// resource type they generate for the argued city. /// </summary> /// <remarks> /// The effective yield is ordered from the smallest expected yield to the largest. /// Ties are broken first by the amount of food the resources yield, then by total /// yield on the tile. Both tiebreakers are organized in ascending order /// </remarks> /// <param name="sourceCity">The city whose hypothetical yield is being considered</param> /// <param name="focusedResource">The ResourceType to be maximized</param> /// <param name="generationLogic">The IResourceGenerationLogic used to determine the yield for the argued city</param> /// <returns>A Comparison that'll sort IWorkerSlots from least to most yield of the focused resource</returns> public static Comparison <IWorkerSlot> BuildFocusedComparisonAscending(ICity sourceCity, YieldType focusedResource, IYieldGenerationLogic generationLogic) { return(delegate(IWorkerSlot firstSlot, IWorkerSlot secondSlot) { var firstYield = GetSlotYield(firstSlot, sourceCity, generationLogic); var secondYield = GetSlotYield(secondSlot, sourceCity, generationLogic); var focusComparison = firstYield[focusedResource].CompareTo(secondYield[focusedResource]); if (focusComparison == 0) { focusComparison = firstYield[YieldType.Food].CompareTo(secondYield[YieldType.Food]); } if (focusComparison == 0) { focusComparison = firstYield.Total.CompareTo(secondYield.Total); } return focusComparison; }); }
public bool TryIncreaseYield( MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded ) { if (type != YieldType.Food) { yieldAdded = YieldSummary.Empty; return(false); } var candidates = region.Cells.Where(GetLakeCandidateFilter(region)); if (candidates.Any()) { var newLake = candidates.Random(); var oldYields = new Dictionary <IHexCell, YieldSummary>(); foreach (var cell in Grid.GetCellsInRadius(newLake, 1)) { oldYields[cell] = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs); } ModLogic.ChangeTerrainOfCell(newLake, CellTerrain.FreshWater); yieldAdded = YieldSummary.Empty; foreach (var cell in oldYields.Keys) { yieldAdded += YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs) - oldYields[cell]; } return(true); } else { yieldAdded = YieldSummary.Empty; return(false); } }
public bool TryIncreaseYield( MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded ) { yieldAdded = YieldSummary.Empty; if (type != YieldType.Food && type != YieldType.Gold) { return(false); } var newOasis = CellRandomSampler.SampleElementsFromSet( region.LandCells, 1, GetOasisCandidateWeightFunction(region) ).FirstOrDefault(); if (newOasis == null) { return(false); } var oldYields = new Dictionary <IHexCell, YieldSummary>(); foreach (var cell in Grid.GetCellsInRadius(newOasis, 1)) { oldYields[cell] = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs); } ModLogic.ChangeFeatureOfCell(newOasis, CellFeature.Oasis); yieldAdded = YieldSummary.Empty; foreach (var cell in oldYields.Keys) { yieldAdded += YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs) - oldYields[cell]; } return(true); }
public bool TryIncreaseYield(MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded) { yieldAdded = YieldSummary.Empty; return(false); }
public override double Modify(YieldType type, Tile tile, double input) { return(input + Modifiers[type.Index]); }
public BuildingYieldChange(YieldType yieldType, float byHowMuch) { this.yieldType = yieldType; this.byHowMuch = byHowMuch; }
void DispatchYield(IEnumerator runner, object yieldResult) { if (!_active) { return; } if (yieldResult is YieldType) { YieldType y = (YieldType)yieldResult; switch (y.id) { case KEY_UPDATE: AddTo(runner, _updateQueue); break; case KEY_FIXED: AddTo(runner, _fixedQueue); break; case KEY_LATE: AddTo(runner, _lateQueue); break; case KEY_ANY: AddTo(runner, _anyMainQueue); break; case KEY_ASYN: AddTo(runner, _asynQueue); break; default: Debug.LogError("yield result id error=====>" + y.id); break; } } else if (yieldResult is float || yieldResult is int) { float nextTime = (float)yieldResult + _time; lock (_timer) { int i = _timer.Count - 1; while (i >= 0) { if (nextTime < _timer[i]) { break; } i--; } i++; if (i == _timer.Count) { _timer.Add(nextTime); _timeRunner.Add(runner); } else { _timer.Insert(i, nextTime); _timeRunner.Insert(i, runner); } } } else { Debug.LogError("yield result id error=====>" + yieldResult.GetType().FullName + ":" + yieldResult.ToString()); } }