// Refined generate function for job demand
public void GenerateDemand(SimulatorInterfaces.IZoningData commData, SimulatorInterfaces.IZoningData resData)
{
// For identifying the senior household occupant index
int seniorIndex = (int)ResidentialSimulator.Constants.OccupantType.SENIOR;
// Calculate how many households have at least one employable person
// This is tentatively calculated as all households that are not classified as a senior household
int maxWorkforceFromHousing = resData.OccupantCount - resData.OccupantVector[seniorIndex];
EmployableMax = BaseDemandNoMatterWhat + maxWorkforceFromHousing;
// Divvy up the employable max among the different types of employment
// Since there's only commercial jobs, 100% of the employable max goes to commercial max
CommercialMax = EmployableMax;
// Calculate a delta; this delta is how far the current commercial occupant count is from the max
// From that delta, the increment is calculated
// This process would be repeated for other types of employment
int commercialDelta = CommercialMax - commData.OccupantCount;
CommercialIncrement = General.GenerateIncrement(commercialDelta);
// Limit demand to 1/16th of available openings, unless negative
if (CommercialIncrement > 0)
{
int maxIncrement = Mathf.CeilToInt((commData.OccupantMax - commData.OccupantCount) * General.MaxDemandPercentage);
CommercialIncrement = Mathf.Min(maxIncrement, CommercialIncrement);
}
}
// Alternate generate function for residential demand
// A much better metric for demand is how good the city's services are; the performance of these services will increase
// a base increment amount so that more people will want to move in.
public void GenerateDemand(SimulatorInterfaces.IZoningData resData, SimulatorInterfaces.ICivicData eduData, SimulatorInterfaces.ICivicData hlthData)
{
// To calculate school performance, divide the number of seats filled by the number of seats needed
// Any would-be divide-by-zero calculation will result in a zero instead
float overallSchoolPerformance = 0f;
for (int i = 0; i < eduData.SeatsFilled.Length; i++)
{
overallSchoolPerformance += CalculateCivicPerformance(eduData.SeatsFilled[i], eduData.SeatsNeeded[i]);
}
// The calculation for healthcare performance is largely the same
float overallHealthcarePerformance = 0f;
for (int i = 0; i < hlthData.SeatsFilled.Length; i++)
{
overallHealthcarePerformance += CalculateCivicPerformance(hlthData.SeatsFilled[i], eduData.SeatsNeeded[i]);
}
// If you can see where this is going, then this is what's happening
// Civic performance ranges on a scale going from [0, 1], and anywhere there is lackluster performance, that score
// will be less than 1; these numbers add up and result in the final overall performance score
float overallPerformance = Mathf.Abs(overallSchoolPerformance + overallHealthcarePerformance);
// Take the overall performance and multiply it by 1/4th the number of occupied households; that is the demand
// Use that demand with the previous demand calculations to get the increment amount
int maxResidentialFromCivicPerformance = Mathf.RoundToInt(resData.OccupantCount * overallPerformance / 4);
ResidentialMax = BaseDemandNoMatterWhat + maxResidentialFromCivicPerformance;
// Calculate a delta; this delta is how far the current residential occupant count is from the max
// From that delta, the increment is calculated
int residentialDelta = ResidentialMax - resData.OccupantCount;
ResidentialIncrement = General.GenerateIncrement(residentialDelta);
// Limit demand to 1/16th of available openings, unless negative
if (ResidentialIncrement > 0)
{
int maxIncrement = Mathf.CeilToInt((resData.OccupantMax - resData.OccupantCount) * General.MaxDemandPercentage);
ResidentialIncrement = Mathf.Min(maxIncrement, ResidentialIncrement);
}
}
// Refined generate function for residential demand
// One metric for residential demand is the maximum number of job openings
// Due to a change to how this is calculated, one unit of commercial occupancy translates to one household's worth
// of employment (IE, at least one person within the household is employed); along with a predetermined amount of base
// demand, this function will generate an increment that approaches that maximum demand
public void GenerateDemand(SimulatorInterfaces.IZoningData resData, SimulatorInterfaces.IZoningData commData)
{
// Calculate the maximum employable maximum across all job-generating simulators; this figure represents
// the maximum residential demand (since one unit of employment is one household)
// This calculation may be replaced due to some weird, undesirable behaviours; also, I'm kinda doubtful
// that commercial jobs alone can make people want to move in; basically, this calculation ain't necessarily
// ideal and I wanna one day replace this with something else; the one for the WorkEval is probably OK
int maxResidentialFromJobs = commData.OccupantMax;
ResidentialMax = BaseDemandNoMatterWhat + maxResidentialFromJobs;
// Calculate a delta; this delta is how far the current residential occupant count is from the max
// From that delta, the increment is calculated
int residentialDelta = ResidentialMax - resData.OccupantCount;
ResidentialIncrement = General.GenerateIncrement(residentialDelta);
// Limit demand to 1/16th of available openings, unless negative
if (ResidentialIncrement > 0)
{
int maxIncrement = Mathf.CeilToInt((resData.OccupantMax - resData.OccupantCount) * General.MaxDemandPercentage);
ResidentialIncrement = Mathf.Min(maxIncrement, ResidentialIncrement);
}
}
