public IAreaConsumptionResult ConsumeZoneAt(IReadOnlyZoneInfo readOnlyZoneInfo, IAreaConsumption consumption)
{
var result = ConsumeZoneAtPrivate(readOnlyZoneInfo, consumption);
OnAreaConsumptionResult?.Invoke(this, new AreaConsumptionResultEventArgs(result));
/*if (consumption is IAreaZoneClusterConsumption)
* {
* foreach (
* var zoneInfo in
* (consumption as IAreaZoneClusterConsumption)
* .ZoneClusterMembers
* .Select(x => x.GetZoneInfo())
* .Where(x => x.HasMatch)
* .Select(x => x.MatchingObject))
* {
* ZoneInfoUpdated?.Invoke(this, new ZoneInfoEventArgs(zoneInfo));
*
* }
* }
* else
* {
* ZoneInfoUpdated?.Invoke(this, new ZoneInfoEventArgs(readOnlyZoneInfo));
* }*/
return(result);
}
public void Render(IReadOnlyZoneInfo zoneInfo, Rectangle rectangle, IGraphicsWrapper graphics)
{
_getDataMeterFunc.WithResultIfHasMatch(f =>
{
var dataMeterResult = f().GetDataMeterResult(zoneInfo);
var brush = BrushManager.Instance.GetBrushFor(dataMeterResult.ValueCategory);
if (brush.HasMatch)
{
graphics.FillRectangle(brush.MatchingObject, rectangle);
}
if (_toggleShowNumbersFunc())
{
var amount = dataMeterResult.Amount;
if (amount != 0)
{
graphics.FillRectangle(BrushManager.DarkNumberSurfaceBrush, rectangle);
graphics.DrawString(amount.ToString(),
BrushManager.ZoneInfoFont,
BrushManager.RedSolidBrush,
rectangle);
}
}
});
}
public ZoneRenderInfo(IReadOnlyZoneInfo zoneInfo, Func <IReadOnlyZoneInfo, Rectangle> createRectangle, ITilesetAccessor tilesetAccessor, RenderZoneOptions renderZoneOptions)
{
ZoneInfo = zoneInfo;
_createRectangle = createRectangle;
_tilesetAccessor = tilesetAccessor;
_renderZoneOptions = renderZoneOptions;
}
private static IEnumerable <IssueResult> GetIssueResults(IReadOnlyZoneInfo zoneInfo, Func <ZoneInfoDataMeter, bool> where)
{
return(DataMeterInstances
.DataMeters
.Where(where)
.Select(x => new IssueResult(x.Name, x.GetDataMeterResult(zoneInfo).PercentageScore))
.Where(x => x.IssueAmount > 0));
}
public static ClientZoneInfo Create(IReadOnlyZoneInfo zoneInfo)
=> new ClientZoneInfo
{
bitmapLayerOne = TilesetProvider
.GetAnimatedCellBitmapSetIdFor(zoneInfo, x => x.LayerOne),
bitmapLayerTwo = TilesetProvider
.GetAnimatedCellBitmapSetIdFor(zoneInfo, x => x.LayerTwo.WithResultIfHasMatch(y => y)),
x = zoneInfo.Point.X,
y = zoneInfo.Point.Y
};
public VehicleBitmapAndPoint(
VehicleBitmap bitmap,
IReadOnlyZoneInfo second,
IReadOnlyZoneInfo third,
IVehicle vehicle)
{
Bitmap = bitmap;
Second = second;
Third = third;
Vehicle = vehicle;
}
public static ClientDataMeterZoneInfo Create(IReadOnlyZoneInfo zoneInfo, ZoneInfoDataMeter zoneInfoDataMeter)
{
return(new ClientDataMeterZoneInfo
{
colour = BrushManager
.Instance
.GetBrushFor(zoneInfoDataMeter.GetDataMeterResult(zoneInfo).ValueCategory)
.WithResultIfHasMatch(brush => System.Drawing.ColorTranslator.ToHtml(brush.Color), string.Empty),
x = zoneInfo.Point.X,
y = zoneInfo.Point.Y
});
}
public static ClientDataMeterZoneInfo Create(IReadOnlyZoneInfo zoneInfo, ZoneInfoDataMeter zoneInfoDataMeter)
{
return(new ClientDataMeterZoneInfo
{
colour = DatameterColourDefinitions
.Instance
.GetColorFor(zoneInfoDataMeter.GetDataMeterResult(zoneInfo).ValueCategory)
.Pipe(x => x.HasValue ? x.Value.ToHex() : string.Empty),
x = zoneInfo.Point.X,
y = zoneInfo.Point.Y
});
}
private static int?GetScoreFor(IReadOnlyZoneInfo zoneInfo)
{
var consumption = zoneInfo.ZoneConsumptionState.GetZoneConsumption();
if (consumption is ZoneClusterMemberConsumption clusterMemberConsumption)
{
if (clusterMemberConsumption.ParentBaseZoneClusterConsumption is BaseGrowthZoneClusterConsumption)
{
return(clusterMemberConsumption.SingleCellCost);
}
}
return(null);
}
public QueryResult <IQueryLandValueResult> GetFor(IReadOnlyZoneInfo zoneInfo)
{
var score = GetScoreFor(zoneInfo);
if (!score.HasValue)
{
return(QueryResult <IQueryLandValueResult> .Create());
}
var newScore = GetIssueResults(zoneInfo, x => x.RepresentsIssue)
.Aggregate(
(decimal)score,
(currentScore, percentageScore) => currentScore / (1 + percentageScore.IssueAmount)
);
return(QueryResult <IQueryLandValueResult> .Create(new QueryLandValueResult((int)Math.Round(newScore))));
}
public IAreaConsumptionResult ConsumeZoneAt(IReadOnlyZoneInfo readOnlyZoneInfo, IAreaConsumption consumption)
{
if (_cityBudget.CurrentAmount < consumption.Cost && !_simulationOptions.ProcessOptions.GetIsMoneyCheatEnabled())
{
var insufficientFundsResult = new InsufficientFundsAreaConsumptionResult(consumption);
RaiseAreaHotMessageEvent("Insufficient funds", insufficientFundsResult.Message);
return(insufficientFundsResult);
}
var result = _area.ConsumeZoneAt(readOnlyZoneInfo, consumption);
if (result.Success)
{
_cityBudget.Handle(result);
}
return(result);
}
public static ClientAnimatedCellBitmapSet GetAnimatedCellBitmapSetIdFor(
IReadOnlyZoneInfo zoneInfo,
Func <AnimatedCellBitmapSetLayers, AnimatedCellBitmapSet> bitmapSelector)
{
var result = TextureAtlas.TilesetAccessor.TryGetBitmapFor(snapShot: zoneInfo.TakeSnapshot(), includeNoElectricity: true);
if (result.HasNoMatch)
{
return(default(ClientAnimatedCellBitmapSet));
}
var animatedCellBitmapSet = bitmapSelector(result.MatchingObject);
if (animatedCellBitmapSet == null)
{
return(default(ClientAnimatedCellBitmapSet));
}
return(new ClientAnimatedCellBitmapSet(
animatedCellBitmapSet.Id,
animatedCellBitmapSet.Delay,
animatedCellBitmapSet.Bitmaps.Select(x => x.Id).ToArray()));
}
private static bool IsSuitableForShip(IReadOnlyZoneInfo zoneInfo)
{
return(zoneInfo
.GetSurroundingZoneInfosDiamond(2)
.All(x => x.HasNoMatch || x.MatchingObject.ConsumptionState.GetIsWater()));
}
public QueryResult <IQueryLandValueResult> GetFor(IReadOnlyZoneInfo zoneInfo)
{
return(QueryResult <IQueryLandValueResult> .Empty);
}
public ZoneInfoEventArgs(IReadOnlyZoneInfo zoneInfo)
{
ZoneInfo = zoneInfo;
}
public DataMeterResult GetDataMeterResult(IReadOnlyZoneInfo zoneInfo)
{
return(GetDataMeterResult(_getValueCategoryFunc(zoneInfo)));
}
private IAreaConsumptionResult ConsumeZoneAtPrivate(IReadOnlyZoneInfo readOnlyZoneInfo,
IAreaConsumption consumption)
{
var zoneInfo = readOnlyZoneInfo as ZoneInfo;
if (zoneInfo == null)
{
throw new ArgumentNullException(nameof(readOnlyZoneInfo));
}
lock (_zoneConsumptionLock)
{
if (consumption is IAreaZoneConsumption)
{
var zoneClusterMember =
zoneInfo.ConsumptionState.GetZoneConsumption() as ZoneClusterMemberConsumption;
if (consumption is EmptyZoneConsumption && zoneClusterMember != null &&
zoneClusterMember.IsCentralClusterMember)
{
List <IConsumeAreaOperation> consumeAreaOperations = null;
zoneClusterMember.ParentBaseZoneClusterConsumption.WithUnlockedClusterMembers(() =>
{
consumeAreaOperations = zoneClusterMember
.ParentBaseZoneClusterConsumption
.ZoneClusterMembers
.Select(zoneMemberConsumption => _zoneInfoGrid
.GetZoneInfoFor(zoneMemberConsumption)
)
.Where(x => x.HasMatch)
.Select(clusterMemberZoneInfo => clusterMemberZoneInfo
.MatchingObject
.ConsumptionState
.TryConsumeWith(new RubbishZoneConsumption())
)
.ToList();
if (consumeAreaOperations.All(x => x.CanOverrideWithResult.WillSucceed))
{
foreach (var consumeAreaOperation in consumeAreaOperations)
{
consumeAreaOperation.Apply();
}
}
});
if (consumeAreaOperations == null)
{
throw new InvalidOperationException();
}
return(new AreaConsumptionResult(consumption, true, consumeAreaOperations.First().Description
));
}
var consumptionOperation = zoneInfo
.ConsumptionState
.TryConsumeWith(consumption as IAreaZoneConsumption);
if (consumptionOperation.CanOverrideWithResult.WillSucceed)
{
consumptionOperation.Apply();
}
return(new AreaConsumptionResult(consumption, consumptionOperation.CanOverrideWithResult.WillSucceed,
consumptionOperation.Description
));
}
if (consumption is IAreaZoneClusterConsumption)
{
var clusterZoneConsumption = consumption as IAreaZoneClusterConsumption;
var queryResults = clusterZoneConsumption
.ZoneClusterMembers
.Select(member =>
new
{
QueryResult = zoneInfo
.GetRelativeZoneInfo(new RelativeZoneInfoQuery(member.RelativeToParentCenterX,
member.RelativeToParentCenterY)),
ConsumptionZoneMember = member
}
)
.ToArray();
if (queryResults.Any(x => x.QueryResult.HasNoMatch))
{
return(new AreaConsumptionResult(consumption, false, "Cannot build across map boundaries."
));
}
var consumeAreaOperations = queryResults
.Select(x => x
.QueryResult
.MatchingObject
.ConsumptionState
.TryConsumeWith(x.ConsumptionZoneMember)
)
.ToArray();
if (consumeAreaOperations.All(x => x.CanOverrideWithResult.WillSucceed))
{
foreach (var consumeAreaOperation in consumeAreaOperations)
{
consumeAreaOperation.Apply();
}
return(new AreaConsumptionResult(consumption, true, consumeAreaOperations.First().Description));
}
return(new AreaConsumptionResult(consumption, false, string.Join(", ", consumeAreaOperations
.Where(x => !x.CanOverrideWithResult.WillSucceed)
.Select(x => x.Description)
.Distinct()
)
));
}
throw new InvalidOperationException();
}
}
