Building.adept

enum BuildingKind (CENTER, DEPOT, FACTORY)
enum ProductionKind (UNIT)

struct Production (kind ProductionKind, id usize, progress, progress_speed float, done_sound Sound) {
    constructor(unit_kind UnitKind, progress_speed float, done_sound Sound) {
        this.kind = ProductionKind::UNIT
        this.id = unit_kind as usize
        this.progress = 0.0
        this.progress_speed = progress_speed
        this.done_sound = done_sound
    }
}

struct Building (kind BuildingKind, x, y, w, h float, texture CaptTexture, id usize, name String, production <Production> Optional) {
    constructor(kind BuildingKind, x, y float) {
        this.kind = kind
        this.x = x
        this.y = y
        this.id = gamedata.next_id++
        this.production = none() ~> <Production> Optional
        
        exhaustive switch kind {
        case BuildingKind::CENTER
            this.name = "Center"
            this.w = 128.0f
            this.h = 128.0f
            this.texture = textures.center
        case BuildingKind::DEPOT
            this.name = "Shooting Range"
            this.w = 64.0f
            this.h = 64.0f
            this.texture = textures.depot
        case BuildingKind::FACTORY
            this.name = "Factory"
            this.w = 64.0f
            this.h = 64.0f
            this.texture = textures.factory
        }
    }

    func update {
        if this.production.isSome() {
            production *Production = this.production.getPointer()

            production.progress += production.progress_speed

            if production.progress >= 1.0f {
                exhaustive switch production.kind {
                case ProductionKind::UNIT
                    gamedata.units.add(Unit(production.id as UnitKind, this.x, this.y + this.h / 2.0f))
                    gamedata.playSound(production.done_sound)
                }

                this.production = none() ~> <Production> Optional
            }
        }
    }

    func pickOption(index usize) successful {
        if this.production.isSome(), return false

        exhaustive switch this.kind {
        case BuildingKind::CENTER
            switch index {
            case 0
                if gamedata.ore < 50 {
                    gamedata.playSound(sfx.error)
                    return false
                }

                this.production = some(Production(UnitKind::WORKER, 0.005f, sfx.worker_ready))
                gamedata.ore -= 50
            }
        case BuildingKind::DEPOT
            switch index {
            case 0
                if gamedata.ore < 50 {
                    gamedata.playSound(sfx.error)
                    return false
                }

                this.production = some(Production(UnitKind::MARINE, 0.005f, sfx.marine_ready))
                gamedata.ore -= 50
                return true
            }
        case BuildingKind::FACTORY
            switch index {
            case 0
                if gamedata.ore < 100 or gamedata.gas < 50 {
                    gamedata.playSound(sfx.error)
                    return false
                }

                this.production = some(Production(UnitKind::CANNON, 0.002f, sfx.cannon_ready))
                gamedata.ore -= 100
                gamedata.gas -= 50
                return true
            }
        }
        return false
    }

    func draw {
        captDrawTexture(this.texture, this.x - this.w/2.0f, this.y - this.h/2.0f, this.w, this.h)
    }

    func drawOptions {
        exhaustive switch this.kind {
        case BuildingKind::CENTER
            drawSingleOption(0, textures.worker)
        case BuildingKind::DEPOT
            drawSingleOption(0, textures.marine)
        case BuildingKind::FACTORY
            drawSingleOption(0, textures.cannon)
        }
    }

    func drawProgress {
        if this.production.isSome() {
            progress float = this.production.getPointer().progress
            captDrawTexture(textures.grey, this.x - this.w/2.0f, this.y - 3.0f*this.h/8.0f, this.w, 8.0f)
            captDrawTexture(textures.white, this.x - this.w/2.0f, this.y - 3.0f*this.h/8.0f, this.w * progress, 8.0f)
        }
    }

    func getAABB <float> AABB {
        return AABB(this.x - this.w/2.0f, this.y - this.h/2.0f, this.w, this.h)
    }
}