resource.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 <iostream>
#include <map>
#include <string>
#include <vector>
 
#include <entt/entt.hpp>
 
#include "common/components/area.h"
#include "common/components/units.h"
 
namespace cqsp::common::components {
struct Matter {
    types::meter_cube volume;
    types::kilogram mass;
};
 
struct Energy {
    // Energy per unit
    types::joule energy;
};
 
struct Unit {
    std::string unit_name;
};
 
struct Good {};
 
struct ConsumerGood {
    double autonomous_consumption;
    double marginal_propensity;
};
 
struct Mineral {};
// Good is for capital goods
struct CapitalGood {};
 
typedef std::map<entt::entity, double> LedgerMap;
 
class ResourceLedger : private LedgerMap {
 public:
    ResourceLedger() = default;
    ~ResourceLedger() = default;
 
    double operator[](const entt::entity) const;
 
    bool EnoughToTransfer(const ResourceLedger& amount);
 
    void operator-=(const ResourceLedger&);
    void operator+=(const ResourceLedger&);
    void operator*=(const ResourceLedger&);
    void operator/=(const ResourceLedger&);
    void operator-=(const double value);
    void operator+=(const double value);
    void operator*=(const double value);
    void operator/=(const double value);
 
    ResourceLedger operator-(const ResourceLedger&) const;
    ResourceLedger operator+(const ResourceLedger&) const;
    ResourceLedger operator*(const ResourceLedger&) const;
    ResourceLedger operator/(const ResourceLedger&) const;
    ResourceLedger operator-(const double value) const;
    ResourceLedger operator+(const double value) const;
    ResourceLedger operator*(const double value) const;
    ResourceLedger operator/(const double value) const;
 
    bool operator<(const ResourceLedger&);
 
    bool operator>(const ResourceLedger&);
 
    bool operator<=(const ResourceLedger&);
 
    bool operator>=(const ResourceLedger&);
 
    bool LedgerEquals(const ResourceLedger&);
 
    bool operator>(const double&);
 
    bool operator<(const double&);
 
    bool operator==(const double&);
 
    bool operator<=(const double&);
    bool operator>=(const double&);
 
    void AssignFrom(const ResourceLedger&);
 
    void TransferTo(ResourceLedger&, const ResourceLedger&);
    // Equivalant to this += other * double
    void MultiplyAdd(const ResourceLedger&, double);
 
    void RemoveResourcesLimited(const ResourceLedger&);
 
    ResourceLedger LimitedRemoveResources(const ResourceLedger&);
 
    ResourceLedger UnitLedger(const double);
 
    // Add all the positive values in the other ledger to this ledger
    // Essentially this += other (if idx > 0)
    void AddPositive(const ResourceLedger&);
 
    // Add all the negative values in the other ledger to this ledger
    // Essentially this += abs(other) (if idx < 0)
    void AddNegative(const ResourceLedger&);
 
    ResourceLedger Clamp(const double, const double);
 
    ResourceLedger SafeDivision(const ResourceLedger&);
 
    ResourceLedger SafeDivision(const ResourceLedger&, double);
 
    double Average();
 
    double Min();
    double Max();
 
    bool HasAllResources(const ResourceLedger&);
 
    bool HasGood(entt::entity good) { return (*this).find(good) != (*this).end(); }
 
    double GetSum();
 
    double MultiplyAndGetSum(ResourceLedger& other);
 
    std::string to_string();
 
    // All the things that we get from map
    using LedgerMap::operator[];
    using LedgerMap::operator=;
    using LedgerMap::begin;
    using LedgerMap::cbegin;
    using LedgerMap::cend;
    using LedgerMap::clear;
    using LedgerMap::contains;
    using LedgerMap::crbegin;
    using LedgerMap::crend;
    using LedgerMap::emplace;
    using LedgerMap::empty;
    using LedgerMap::end;
    using LedgerMap::erase;
    using LedgerMap::mapped_type;
    using LedgerMap::rbegin;
    using LedgerMap::rend;
    using LedgerMap::size;
    using LedgerMap::value_comp;
};
 
ResourceLedger CopyVals(const ResourceLedger& keys, const ResourceLedger& values);
 
struct RecipeOutput {
    entt::entity entity;
    double amount;
    ResourceLedger operator*(const double value) const;
    ResourceLedger operator*(ResourceLedger&) const;
};
 
struct Recipe {
    ResourceLedger input;
    RecipeOutput output;
    ProductionType type;
    float interval;
    // The actual factory worker amount is workers * productivity
    double workers;
 
    ResourceLedger capitalcost;
};
 
struct RecipeCost {
    ResourceLedger fixed;
    ResourceLedger scaling;
};
 
// Factory size
struct IndustrySize {
    // The size of the factory.
    // the maximum output of the factory is
    double size;
    // The utilization of the factory.
    double utilization;
    double diff;
    double diff_delta;
 
    int workers;
    bool shortage = false;
    double wages = 10;
};
 
struct CostBreakdown {
    double revenue;
    // How much it paid in materials to produce goods
    double materialcosts;
    // How much cash it took to maintain the factory
    double maintenance;
    // How much it paid to people
    double wages;
    double profit;
    // How much it paid in transport fees
    double transport;
 
    void Reset() {
        revenue = 0;
        materialcosts = 0;
        maintenance = 0;
        wages = 0;
        profit = 0;
        transport = 0;
    }
};
 
// TODO(AGM): Remove
struct FactoryTimer {
    float interval;
    float time_left;
};
 
struct ResourceConsumption : public ResourceLedger {};
struct ResourceProduction : public ResourceLedger {};
 
struct ResourceConverter {
    entt::entity recipe;
};
 
struct ResourceStockpile : public ResourceLedger {};
 
struct FailedResourceTransfer {
    // Ledgers later to show how much
};
 
struct FailedResourceProduction {};
 
struct FailedResourceConsumption {};
 
struct ResourceDistribution {
    std::map<entt::entity, double> dist;
};
}  // namespace cqsp::common::components