protected override void ReadFrom(Game game, AI ai, string name, SaveReaderText reader)
{
base.ReadFrom(game, ai, name, reader);
type = reader.Value($"{name}.building_type").ReadBuilding();
builtPosition = reader.Value($"{name}.built_position").ReadUInt();
}
public BuildingRef(Building building)
{
pos = building.pos;
empire = building.empire.id;
type = building.type;
level = building.level;
}
public void _on_Buildings_item_activated(int index)
{
Building.Type type = (Building.Type)index;
if (Player.inventoryBuildings.GetItemCount(type) >= 1)
{
Player.BuildingSelected = type;
Delay.StartDelay(this, 0.1f, () => Close(PlayerState.State.Build));
}
}
bool CheckMaxInAreaOk(Map map, uint basePosition, int range, Building.Type buildingType, int maxInArea = int.MaxValue)
{
if (maxInArea == int.MaxValue)
{
return(true);
}
return(BuildingsInArea(map, basePosition, range, buildingType, FindBuilding, 1) < maxInArea);
}
private void InitBuildingSelector()
{
buildingSelector.Clear();
for (int i = 0; i < Building.nbBuildings; i++)
{
Building.Type type = (Building.Type)i;
buildingSelector.AddItem(type.ToString(), Building.textures[type]);
}
}
public void _on_BuildingList_item_selected(int index)
{
if (index < Building.nbBuildings)
{
Building.Type type = (Building.Type)index;
SetDescription(type);
buildingSelected = type;
RefreshBtnPrint();
}
}
public AIStateBuildBuilding(Building.Type buildingType)
: base(AI.State.BuildBuilding)
{
if (buildingType >= Building.Type.StoneMine && buildingType <= Building.Type.GoldMine)
{
throw new ExceptionFreeserf(ErrorSystemType.AI, "Mines are handled by AIStateFindMinerals");
}
type = buildingType;
}
//Enlever un batiment
public bool Remove(Building.Type type, int nb)
{
bool res = false;
if (storage[type] - nb >= 0)
{
res = true;
storage[type] -= nb;
}
return(res);
}
//ici les méthodes
//Ajouter un batiment
public bool Add(Building.Type type, int nb)
{
bool res = false;
if (storage[type] + nb < max)
{
res = true;
storage[type] += nb;
}
return(res);
}
public void SetBuildingSaveStruct(SaveStruct st)
{
type = st.type;
healthMax = st.healthMax;
health = st.health;
id = st.id;
energy = st.energy;
energyMax = st.energyMax;
isLinked = st.isLinked;
energyhistory = st.energyhistory;
powerInhistory = st.powerInhistory;
powerOuthistory = st.powerOuthistory;
}
public BuildingType
(
Building.Type type, int occupyingSpace, int maxUnitsOccupyingSpace,
string name, TimeSpan timeToBuild, TimeSpan timeToDestroy, List <ResourseBunch> necessaryResourses
)
: base(
name, timeToBuild, timeToDestroy, necessaryResourses
)
{
this.Type = type;
this.OccupyingSpace = occupyingSpace;
this.MaxUnitsOccupyingSpace = maxUnitsOccupyingSpace;
}
protected ResourseBuildingType
(
double damageRate, double strengthMultipler, double enduranceMultipler,
Building.Type type, int occupyingSpace, int maxUnitsOccupyingSpace,
string name, TimeSpan timeToBuild, TimeSpan timeToDestroy, List <ResourseBunch> necessaryResourses
)
: base(
type, occupyingSpace, maxUnitsOccupyingSpace,
name, timeToBuild, timeToDestroy, necessaryResourses
)
{
this.DamageRate = damageRate;
this.StrengthMultipler = strengthMultipler;
this.EnduranceMultipler = enduranceMultipler;
}
public Building GetBuildingByType(Building.Type type)
{
if (allNodes.Count <= 0)
{
return(null);
}
foreach (Node n in allNodes)
{
if (n.building != null && n.building.buildingType == type)
{
return(n.building);
}
}
return(null);
}
private void SetDescription(Building.Type type)
{
imageDesc.Texture = Building.textures[type];
titleDesc.Text = type.ToString();
timeDesc.Text = Building.times2Create[type].ToString() + "s";
energyDesc.Text = "-> " + (Building.times2Create[type] * Printer3D.power) + "e";
descriptionDesc.Text = Building.descriptions[type];
ClearItemsList();
foreach (var loot in Building.crafts[type].loots)
{
Control it = (Control)itemBox.Instance();
it.GetNode <TextureRect>("img").Texture = Item.textures[(int)loot.type];
it.GetNode <Label>("texte").Text = Player.inventoryItems.GetItemCount(loot.type) + "/" + loot.amount;
itemListDesc.AddChild(it);
}
}
public static void Revive()
{
if (health <= 0)
{
FillHealth();
FillOxygene();
FillEnergy();
inventoryUsables = new StorageUsables(inventoryUsablesSize);
inventoryItems = new StorageItems(inventoryItemsSize);
inventoryLiquids = new StorageLiquids(inventoryLiquidsSize);
inventoryBuildings = new StorageBuildings(inventoryBuildingsSize);
UsableSelected = Usable.Type.Laser;
BuildingSelected = Building.Type.SolarPanel;
PlayerMouvements.Teleport(World.spawn.x, World.spawn.y);
PlayerMouvements.canMove = true;
}
}
CheckResult NeedBuilding(AI ai, Game game, Player player, Building.Type type)
{
if (!ai.HasResourcesForBuilding(type))
{
return(CheckResult.NotNeeded);
}
var neededForBuilding = Building.Requests[(int)type];
int inventory = -1;
if (type == Building.Type.Hut || type == Building.Type.Tower || type == Building.Type.Fortress)
{
if (game.GetFreeKnightCount(player) != 0)
{
return(CheckResult.Needed);
}
else
{
return(CheckResult.NeededButNoSpecialistOrResources);
}
}
else
{
inventory = game.FindInventoryWithValidSpecialist(player, neededForBuilding.SerfType,
neededForBuilding.ResourceType1, neededForBuilding.ResourceType2);
}
if (inventory != -1)
{
if (inventory > 0xffff)
{
return(CheckResult.NeededButNoGenerics);
}
return(CheckResult.Needed);
}
if (player.GetResourceCount(neededForBuilding.ResourceType1) != 0 &&
(neededForBuilding.ResourceType2 == Resource.Type.None || player.GetResourceCount(neededForBuilding.ResourceType2) != 0))
{
return(CheckResult.Needed);
}
return(CheckResult.NeededButNoSpecialistOrResources);
}
uint FindSpotNearBuilding(Game game, Player player, int intelligence, Building.Type buildingType, int maxInArea = int.MaxValue)
{
var buildings = game.GetPlayerBuildings(player).Where(building => building.BuildingType == buildingType).ToList();
while (buildings.Count > 0)
{
var randomBuilding = buildings[game.RandomInt() % buildings.Count];
if (CheckMaxInAreaOk(game.Map, randomBuilding.Position, 6, buildingType, maxInArea))
{
return(FindSpotNear(game, player, randomBuilding.Position, 4));
}
buildings.Remove(randomBuilding);
}
return(Global.INVALID_MAPPOS);
}
private void ClickBuildState()
{
Vector2 playerPos = Convertion.Location2World(PlayerMouvements.instance.Position);
bool right = playerPos.x - 1 < mousePos.x;
bool res = mousePos.y > 0 && mousePos.y <= Chunk.height;
if (res && MouseInRange(9, true))
{
Building.Type type = Player.BuildingSelected;
if (Player.inventoryBuildings.GetItemCount(type) >= 1)
{
Building building = (Building)Building.prefabs[type].Instance();
building.SetType(type);
bool succeed = BasicPlacement.PlaceWithMouse(building, GetGlobalMousePosition(), right);
if (succeed)
{
Player.inventoryBuildings.Remove(type, 1);
}
}
}
}
// Build a new building.
public void BuildBuilding(Building.Type type)
{
if (AccessRights != Viewer.Access.Player)
{
return;
}
if (!Game.BuildBuilding(mapCursorPosition, type, player))
{
PlaySound(Freeserf.Audio.Audio.TypeSfx.NotAccepted);
return;
}
PlaySound(Freeserf.Audio.Audio.TypeSfx.Accepted);
ClosePopup();
// Move cursor to flag.
var flagPosition = Game.Map.MoveDownRight(mapCursorPosition);
UpdateMapCursorPosition(flagPosition);
}
private void BuildState()
{
Vector2 vec = mousePos;
int x = (int)mousePos.x;
int y = (int)mousePos.y;
bool res = y > 0 && y <= Chunk.height;
World.UIBlockTilemap.Clear();
Vector2 playerPos = Convertion.Location2World(PlayerMouvements.instance.Position);
bool right = playerPos.x - 1 < mousePos.x;
Building.Type type = Player.BuildingSelected;
bool haveBuilding = Player.inventoryBuildings.GetItemCount(type) >= 1;
if (res && right)
{
if (haveBuilding && BasicPlacement.IsPlacableRight(x, y, 4, 4) && MouseInRange(9, true))
{
PrintBatRight(1);
}
else
{
PrintBatRight(0);
}
}
else if (res)
{
if (haveBuilding && BasicPlacement.IsPlacableLeft(x, y, 4, 4) && MouseInRange(9, true))
{
PrintBatLeft(1);
}
else
{
PrintBatLeft(0);
}
}
}
public void SetType(Building.Type type)
{
this.type = type;
}
/// Recupere le nombre de batiments du type demandé
public int GetItemCount(Building.Type type)
{
return(storage[type]);
}
CheckResult CheckBuilding(AI ai, Game game, Player player, int intelligence, Building.Type type)
{
int count = (int)player.GetTotalBuildingCount(type);
if (count == 0)
{
switch (type)
{
// these are essential buildings
case Building.Type.Lumberjack:
case Building.Type.Sawmill:
case Building.Type.Stonecutter:
return(NeedBuilding(ai, game, player, type));
}
}
// Don't build new buildings while the emergency program is active.
// The essential buildings are handled above.
if (player.EmergencyProgramActive)
{
return(CheckResult.NotNeeded);
}
// Ensure there is a source for planks and stones before building more
if (type != Building.Type.Lumberjack && type != Building.Type.Sawmill &&
(player.GetCompletedBuildingCount(Building.Type.Sawmill) == 0 ||
player.GetCompletedBuildingCount(Building.Type.Lumberjack) == 0))
{
if ((ai.HardTimes && game.GetResourceAmountInInventories(player, Resource.Type.Plank) < 5) ||
player.GetIncompleteBuildingCount(Building.Type.Sawmill) == 0 ||
player.GetIncompleteBuildingCount(Building.Type.Lumberjack) == 0)
{
return(CheckResult.NotNeeded);
}
}
if (type != Building.Type.Stonecutter && type != Building.Type.StoneMine &&
(player.GetCompletedBuildingCount(Building.Type.Stonecutter) == 0 &&
player.GetCompletedBuildingCount(Building.Type.StoneMine) == 0))
{
if ((ai.HardTimes && game.GetResourceAmountInInventories(player, Resource.Type.Plank) < 3) ||
(player.GetIncompleteBuildingCount(Building.Type.Stonecutter) == 0 &&
player.GetIncompleteBuildingCount(Building.Type.StoneMine) == 0))
{
if (ai.GameTime < 10 * Global.TICKS_PER_MIN && player.GetResourceCount(Resource.Type.Stone) < 10 &&
game.Map.FindInTerritory(player.Index, FindStoneNear).Count > 0)
{
return(CheckResult.NotNeeded);
}
}
}
// Don't build more than x building at the same time (x is 3 ~ 15)
if (player.IncompleteBuildingCount > 3 + ai.BuildingFocus + Math.Min(10, ai.GameTime / (30 * Global.TICKS_PER_MIN)))
{
return(CheckResult.NotNeeded);
}
// Our focus must be to get a coal and iron mine running as we need steel.
// We also need a food source.
if (ai.HardTimes)
{
switch (type)
{
case Building.Type.Fisher:
if (count == 0 && game.HasAnyOfBuildingCompletedOrMaterialsAtPlace(player, Building.Type.Forester) &&
game.Map.FindInTerritory(player.Index, FindFishNear).Count > 0) // fish present
{
return(CheckResult.Needed);
}
break;
case Building.Type.Farm:
if (count == 0)
{
if (player.GetResourceCount(Resource.Type.Scythe) != 0 ||
player.GetSerfCount(Serf.Type.Farmer) != 0)
{
return(CheckResult.Needed);
}
else if (player.GetTotalBuildingCount(Building.Type.Fisher) == 0 &&
game.Map.FindInTerritory(player.Index, FindFishNear).Count == 0) // no fish
{
// First check if we can expand the territory.
// If not trying to craft a scythe is our last hope.
// Otherwise we can't do anything. If we are lucky
// there is a piece of coal and iron on the way to
// make a piece of steel.
if (game.GetPossibleFreeKnightCount(player) == 0)
{
return(CheckResult.NeededButNoSpecialistOrResources);
}
}
}
break;
case Building.Type.Mill:
if (count == 0 && player.GetCompletedBuildingCount(Building.Type.Farm) != 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.Baker:
if (count == 0 && player.GetTotalBuildingCount(Building.Type.Mill) != 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.Hut:
if (player.GetIncompleteBuildingCount(Building.Type.Hut) == 0 &&
game.HasAnyOfBuildingCompletedOrMaterialsAtPlace(player, Building.Type.Forester) &&
!game.GetPlayerBuildings(player, Building.Type.Hut).Any(building => !building.HasKnight()) &&
ai.GameTime > count * 180 * Global.TICKS_PER_SEC && game.GetPossibleFreeKnightCount(player) > 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.CoalMine:
if (count == 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.IronMine:
if (count == 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.Forester:
if (count == 0)
{
return(CheckResult.Needed);
}
break;
// If we have at least one coal and iron, we can build a steelsmelter and a toolmaker to produce a scythe or pincer.
// This can happen with a bit more than minimum supplies or if the mines produce something without a food source.
// We will craft a scythe if we can't build a fisher. We will craft a pincer and/or hammer if we have no more knights.
case Building.Type.ToolMaker:
if (count == 0 && player.GetCompletedBuildingCount(Building.Type.SteelSmelter) != 0)
{
return(CheckResult.Needed);
}
break;
case Building.Type.SteelSmelter:
if (count == 0 &&
(game.GetResourceAmountInInventories(player, Resource.Type.Coal) != 0 || player.GetCompletedBuildingCount(Building.Type.CoalMine) != 0) &&
(game.GetResourceAmountInInventories(player, Resource.Type.IronOre) != 0 || player.GetCompletedBuildingCount(Building.Type.IronMine) != 0))
{
return(CheckResult.Needed);
}
break;
case Building.Type.WeaponSmith:
if (count == 0 && player.GetCompletedBuildingCount(Building.Type.ToolMaker) != 0 &&
game.GetPossibleFreeKnightCount(player) < 4)
{
return(CheckResult.Needed);
}
break;
}
return(CheckResult.NotNeeded);
}
int numIncompleteBuildings = game.GetPlayerBuildings(player).Count(building => !building.IsDone);
int numPossileAdditionalBuildings = type == Building.Type.Hut ? ai.ExpandFocus / 2 + Math.Max(0, (int)player.LandArea / 50) : 0;
if (numIncompleteBuildings > 2 + numPossileAdditionalBuildings + player.LandArea / 200 + ai.GameTime / (20 * Global.TICKS_PER_MIN) + Math.Max(ai.ExpandFocus - 1, ai.BuildingFocus))
{
return(CheckResult.NotNeeded);
}
// If we can't produce knights and don't have any left, we won't build
// several buildings until we have a weaponsmith. Otherwise we might
// run out of space for large buildings and therefore a weaponsmith.
bool hasKnightRequirements = ai.HasRequirementsForKnights(game);
switch (type)
{
case Building.Type.Lumberjack:
if (TestBuilding(count, ai, game, player, 45 - ai.ConstructionMaterialFocus * 7, 55 - ai.ConstructionMaterialFocus * 10, 75))
{
if (game.GetResourceAmountInInventories(player, Resource.Type.Plank) < 70 + ai.ConstructionMaterialFocus * ai.ConstructionMaterialFocus * 40 - count * 3)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.Forester:
{
int lumberjackCount = (int)player.GetTotalBuildingCount(Building.Type.Lumberjack);
if (count < lumberjackCount + ai.ConstructionMaterialFocus && TestBuilding(count, ai, game, player, 30 - ai.ConstructionMaterialFocus * 7, 60 - ai.ConstructionMaterialFocus * 20, 50))
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.Stonecutter:
if (TestBuilding(count, ai, game, player, 110 - ai.ConstructionMaterialFocus * 32, 100 - ai.ConstructionMaterialFocus * 20, 75))
{
if (game.GetResourceAmountInInventories(player, Resource.Type.Stone) < 50 + ai.ConstructionMaterialFocus * ai.ConstructionMaterialFocus * 30 - count * 5)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.Sawmill:
{
int lumberjackCount = (int)player.GetTotalBuildingCount(Building.Type.Lumberjack);
if (count < lumberjackCount * 3 - ai.ConstructionMaterialFocus && TestBuilding(count, ai, game, player, 120 - ai.ConstructionMaterialFocus * 10, 400 - ai.ConstructionMaterialFocus * 15, 30))
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.ToolMaker:
if (count < 1 && ai.GameTime > 30 * Global.TICKS_PER_SEC + (2 - intelligence / 20) * Global.TICKS_PER_MIN)
{
return(NeedBuilding(ai, game, player, type));
}
if (count < 2 && game.GetResourceAmountInInventories(player, Resource.Type.Plank) >= 100 && game.GetResourceAmountInInventories(player, Resource.Type.Stone) >= 20 &&
game.GetResourceAmountInInventories(player, Resource.Type.Steel) >= 75 && TestBuilding(1, ai, game, player, 180, 800, 5))
{
return(NeedBuilding(ai, game, player, type));
}
break;
case Building.Type.Hut:
case Building.Type.Tower:
case Building.Type.Fortress:
{
// TODO: large military buildings should be placed near important buildings or near to an enemy to start fights (depending on AI character)
if (game.GetPossibleFreeKnightCount(player) == 0)
{
return(CheckResult.NotNeeded);
}
var numHuts = player.GetTotalBuildingCount(Building.Type.Hut);
var numTowers = player.GetTotalBuildingCount(Building.Type.Tower);
var numFortresses = player.GetTotalBuildingCount(Building.Type.Fortress);
var percHut = ai.GetMilitaryBuildingPercentage(Building.Type.Hut);
var percTower = ai.GetMilitaryBuildingPercentage(Building.Type.Tower);
var percFortress = ai.GetMilitaryBuildingPercentage(Building.Type.Fortress);
uint numHutsPerTower = 32u - (uint)Math.Ceiling(2.0 * (percTower + 50.0) / percHut); // 10-30
uint numHutsPerFortress = 48u - (uint)Math.Ceiling(4.0 * (percFortress + 20.0) / percHut); // 16-46
if (numHuts < numHutsPerTower + numTowers * numHutsPerTower)
{
if (type != Building.Type.Hut)
{
return(CheckResult.NotNeeded);
}
}
else if (numHuts < numHutsPerFortress + numFortresses * numHutsPerFortress)
{
if (type == Building.Type.Fortress)
{
return(CheckResult.NotNeeded);
}
}
if (!ai.CanBuildMilitaryBuilding(type))
{
return(CheckResult.NotNeeded);
}
int focus = Misc.Max(ai.MilitaryFocus, (ai.DefendFocus + 1) / 2, ai.ExpandFocus) + (ai.MilitaryFocus + ai.DefendFocus + ai.ExpandFocus) / 4;
if (focus == 0 && numHuts == 0)
{
focus = 1;
}
float gameTimeFactor = ai.GameTime / (10.0f * Global.TICKS_PER_MIN); // increases every 10 minutes
gameTimeFactor = Math.Min(100.0f, gameTimeFactor * gameTimeFactor); // 10 min -> 1, 20 min -> 4, 30 min -> 9, 40 min -> 16, ... 100 min -> 100
long numPerLand = (focus * 50 + player.LandArea * 3 - 400) / (200 - Misc.Round(gameTimeFactor));
long numPerTime = (focus + 1) * Misc.Round(gameTimeFactor / (12 - ai.Aggressivity * 2));
if (CanBuildMilitary(ai, game, player) &&
count < focus + numPerLand + numPerTime &&
ai.GameTime > (90 - intelligence - focus * 15 - ai.Aggressivity * 5) * Global.TICKS_PER_SEC)
{
return(NeedBuilding(ai, game, player, type));
}
break;
}
case Building.Type.CoalMine:
if (count < 1 && ai.GameTime > (30 - Misc.Max(ai.GoldFocus, ai.SteelFocus, ai.MilitaryFocus) * 10 - intelligence / 7) * 5 * Global.TICKS_PER_SEC)
{
return(NeedBuilding(ai, game, player, type));
}
else if (count > 0 && count < Math.Max(0, (ai.GameTime - 30 * Global.TICKS_PER_MIN) / ((80 - Misc.Max(ai.GoldFocus, ai.SteelFocus, ai.MilitaryFocus) * 10) * Global.TICKS_PER_MIN)))
{
uint numIronMines = player.GetCompletedBuildingCount(Building.Type.IronMine);
uint numGoldMines = player.GetCompletedBuildingCount(Building.Type.GoldMine);
uint numWeaponSmiths = player.GetCompletedBuildingCount(Building.Type.WeaponSmith);
var maxNeededCoalMines = Math.Max(2, 1 + (numIronMines + ai.SteelFocus / 2) + (numGoldMines + ai.GoldFocus / 2) + (numWeaponSmiths + ai.MilitaryFocus / 2));
if (count < maxNeededCoalMines)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.IronMine:
if (count < 1 && ai.GameTime > (33 - Math.Max(ai.SteelFocus, ai.MilitaryFocus) * 10 - intelligence / 8) * 5 * Global.TICKS_PER_SEC)
{
return(NeedBuilding(ai, game, player, type));
}
else if (count > 0 && count < Math.Max(0, (ai.GameTime - 30 * Global.TICKS_PER_MIN) / ((100 - Misc.Max(ai.SteelFocus, ai.MilitaryFocus) * 10) * Global.TICKS_PER_MIN)))
{
uint numCoalMines = player.GetCompletedBuildingCount(Building.Type.CoalMine);
var maxNeededIronMines = Math.Max(2, 1 + (numCoalMines + Misc.Max(ai.SteelFocus, ai.MilitaryFocus) / 2));
if (count < maxNeededIronMines)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.GoldMine:
if (count < 1 && ai.GameTime > (45 - Math.Max(ai.GoldFocus, ai.MilitaryFocus - 1) * 7 - intelligence / 9) * 5 * Global.TICKS_PER_SEC)
{
return(NeedBuilding(ai, game, player, type));
}
else if (count > 0 && count < Math.Max(0, (ai.GameTime - 30 * Global.TICKS_PER_MIN) / ((160 - Misc.Max(ai.GoldFocus, ai.MilitaryFocus - 1) * 10) * Global.TICKS_PER_MIN)))
{
uint numCoalMines = player.GetCompletedBuildingCount(Building.Type.CoalMine);
var maxNeededGoldMines = Math.Max(2, 1 + (numCoalMines + Misc.Max(ai.GoldFocus, ai.MilitaryFocus) / 2));
if (count < maxNeededGoldMines)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.StoneMine:
if (count < 1 && ai.GameTime > (120 - Math.Max(ai.BuildingFocus, ai.ConstructionMaterialFocus) * 20 - intelligence / 10) * 5 * Global.TICKS_PER_SEC)
{
if (ai.ConstructionMaterialFocus == 2 || player.GetResourceCount(Resource.Type.Stone) < 45 - ai.ConstructionMaterialFocus * 15)
{
return(NeedBuilding(ai, game, player, type));
}
}
else if (count > 0 && count < Math.Max(0, (ai.GameTime - 40 * Global.TICKS_PER_MIN) / ((200 - ai.ConstructionMaterialFocus * 15) * Global.TICKS_PER_MIN)))
{
uint numSawMills = player.GetCompletedBuildingCount(Building.Type.Sawmill);
var maxNeededStoneMines = Math.Max(2, 1 + (numSawMills + ai.ConstructionMaterialFocus / 2));
if (count < maxNeededStoneMines)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.Farm:
case Building.Type.Mill:
case Building.Type.Baker:
case Building.Type.PigFarm:
case Building.Type.Butcher:
case Building.Type.Fisher:
if (!hasKnightRequirements)
{
return(CheckResult.NotNeeded);
}
if (ai.GameTime > (120 - Math.Max(ai.FoodFocus, ai.BuildingFocus) * 15) * Global.TICKS_PER_SEC && NeedFoodBuilding(ai, game, player, type))
{
return(NeedBuilding(ai, game, player, type));
}
break;
case Building.Type.SteelSmelter:
{
if (count != 0 && player.GetTotalBuildingCount(Building.Type.WeaponSmith) == 0)
{
return(CheckResult.NotNeeded);
}
if (count < player.GetCompletedBuildingCount(Building.Type.IronMine) * Math.Max(2, ai.SteelFocus + 1) &&
game.GetResourceAmountInInventories(player, Resource.Type.Plank) >= 5 &&
game.GetResourceAmountInInventories(player, Resource.Type.Stone) >= 3)
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.GoldSmelter:
{
if (!hasKnightRequirements)
{
return(CheckResult.NotNeeded);
}
if (count < player.GetCompletedBuildingCount(Building.Type.GoldMine) * (ai.GoldFocus + 2) &&
game.GetResourceAmountInInventories(player, Resource.Type.Plank) >= 5 &&
game.GetResourceAmountInInventories(player, Resource.Type.Stone) >= 3 &&
TestBuilding(count, ai, game, player, 80 - ai.GoldFocus * 10, 50 - ai.GoldFocus * 5, 20))
{
return(NeedBuilding(ai, game, player, type));
}
else if (count < 1 && game.GetResourceAmountInInventories(player, Resource.Type.GoldOre) >= 35 - ai.GoldFocus * 16)
{
// Gold focus: 0 -> min 35 ore, 1 -> min 19 ore, 2 -> min 3 ore
if (ai.GameTime > (60 - ai.GoldFocus * 20) * Global.TICKS_PER_MIN)
{
return(NeedBuilding(ai, game, player, type));
}
}
}
break;
case Building.Type.WeaponSmith:
{
if (count == 0)
{
if (player.GetCompletedBuildingCount(Building.Type.ToolMaker) > 0 && player.GetCompletedBuildingCount(Building.Type.SteelSmelter) > 0)
{
return(NeedBuilding(ai, game, player, type));
}
else if (game.GetResourceAmountInInventories(player, Resource.Type.Coal) >= 10 && game.GetResourceAmountInInventories(player, Resource.Type.Steel) >= 10 &&
ai.GameTime > (10 - Misc.Max(ai.MilitaryFocus, ai.ExpandFocus, ai.DefendFocus - 1, ai.Aggressivity - 1) - game.RandomInt() % 3) * Global.TICKS_PER_MIN)
{
return(NeedBuilding(ai, game, player, type));
}
}
if (count < Math.Min(player.GetCompletedBuildingCount(Building.Type.CoalMine) + 1, player.GetCompletedBuildingCount(Building.Type.SteelSmelter)))
{
return(NeedBuilding(ai, game, player, type));
}
}
break;
case Building.Type.Stock:
if (!hasKnightRequirements)
{
return(CheckResult.NotNeeded);
}
if (count < (game.Map.Size + 1) / 2 + ai.BuildingFocus &&
count < ((int)player.LandArea + ai.BuildingFocus * 300) / 1200 && ai.GameTime > 60 - ai.BuildingFocus * 8 * Global.TICKS_PER_MIN &&
player.GetCompletedBuildingCount(Building.Type.WeaponSmith) > count &&
ai.Chance(50 + ai.BuildingFocus * 25))
{
return(NeedBuilding(ai, game, player, type));
}
break;
case Building.Type.Boatbuilder:
if (count < 1 && ai.GameTime > 52 - ai.BuildingFocus * 2 * Global.TICKS_PER_MIN &&
game.GetResourceAmountInInventories(player, Resource.Type.Plank) >= 24 - ai.BuildingFocus * 4 &&
ai.Chance(1))
{
return(NeedBuilding(ai, game, player, type));
}
break;
}
return(CheckResult.NotNeeded);
}
bool NeedFoodBuilding(AI ai, Game game, Player player, Building.Type type)
{
// TODO: Fishers can't be build in any case or on any map.
// Therefore the ratio for food end buildings need adjustment in this case.
// Otherwise no new food chains will be build.
int numberOfMines = game.GetPlayerBuildings(player).Where(building =>
building.BuildingType == Building.Type.CoalMine ||
building.BuildingType == Building.Type.IronMine ||
building.BuildingType == Building.Type.GoldMine ||
building.BuildingType == Building.Type.StoneMine).Count();
int numberOfFishers = (int)player.GetTotalBuildingCount(Building.Type.Fisher);
int numberOfFarms = (int)player.GetTotalBuildingCount(Building.Type.Farm);
int numberOfCompletedFarms = (int)player.GetCompletedBuildingCount(Building.Type.Farm);
int numberOfMills = (int)player.GetTotalBuildingCount(Building.Type.Mill);
int numberOfBakers = (int)player.GetTotalBuildingCount(Building.Type.Baker);
int numberOfPigFarms = (int)player.GetTotalBuildingCount(Building.Type.PigFarm);
int numberOfButchers = (int)player.GetTotalBuildingCount(Building.Type.Butcher);
bool hasPotentialFarmer = player.GetSerfCount(Serf.Type.Farmer) != 0 ||
game.GetResourceAmountInInventories(player, Resource.Type.Scythe) != 0;
// If there are no mines and some game time has passed
// the AI will at least build one of its favorite food source chain.
if (numberOfMines == 0)
{
if (ai.GameTime >= (25 - ai.FoodFocus * 4 - (type == Building.Type.Fisher ? 5 : 0)) * Global.TICKS_PER_MIN)
{
switch (type)
{
case Building.Type.Fisher:
if (numberOfFishers == 0 && (ai.GetFoodSourcePriority(0) == 2 || !hasPotentialFarmer))
{
return(true);
}
break;
case Building.Type.Farm:
if (numberOfFarms == 0 && ai.GetFoodSourcePriority(0) != 2 && hasPotentialFarmer)
{
return(true);
}
break;
case Building.Type.Mill:
if (numberOfCompletedFarms != 0 && numberOfMills < Math.Max(1, ai.FoodFocus) && ai.GetFoodSourcePriority(1) == 2 &&
game.GetResourceAmountInInventories(player, Resource.Type.Plank) > 3)
{
return(true);
}
break;
case Building.Type.Baker:
if (numberOfMills != 0 && numberOfBakers == 0 && ai.GetFoodSourcePriority(1) == 2)
{
return(true);
}
break;
case Building.Type.PigFarm:
if (numberOfCompletedFarms != 0 && numberOfPigFarms < 2 + ai.FoodFocus && ai.GetFoodSourcePriority(2) == 2 &&
game.GetResourceAmountInInventories(player, Resource.Type.Plank) > 4)
{
return(true);
}
break;
case Building.Type.Butcher:
if (numberOfPigFarms != 0 && numberOfButchers == 0 && ai.GetFoodSourcePriority(2) == 2)
{
return(true);
}
break;
}
}
return(false);
}
int numPossibleMines = numberOfFishers + numberOfButchers * 3 + numberOfBakers * 2;
int numMineDifference = ai.FoodFocus + numberOfMines - numPossibleMines;
if (numMineDifference <= 0)
{
return(false);
}
else
{
int numFoodEndBuildings = numberOfFishers + numberOfBakers + numberOfButchers;
switch (type)
{
case Building.Type.Fisher:
if (numFoodEndBuildings == 0)
{
return(ai.GetFoodSourcePriority(0) == 2);
}
return((float)numberOfFishers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(0) / 100.0f);
case Building.Type.Mill:
if (numberOfMills > 1 + numberOfBakers * 2)
{
return(false);
}
if (numberOfCompletedFarms == 0 && game.GetResourceAmountInInventories(player, Resource.Type.Wheat) < 10)
{
return(false);
}
if (numberOfMills < numberOfBakers * 2)
{
return(true);
}
if (numFoodEndBuildings == 0 && numberOfMills == 0)
{
return(ai.GetFoodSourcePriority(1) == 2);
}
return((float)numberOfBakers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(1) / 100.0f);
case Building.Type.Baker:
if (numberOfMills == 0)
{
return(false);
}
if (numFoodEndBuildings == 0)
{
return(ai.GetFoodSourcePriority(1) == 2);
}
return((float)numberOfBakers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(1) / 100.0f);
case Building.Type.PigFarm:
if (numberOfPigFarms > 2 + numberOfButchers * 6)
{
return(false);
}
if (numberOfCompletedFarms == 0 && game.GetResourceAmountInInventories(player, Resource.Type.Wheat) < 10)
{
return(false);
}
if (numberOfPigFarms < numberOfButchers * 6)
{
return(true);
}
if (numFoodEndBuildings == 0 && numberOfPigFarms == 0)
{
return(ai.GetFoodSourcePriority(2) == 2);
}
return((float)numberOfButchers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(2) / 100.0f);
case Building.Type.Butcher:
if (numberOfPigFarms == 0)
{
return(false);
}
if (numFoodEndBuildings == 0)
{
return(ai.GetFoodSourcePriority(2) == 2);
}
return((float)numberOfButchers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(2) / 100.0f);
case Building.Type.Farm:
{
int numNeeded = numberOfMills * 2 + (numberOfPigFarms + 5) / 6;
if (numNeeded > numberOfFarms)
{
return(true);
}
if (numFoodEndBuildings == 0)
{
if (numberOfFarms == 0)
{
return(ai.GetFoodSourcePriority(0) != 2);
}
return(false);
}
/*if (ai.GetFoodSourcePriority(1) == 2)
* return (float)numberOfButchers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(2) / 100.0f;
* else if (ai.GetFoodSourcePriority(2) == 2)
* return (float)numberOfBakers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(1) / 100.0f;
* else
* {
* return (float)numberOfBakers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(1) / 100.0f ||
* (float)numberOfButchers / numFoodEndBuildings < ai.GetFoodSourcePriorityInPercentage(2) / 100.0f;
* }*/
return(false);
}
}
}
return(false);
}
static int BuildingsInArea(Map map, uint basePosition, int range, Building.Type buildingType, Func <Map, uint, Map.FindData> searchFunc, int minDistance = 0)
{
return(map.FindInArea(basePosition, range, searchFunc, minDistance).Count(building => (building as Building).BuildingType == buildingType));
}
public AIStateBuildBuilding(Building.Type buildingType)
: base(AI.State.BuildBuilding)
{
type = buildingType;
}
