namespace CityBuilder

​

module Buildings =

    type MagicItemInfo = {

        minor : int

        medium : int

        major : int     

    }

    let defaultMagicItemInfo = {

        minor = 0

        medium = 0

        major = 0

    } 

​

    type Bonuses = {

        economy : int

        loyalty : int

        stability : int

        fame : int

        defense : int

        addedValue : int

    }

    let defaultBonuses = {

        economy = 0

        loyalty = 0

        stability = 0

        fame = 0

        defense = 0

        addedValue = 0

    }

​

    type Upgrades = {

        upgradeTo : string option // can upgrade to this building

        upgradeFrom : string option // upgraded from this building

    }

    let defaultUpgrades = {

        upgradeTo = None

        upgradeFrom = None

    }

​

    type CostImpacts = {

        impacts : string list // these buildings get half off

        impactedBy : string list // these building offer half off for this building 

    }

    let defaultCostImpacts = {

        impacts = List.empty

        impactedBy = List.empty

    }

​

    type Terrain = Water | Land

​

    type BuildingType = Empty | House // only known building constraint right now

​

    type Constraint = // a constraint is either

        | Building of BuildingType * int  // a building constraint specifying a building type and a required quantity

        | Terrain of Terrain // or must have this terrain

        | TotalCount of int

​

    type BuildingCost = {

        bp : int

        unrest : int

    }

    let defaultCost = {

        bp = 0

        unrest = 0

    }

​

    type BuildDef = {

        name : string // unique across buildDefs

        buildingType : BuildingType

        size : int

        cost : BuildingCost

        bonuses : Bonuses // required 

        items : MagicItemInfo option // optional magic item info

        upgrades : Upgrades option // not all buildings have upgrades

        impacts : CostImpacts option // not all buildings impact other buildings' costs

        constraints : Constraint list // not all buildings have building constraints

    }

    let defaultBuilding = {

        name = ""

        buildingType = Empty

        size = 0

        cost = defaultCost

        bonuses = defaultBonuses

        items = None

        upgrades = None

        impacts = None

        constraints = List.empty

    }

​

    let createBuilding name size bpCost e l s f def value = 

        {defaultBuilding with

            name = name

            size = size

            cost = {defaultCost with bp = bpCost}

            bonuses = {defaultBonuses with economy = e; loyalty = l; stability = s; fame = f; defense = def; addedValue = value}

        }

open Buildings

​

module City =

    type BorderInfo = {

        north : Terrain

        east : Terrain

        south : Terrain

        west : Terrain

    }

    type Position = {

        row : int

        col : int

    }

​

    type ConstructedBuilding = {

        pos : Position

        def : BuildDef

        name : string

    }

​

    type CityGrid = { // only allows square cities

        walls : BorderInfo

        sideLength : int

        buildings : ConstructedBuilding list

        terrain : (Position * Terrain) list

    }

open City

open Buildings

​

module Utils =

    let addBonuses (acc:Bonuses) (bonus:Bonuses) =

        {defaultBonuses with

            economy = acc.economy + bonus.economy

            defense = acc.defense + bonus.defense

            addedValue = acc.addedValue + bonus.addedValue

            fame = acc.fame + bonus.fame

            loyalty = acc.loyalty + bonus.loyalty

            stability = acc.stability + bonus.stability

        }

​

    /// <summary>

    /// aggregates the bonuses across all city buildings

    /// </summary>

    /// <param name="city"></param>

    let sumCityBonuses (city: CityGrid) = 

        city.buildings

        |> List.map (fun building -> building.def.bonuses)

        |> List.fold addBonuses defaultBonuses

​

    /// <summary>

    /// compares the bonuses for two cities, so if a > b

    /// </summary>

    /// <param name="a"></param>

    /// <param name="b"></param>

    let cmpBonuses a b = 

        sumCityBonuses a > sumCityBonuses b 

​

    let isWithinWalls size pos =

        pos.row <= size && pos.row >= 0 && pos.col <= size && pos.col >= 0

​

    let sumBuildingsWithType (buildings:BuildDef list) t =

        buildings

        |> List.filter (fun b -> b.buildingType = t)

        |> List.length

​

    let getTerrainAtPos pos city =

        let maybe =

            city.terrain

            |> List.tryFind (fun (p, t) -> pos = p)

        match maybe with

        | None -> None

        | Some (p,t) -> Some t

​

    let getBuildingAtPos pos city =

        let maybe = 

            city.buildings

            |> List.tryFind ( fun b -> b.pos = pos)

        match maybe with

        | None -> None

        | Some b -> Some b.def

    let evalConstraint (city:CityGrid) (limit:Constraint) (pos:Position) =

        let buildings = city.buildings |> List.map (fun n -> n.def)

        let destBuilding = getBuildingAtPos pos city

        let destBuildingType = 

            match destBuilding with

            | None -> failwith "no building at that pos"

            | Some t -> t.buildingType

​

        match limit with

        | Building (t, n) -> (sumBuildingsWithType buildings t) > n

        | TotalCount n -> (sumBuildingsWithType buildings destBuildingType) > n           

        | Terrain t -> 

            match (getTerrainAtPos pos city) with 

            | None -> false

            | Some tPos -> tPos = t                               

​

    let meetsConstraints city (building:BuildDef) pos =

        building.constraints

        |> List.fold (fun acc con -> acc && evalConstraint city con pos) true

​

    /// <summary>

    /// adds a building to a city with the given name and position, if 

    ///     that position is valid

    ///     that position is not occupied

    ///     the building constraints are met

    /// </summary>

    /// <param name="city"></param>

    /// <param name="building"></param>

    /// <param name="name"></param>

    /// <param name="pos"></param>

    let addBuilding city building name pos =

        if not (isWithinWalls city.sideLength pos) then failwith "not enough size"

        if (getBuildingAtPos pos city).IsSome then failwith "position already occupied"

        if not (meetsConstraints city building pos) then failwith "doesn't meet constraints"

​

        let constructed = {

            pos = pos

            def = building

            name = name

        }

        city.buildings @ [constructed]

​