area.h

Go to the documentation of this file.

/* Conquer Space
 * Copyright (C) 2021-2025 Conquer Space
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <string>
#include <vector>
 
#include <entt/entt.hpp>
 
#include "core/components/modifier.h"
#include "core/components/resourceledger.h"
 
namespace cqsp::core::components {
struct IndustrialZone {
    std::vector<entt::entity> industries;
};
 
struct PowerPlants {
    std::vector<entt::entity> power_plants;
};
 
struct Construction {
    int progress;
    int maximum;
    int levels;
};
 
enum class ProductionType { factory, mine, service };
 
struct Factory {};
 
struct Mine {};
 
struct Service {};
 
struct Farm {
    // Farms have a harvest period?
    // Farms can fluctuate between how much they generate per tick.
    // Also add food good
};
 
struct RawResourceGen {};
 
enum struct IndustryState {
    SteadyState,
    MaximumProduction,
    MinimumProduction,
    Construction,
    Demolishing,
    Shrinking,
    Expanding,
    Shortage
};
 
inline std::string IndustryStateToString(IndustryState state) {
    switch (state) {
        case IndustryState::SteadyState:
            return "Steady State";
        case IndustryState::MaximumProduction:
            return "Maximum Production";
        case IndustryState::MinimumProduction:
            return "Minimum Production";
        case IndustryState::Construction:
            return "Construction";
        case IndustryState::Demolishing:
            return "Demolishing";
        case IndustryState::Shrinking:
            return "Shrinking";
        case IndustryState::Expanding:
            return "Expanding";
        case IndustryState::Shortage:
            return "Shortage";
    }
}
 
// Factory size
struct ProductionUnit {
    // The size of the factory.
    // the maximum output of the factory is
    double size;
    // The utilization of the factory.
    double utilization = 0;
    double diff = 0;
 
    ResourceVector workers;
    bool shortage = false;
    double cumulative_pr = 0;
    int continuous_gains = 0;
    int stability = 0;
    double expertise = 1;
 
    MultiplicativeModifier expertise_gain = 0.0001;
    AdditiveModifier max_expertise = 1.5;
    double throughput = 1.;
 
    // Zoning requirements...
    std::pair<entt::entity, int> consumption;
 
    ProductionType type;
    entt::entity recipe;
 
    IndustryState state = IndustryState::SteadyState;
 
    double revenue;
    // How much it paid in materials to produce goods
    double material_costs;
    // How much cash it took to maintain the factory
    double maintenance;
    double power_consumption = 0;
    // How much it paid to people
    double wage_cost;
    double tax_cost;
    double construction_cost;
    double profit;
    // How much it paid in transport fees
    double transport;
    // How much in (percent) subsidies you are adding to the output
    double output_subsidy = 0.0;
    double output_subsidy_amount = 0.0;
 
    double amount_sold = 0;
 
    void Reset() {
        revenue = 0;
        material_costs = 0;
        maintenance = 0;
        wage_cost = 0;
        profit = 0;
        amount_sold = 0;
        transport = 0;
    }
 
    double ProfitMargin() { return profit / (revenue + 0.0001); }
};
 
struct ZoningType {};
}  // namespace cqsp::core::components