private static Bundle GetBestPlayground(Upgrade upgrade, GameLayer layer)
{
var state = layer.GetState();
Position pos = new Position(0, 0);
BuiltResidenceBuilding building = null;
int turnsleft = state.MaxTurns - state.Turn;
int popAffected = 0;
foreach (var build in state.ResidenceBuildings)
{
if (!build.Effects.Contains(upgrade.Name) && popAffected < layer.GetResidenceBlueprint(build.BuildingName).MaxPop)
{
building = build;
popAffected = layer.GetResidenceBlueprint(build.BuildingName).MaxPop;
pos = build.Position;
}
}
if (building == null)
{
return(null);
}
var b = new Bundle
{
EnergyNeed = 0,
ExtraCost = 0,
PotentialScore = popAffected * turnsleft * 0.16 / 10 + 0.007 * popAffected * turnsleft,
TotalIncome = 0,
Turn = new UpgradeTurn(pos.x, pos.y, upgrade.Name, state.GameId),
UpfrontCost = 5200
};
return(b);
}
private static Bundle GetBestCaretaker(Upgrade upgrade, GameLayer layer)
{
var state = layer.GetState();
Position pos = new Position(0, 0);
BuiltResidenceBuilding building = null;
int turnsleft = state.MaxTurns - state.Turn;
double save = 0;
foreach (var build in state.ResidenceBuildings)
{
double maintCost = layer.GetResidenceBlueprint(build.BuildingName).MaintenanceCost;
double decayRate = layer.GetResidenceBlueprint(build.BuildingName).DecayRate + build.Effects.Where(t => t == "Charger" || t == "Regulator" || t == "Playground" || t == "SolarPanel" || t == "Insulation").Count() * 0.2;
if (!build.Effects.Contains(upgrade.Name) && save < maintCost * Math.Ceiling(turnsleft / (55 / decayRate)) - maintCost * Math.Ceiling(turnsleft * 0.25 / (55 / decayRate)) - 6 * turnsleft - 3500)
{
building = build;
pos = build.Position;
save = maintCost * Math.Ceiling(turnsleft / (55 / decayRate)) - maintCost * Math.Ceiling(turnsleft * 0.25 / (55 / decayRate)) - 6 * turnsleft - 3500;
}
}
if (building == null)
{
return(null);
}
var b = new Bundle
{
EnergyNeed = 0,
ExtraCost = 6 * turnsleft,
PotentialScore = 0,
TotalIncome = save + 6 * turnsleft + 3500,
Turn = new UpgradeTurn(pos.x, pos.y, upgrade.Name, state.GameId),
UpfrontCost = 3500
};
return(b);
}
private static double GetNextTemp(BuiltResidenceBuilding building, GameLayer gameLayer)
{
return
(building.Temperature +
(building.EffectiveEnergyIn - gameLayer.GetResidenceBlueprint(building.BuildingName).BaseEnergyNeed) * Constants.DEGREES_PER_EXCESS_MWH +
Constants.DEGREES_PER_POP * building.CurrentPop -
(building.Temperature - gameLayer.GetState().CurrentTemp) * (gameLayer.GetResidenceBlueprint(building.BuildingName).Emissivity *(building.Effects.Contains("Insulation") ? 0.6 : 1)));
}
private static Bundle GetBestInsulation(Upgrade upgrade, GameLayer layer)
{
var state = layer.GetState();
Position pos = new Position(0, 0);
BuiltResidenceBuilding building = null;
return(null);
}
//newTemp = indoorTemp + (effectiveEnergyIn - baseEnergyNeed) * degreesPerExcessMwh + degreesPerPop * currentPop - (indoorTemp - outdoorTemp) * emissivity
private static double OptimalEnergy(double targetIndoorTemp, BuiltResidenceBuilding building, GameLayer layer, double outTemp)
{
var state = layer.GetState();
double A = (state.MaxTemp - state.MinTemp) / 2.0;
double B = Math.PI * 2 / 183.0;
double C = A + state.MinTemp;
double baseEnergy = layer.GetResidenceBlueprint(building.BuildingName).BaseEnergyNeed + (building.Effects.Contains("Charger") ? 1.8 : 0);
double ret =
(((targetIndoorTemp - outTemp) * (layer.GetResidenceBlueprint(building.BuildingName).Emissivity *(building.Effects.Contains("Insulation") ? 0.6 : 1))) -
Constants.DEGREES_PER_POP * building.CurrentPop) / Constants.DEGREES_PER_EXCESS_MWH +
baseEnergy;
return(ret);
}
private static double GetNextEnergy(BuiltResidenceBuilding building, GameLayer layer)
{
var state = layer.GetState();
double A = (state.MaxTemp - state.MinTemp) / 2.0;
double B = Math.PI * 2 / 183.0;
double C = A + state.MinTemp;
double minEnergy = layer.GetResidenceBlueprint(building.BuildingName).BaseEnergyNeed + ((building.Effects.Contains("Charger") ? 1.8 : 0));
if ((((state.Turn + 10) % 193) < 87))
{
return(OptimalEnergy(22.5, building, layer, Math.Max(state.CurrentTemp, state.MinTemp)));
}
else
{
return(OptimalEnergy(19.5, building, layer, Math.Min(state.CurrentTemp, state.MaxTemp)));
}
}
private static Bundle GetBestSolarPanel(Upgrade upgrade, GameLayer layer)
{
var state = layer.GetState();
Position pos = new Position(0, 0);
BuiltResidenceBuilding building = null;
int turnsleft = state.MaxTurns - state.Turn;
double energySaved = 0;
foreach (var build in state.ResidenceBuildings)
{
if (!build.Effects.Contains(upgrade.Name) && (build.EffectiveEnergyIn - (build.Effects.Contains("WindTurbine") ? 3.4 : 0) + (build.Effects.Contains("Charger") ? 1.8 : 0)) > energySaved)
{
building = build;
pos = build.Position;
energySaved = Math.Max(Math.Min(build.EffectiveEnergyIn - (build.Effects.Contains("WindTurbine") ? 3.4 : 0) + (build.Effects.Contains("Charger") ? 1.8 : 0), 3.4), 0);
}
}
if (building == null)
{
return(null);
}
double consu = Helper.GetEnergyConsumation(layer) - energySaved;
var levelNow = Helper.GetEnergyLevel(layer, consu);
var levelPrev = Helper.GetEnergyLevel(layer);
double score = energySaved * levelNow.TonCo2PerMwh * turnsleft;
var b = new Bundle
{
EnergyNeed = -energySaved,
ExtraCost = 0,
PotentialScore = score,
TotalIncome = energySaved * levelNow.CostPerMwh * turnsleft,
Turn = new UpgradeTurn(pos.x, pos.y, upgrade.Name, state.GameId),
UpfrontCost = 6800
};
return(b);
}
public static IEnumerable <Bundle> GetBestPlaceBuildingTurnBundles(GameLayer gameLayer)
{
foreach (var building in gameLayer.GetState().AvailableResidenceBuildings)
{
if (building.ReleaseTick > gameLayer.GetState().Turn)
{
continue;
}
var b = PlaceBuildingTurnFactory.GetBestResidenceBundle(building, gameLayer);
if (b == null)
{
if (gameLayer.GetState().HousingQueue > Constants.LONG_QUEUE)
{
BuiltResidenceBuilding bui = null;
double best = 200;
foreach (var build in gameLayer.GetState().ResidenceBuildings)
{
if (!build.CanBeDemolished || build.CurrentPop != gameLayer.GetResidenceBlueprint(build.BuildingName).MaxPop || gameLayer.GetState().ResidenceBuildings.Where(t => t.BuildingName == build.BuildingName).Count() == 1)
{
continue;
}
if (best > gameLayer.GetResidenceBlueprint(build.BuildingName).MaxHappiness *gameLayer.GetResidenceBlueprint(build.BuildingName).MaxPop)
{
best = gameLayer.GetResidenceBlueprint(build.BuildingName).MaxHappiness *gameLayer.GetResidenceBlueprint(build.BuildingName).MaxPop;
bui = build;
}
}
if (bui != null && best < 30 && gameLayer.GetState().Funds > 15000 && gameLayer.GetState().Turn < 550)
{
Console.WriteLine("Demolish");
Program.StackedTurns.Push(new DemolishTurn(bui.Position.x, bui.Position.y, gameLayer.GetState().GameId));
}
}
break;
}
b.Residence = building;
yield return(b);
}
}
private static Bundle GetBestCharger(Upgrade upgrade, GameLayer layer)
{
var state = layer.GetState();
Position pos = new Position(0, 0);
BuiltResidenceBuilding building = null;
int turnsleft = state.MaxTurns - state.Turn;
int popAffected = 0;
foreach (var build in state.ResidenceBuildings)
{
if (build.Effects.Contains("Mall.2") && !build.Effects.Contains(upgrade.Name) && popAffected < layer.GetResidenceBlueprint(build.BuildingName).MaxPop)
{
building = build;
pos = build.Position;
popAffected = layer.GetResidenceBlueprint(build.BuildingName).MaxPop;
}
}
if (building == null)
{
return(null);
}
double consu = Helper.GetEnergyConsumation(layer) + 1.8;
var levelNow = Helper.GetEnergyLevel(layer, consu);
var b = new Bundle
{
EnergyNeed = 1.8,
ExtraCost = 1.8 * turnsleft * levelNow.CostPerMwh,
PotentialScore = popAffected * 0.016 * turnsleft - 1.8 * turnsleft * levelNow.TonCo2PerMwh,
TotalIncome = 0,
Turn = new UpgradeTurn(pos.x, pos.y, upgrade.Name, state.GameId),
UpfrontCost = 3400
};
return(b);
}
