public void Take_turn(string gameId)
{
//Vi skapar "Urgency values" som alltid ska refleketera hur viktigt något är att göra denna tur.
//Dessa använder vi sen för att väljav vilken handling vi tar.
//Måste även implementera en "value map" som beräknar vilka platser på kartan som är mest
//Värdefulla att bygga hushåll alternativt utilities på.
//Tex så är ju platser utan många angrändsande platser attraktiva för vindkraftverk
//och platser med många rutor nära varandra attraktiva för ställen med områdeseffekter.
// TODO Implement your artificial intelligence here.
// TODO Taking one action per turn until the game ends.
// TODO The following is a short example of how to use the StarterKit
GameState state = GameLayer.GetState();
//Urgency values
int startBuildValue = config.StartBuildValue;
int buildValue = config.BuildValue;
int repairValue = config.RepairValue;
int temperatureValue = config.TemperatureValue;
int waitValue = config.WaitValue;
List <UrgencyValue> urgencyValues = new List <UrgencyValue>();
UrgencyValue StartBuildTask = new UrgencyValue(startBuildValue, GameTask.StartBuild);
urgencyValues.Add(StartBuildTask);
UrgencyValue BuildTask = new UrgencyValue(buildValue, GameTask.Build);
urgencyValues.Add(BuildTask);
//implementera start värde
UrgencyValue UtilityTask = new UrgencyValue(0, GameTask.BuildUtility);
urgencyValues.Add(UtilityTask);
UrgencyValue UpgradetTask = new UrgencyValue(0, GameTask.Upgrade);
urgencyValues.Add(UpgradetTask);
UrgencyValue RepairTask = new UrgencyValue(repairValue, GameTask.Repair);
urgencyValues.Add(RepairTask);
UrgencyValue TemperatureTask = new UrgencyValue(temperatureValue, GameTask.ChangeTemperature);
urgencyValues.Add(TemperatureTask);
UrgencyValue WaitTask = new UrgencyValue(waitValue, GameTask.Wait);
urgencyValues.Add(WaitTask);
//Evaluate neccissity of every task
//start build
if (ResidencePositions.Count == 0 && UtilityPositions.Count == 0)
{
//Gör ingenting
}
else if (state.ResidenceBuildings.Count < config.NumberOfResidenceBuildings)
{
StartBuildTask.Value = 70;
}
else if (state.Funds > config.FundsLevelBuildHouse && state.HousingQueue > config.HousingQueue)
{
StartBuildTask.Value = 40;
}
//Utility buildings
else if (UtilityPositions.Count > 0 && state.Funds > 7500 && BuiltResidences.Count > BuiltUtilitys.Count * 3)
{
UtilityTask.Value = 30;
}
//Build building
//Repair buildning
//Change temperature
for (int i = 0; i < state.ResidenceBuildings.Count; i++)
{
var building = state.ResidenceBuildings[i];
if (building.BuildProgress < 100)
{
BuildTask.Value = 80;
}
if (building.Health < 50)
{
RepairTask.Value = 70;
}
if (building.Temperature < config.BuildingMinTemp || building.Temperature > config.BuildingMaxTemp)
{
TemperatureTask.Value = 60;
}
}
//Samma för upgrades. En annan loop här då vi går igenom våran egen lista med byggda byggnader.
for (int i = 0; i < BuiltResidences.Count; i++)
{
var residence = BuiltResidences[i];
foreach (var item in config.UpgradesToBuild)
{
if (!residence.BuiltUpgrades.Contains(item) && state.Funds > 8000)
{
UpgradetTask.Value = 20;
}
}
}
//same for utility buildings
for (int i = 0; i < state.UtilityBuildings.Count; i++)
{
var building = state.UtilityBuildings[i];
if (building.BuildProgress < 100)
{
BuildTask.Value = 80;
}
}
//Get the biggest urgencyValue. That being the most urgent task
int maxValue = 0;
GameTask taskToPerform = GameTask.Build;
if (ResidencePositions.Count == 0)
{
taskToPerform = GameTask.Wait;
}
foreach (UrgencyValue item in urgencyValues)
{
if (item.Value > maxValue)
{
maxValue = item.Value;
taskToPerform = item.GameTask;
}
}
switch (taskToPerform)
{
case GameTask.StartBuild:
var building = ResidencePositions[0];
GameLayer.StartBuild(new Position(building.XSpot, building.YSpot), state.AvailableResidenceBuildings[(int)ResidencePositions[0].ResidenceType].BuildingName,
gameId);
BuiltResidences.Add(ResidencePositions[0]);
ResidencePositions.RemoveAt(0);
break;
case GameTask.Build:
for (int i = 0; i < state.ResidenceBuildings.Count; i++)
{
var buildSpot = state.ResidenceBuildings[i];
if (buildSpot.BuildProgress < 100)
{
GameLayer.Build(buildSpot.Position, gameId);
break;
}
}
for (int i = 0; i < state.UtilityBuildings.Count; i++)
{
var buildSpot = state.UtilityBuildings[i];
if (buildSpot.BuildProgress < 100)
{
GameLayer.Build(buildSpot.Position, gameId);
break;
}
}
break;
case GameTask.BuildUtility:
var utilityBuilding = UtilityPositions[0];
GameLayer.StartBuild(new Position(utilityBuilding.XSpot, utilityBuilding.YSpot), state.AvailableUtilityBuildings[(int)UtilityPositions[0].UtilityType].BuildingName,
gameId);
BuiltUtilitys.Add(UtilityPositions[0]);
UtilityPositions.RemoveAt(0);
break;
case GameTask.Repair:
for (int i = 0; i < state.ResidenceBuildings.Count; i++)
{
var repairSpot = state.ResidenceBuildings[i];
if (repairSpot.Health < 50)
{
GameLayer.Maintenance(repairSpot.Position, gameId);
break;
}
}
break;
case GameTask.Upgrade:
for (int i = 0; i < BuiltResidences.Count; i++)
{
var residence = BuiltResidences[i];
Upgrades upgradeToBuild = Upgrades.None;
foreach (var item in config.UpgradesToBuild)
{
if (!residence.BuiltUpgrades.Contains(item))
{
upgradeToBuild = item;
}
}
if (upgradeToBuild != Upgrades.None)
{
GameLayer.BuyUpgrade(new Position(residence.XSpot, residence.YSpot), state.AvailableUpgrades[(int)upgradeToBuild].Name, gameId);
BuiltResidences[i].BuiltUpgrades.Add(upgradeToBuild);
break;
}
}
break;
case GameTask.ChangeTemperature:
for (int i = 0; i < state.ResidenceBuildings.Count; i++)
{
var changeTemperatureSpot = state.ResidenceBuildings[i];
if (changeTemperatureSpot.Temperature < config.BuildingMinTemp)
{
var bluePrint = GameLayer.GetResidenceBlueprint(changeTemperatureSpot.BuildingName);
var energy = bluePrint.BaseEnergyNeed + (changeTemperatureSpot.Temperature - state.CurrentTemp)
* bluePrint.Emissivity / 1 + config.TempAdjustValue - changeTemperatureSpot.CurrentPop * 0.04;
//test av alternativ algoritm
//var degPerPop = 0.04;
//var degPerExcessMwh = config.TempAdjustValue;
//var energy = (21 - changeTemperatureSpot.Temperature - degPerPop * changeTemperatureSpot.CurrentPop +
// (changeTemperatureSpot.Temperature - state.CurrentTemp) * bluePrint.Emissivity) / degPerExcessMwh + bluePrint.BaseEnergyNeed;
GameLayer.AdjustEnergy(changeTemperatureSpot.Position, energy, gameId);
break;
}
else if (changeTemperatureSpot.Temperature > config.BuildingMaxTemp)
{
var bluePrint = GameLayer.GetResidenceBlueprint(changeTemperatureSpot.BuildingName);
var energy = bluePrint.BaseEnergyNeed + (changeTemperatureSpot.Temperature - state.CurrentTemp)
* bluePrint.Emissivity / 1 - config.TempAdjustValue - changeTemperatureSpot.CurrentPop * 0.04;
GameLayer.AdjustEnergy(changeTemperatureSpot.Position, energy, gameId);
break;
}
}
break;
case GameTask.Wait:
GameLayer.Wait(gameId);
break;
default:
break;
}
foreach (var message in GameLayer.GetState().Messages)
{
Log.Information(message);
}
foreach (var error in GameLayer.GetState().Errors)
{
Log.Information("Error: " + error);
}
prevState = state;
}
public void take_turn(string gameId)
{
//Vi skapar "Urgency values" som alltid ska refleketera hur viktigt något är att göra denna tur.
//Dessa använder vi sen för att väljav vilken handling vi tar.
//Måste även implementera en "value map" som beräknar vilka platser på kartan som är mest
//Värdefulla att bygga hushåll alternativt utilities på.
//Tex så är ju platser utan många angrändsande platser attraktiva för vindkraftverk
//och platser med många rutor nära varandra attraktiva för ställen med områdeseffekter.
// TODO Implement your artificial intelligence here.
// TODO Taking one action per turn until the game ends.
// TODO The following is a short example of how to use the StarterKit
var x = 0;
var y = 0;
var state = GameLayer.GetState();
if (state.ResidenceBuildings.Count < 1)
{
for (var i = 0; i < 10; i++)
{
for (var j = 0; j < 10; j++)
{
if (state.Map[i][j] == 0)
{
x = i;
y = j;
break;
}
}
}
GameLayer.StartBuild(new Position(x, y), state.AvailableResidenceBuildings[0].BuildingName,
gameId);
}
else
{
var building = state.ResidenceBuildings[0];
if (building.BuildProgress < 100)
{
GameLayer.Build(building.Position, gameId);
}
else if (!building.Effects.Contains(state.AvailableUpgrades[0].Name))
{
GameLayer.BuyUpgrade(building.Position, state.AvailableUpgrades[0].Name, gameId);
}
else if (building.Health < 50)
{
GameLayer.Maintenance(building.Position, gameId);
}
else if (building.Temperature < 18)
{
var bluePrint = GameLayer.GetResidenceBlueprint(building.BuildingName);
var energy = bluePrint.BaseEnergyNeed + (building.Temperature - state.CurrentTemp)
* bluePrint.Emissivity / 1 + 0.5 - building.CurrentPop * 0.04;
GameLayer.AdjustEnergy(building.Position, energy, gameId);
}
else if (building.Temperature > 24)
{
var bluePrint = GameLayer.GetResidenceBlueprint(building.BuildingName);
var energy = bluePrint.BaseEnergyNeed + (building.Temperature - state.CurrentTemp)
* bluePrint.Emissivity / 1 - 0.5 - building.CurrentPop * 0.04;
GameLayer.AdjustEnergy(building.Position, energy, gameId);
}
else
{
GameLayer.Wait(gameId);
}
foreach (var message in GameLayer.GetState().Messages)
{
Log.Information(message);
}
foreach (var error in GameLayer.GetState().Errors)
{
Log.Information("Error: " + error);
}
}
}
