Introduced the Buildings mechanics for holdings

DataAccess/DataObjects/BuildingTypeEntity.cs

@@ -0,0 +1,27 @@
+using NuciDAL.DataObjects;
+
+namespace Narivia.DataAccess.DataObjects
+{
+    public class BuildingTypeEntity : EntityBase
+    {
+        public string Name { get; set; }
+
+        public string Description { get; set; }
+
+        public string RequiredResourceId { get; set; }
+
+        public int Price { get; set; }
+
+        public int MaintenanceCost { get; set; }
+
+        public int Income { get; set; }
+
+        public int AttackBonus { get; set; }
+
+        public int DefenceBonus { get; set; }
+
+        public int RecruitmentBonus { get; set; }
+
+        public int ReligionInfluence { get; set; }
+    }
+}

GameLogic/GameManagers/BuildingManager.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Narivia.DataAccess.DataObjects;
+using Narivia.GameLogic.Mapping;
+using Narivia.Models;
+using Narivia.Settings;
+using NuciDAL.Repositories;
+
+namespace Narivia.GameLogic.GameManagers
+{
+    public sealed class BuildingManager : IBuildingManager
+    {
+        readonly Random random;
+        readonly IHoldingManager holdingManager;
+        readonly IWorldManager worldManager;
+
+        string worldId;
+        Dictionary<string, Building> buildings;
+        Dictionary<string, BuildingType> buildingTypes;
+
+        public BuildingManager(
+            string worldId,
+            IHoldingManager holdingManager,
+            IWorldManager worldManager)
+        {
+            random = new Random();
+
+            this.worldId = worldId;
+            this.holdingManager = holdingManager;
+            this.worldManager = worldManager;
+        }
+
+        public void LoadContent()
+        {
+            string buildingsPath = Path.Combine(ApplicationPaths.WorldsDirectory, worldId, "building_types.xml");
+
+            IRepository<BuildingTypeEntity> repository = new XmlRepository<BuildingTypeEntity>(buildingsPath);
+
+            buildings = new Dictionary<string, Building>();
+            buildingTypes = repository.GetAll().ToDictionary(x => x.Id, x => x.ToDomainModel());
+        }
+
+        public void UnloadContent()
+        {
+            buildings.Clear();
+        }
+
+        public Building GetBuilding(string buildingId)
+        => buildings[buildingId];
+
+        public IEnumerable<Building> GetBuildings()
+        => buildings.Values;
+
+        public IEnumerable<Building> GetHoldingBuildings(string holdingId)
+        => buildings.Values.Where(building => building.HoldingId == holdingId);
+
+        public IEnumerable<BuildingType> GetBuildingTypes()
+        => buildingTypes.Values;
+
+        public void BuildBuilding(string holdingId, string buildingTypeId)
+        {
+            BuildingType buildingType = buildingTypes[buildingTypeId];
+            Holding holding = holdingManager.GetHolding(holdingId);
+            Province province = worldManager.GetProvince(holding.ProvinceId);
+            Faction faction = worldManager.GetFaction(province.FactionId);
+
+            AddBuilding(holding.Id, buildingType.Id, faction.CultureId);
+            faction.Wealth -= buildingType.Price;
+        }
+
+        public void AddBuilding(string holdingId, string buildingTypeId, string cultureId)
+        {
+            // TODO: Don't pass cultureId as a parameter
+
+            Building building = new()
+            {
+                Id = $"{holdingId}_{buildingTypeId}",
+                Name = buildingTypes[buildingTypeId].Name,
+                Description = buildingTypes[buildingTypeId].Description,
+                TypeId = buildingTypeId,
+                HoldingId = holdingId,
+                CultureId = cultureId
+            };
+
+            buildings.Add(building.Id, building);
+        }
+    }
+}

GameLogic/GameManagers/IBuildingManager.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Narivia.Models;
+
+namespace Narivia.GameLogic.GameManagers
+{
+    public interface IBuildingManager
+    {
+        void LoadContent();
+
+        void UnloadContent();
+
+        Building GetBuilding(string buildingId);
+
+        IEnumerable<Building> GetBuildings();
+
+        IEnumerable<Building> GetHoldingBuildings(string holdingId);
+
+        IEnumerable<BuildingType> GetBuildingTypes();
+
+        void BuildBuilding(string holdingId, string buildingTypeId);
+
+        void AddBuilding(string holdingId, string buildingTypeId, string cultureId);
+    }
+}

GameLogic/Mapping/BuildingTypeMappingExtensions.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq;
+
+using Narivia.DataAccess.DataObjects;
+using Narivia.Models;
+
+namespace Narivia.GameLogic.Mapping
+{
+    static class BuildingTypeMappingExtensions
+    {
+        internal static BuildingType ToDomainModel(this BuildingTypeEntity entity)
+        => new()
+            {
+                Id = entity.Id,
+                Name = entity.Name,
+                Description = entity.Description,
+                RequiredResourceId = entity.RequiredResourceId,
+                Price = entity.Price,
+                MaintenanceCost = entity.MaintenanceCost,
+                Income = entity.Income,
+                AttackBonus = entity.AttackBonus,
+                DefenceBonus = entity.DefenceBonus,
+                RecruitmentBonus = entity.RecruitmentBonus,
+                ReligionInfluence = entity.ReligionInfluence
+            };
+
+        internal static BuildingTypeEntity ToEntity(this BuildingType domainModel)
+        => new()
+            {
+                Id = domainModel.Id,
+                Name = domainModel.Name,
+                Description = domainModel.Description,
+                RequiredResourceId = domainModel.RequiredResourceId,
+                Price = domainModel.Price,
+                MaintenanceCost = domainModel.MaintenanceCost,
+                Income = domainModel.Income,
+                AttackBonus = domainModel.AttackBonus,
+                DefenceBonus = domainModel.DefenceBonus,
+                RecruitmentBonus = domainModel.RecruitmentBonus,
+                ReligionInfluence = domainModel.ReligionInfluence
+            };
+
+        internal static IEnumerable<BuildingType> ToDomainModels(this IEnumerable<BuildingTypeEntity> entities)
+        => entities.Select(entity => entity.ToDomainModel());
+
+        internal static IEnumerable<BuildingTypeEntity> ToEntities(this IEnumerable<BuildingType> domainModels)
+        => domainModels.Select(domainModel => domainModel.ToEntity());
+    }
+}