market.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 <map>
#include <set>
#include <string>
#include <vector>
 
#include <entt/entt.hpp>
 
#include "core/components/resource.h"
 
namespace cqsp::core::components {
struct MarketOrder {
    entt::entity target;
    double amount;
    double price;
 
    MarketOrder(entt::entity target, double amount, double price) : target(target), amount(amount), price(price) {}
};
 
// A planetary market must have a regular market as well
struct PlanetaryMarket {
    explicit PlanetaryMarket(size_t good_count) : supplied_resources(good_count), supply_difference(good_count) {}
    std::map<entt::entity, std::vector<MarketOrder>> demands;
    std::map<entt::entity, std::vector<MarketOrder>> requests;
    // Resources supplied by the interplanetary market
    ResourceLedger supplied_resources;
    ResourceLedger supply_difference;
};
 
struct Market {
    Market(size_t good_count)
        : demand(good_count),
          supply(good_count),
          sd_ratio(good_count),
          volume(good_count),
          price(good_count),
          chronic_shortages(good_count),
          trade(good_count),
          resource_fulfilled(good_count),
          production(good_count),
          consumption(good_count),
          market_access(good_count) {}
 
    Market(const Market&) = default;      // Copy Constructor
    Market(Market&&) noexcept = default;  // Move Constructor
 
    Market& operator=(const Market&) = default;      // Copy Assignment
    Market& operator=(Market&&) noexcept = default;  // Move Assignment
 
    ~Market() = default;
 
    ResourceLedger demand;
    ResourceLedger supply;
    ResourceLedger sd_ratio;
 
    ResourceLedger volume;
    ResourceLedger price;
    ResourceLedger chronic_shortages;
    ResourceLedger trade;
    ResourceLedger resource_fulfilled;
    ResourceLedger production;
    ResourceLedger consumption;
 
    void ResetLedgers() {
        // Reset the ledger values
        demand.clear();
        supply.clear();
    }
 
    std::set<entt::entity> participants;
 
    std::vector<entt::entity> connected_markets;
 
    ResourceLedger market_access;
 
    entt::entity parent_market = entt::null;
 
    double GDP = 0;
    // How much money we are creating from thin air
    // Cumulative deficit
    double deficit = 0;
    // Deficit in last tick
    double last_deficit = 0;
 
    double trade_deficit = 0;
    double last_trade_deficit = 0;
 
    void AddParticipant(entt::entity participant) { participants.insert(participant); }
};
 
struct Price {
    double price;
 
    operator double() { return price; }
};
 
struct Currency {};
 
struct CostTable : public ResourceMap {};
 
// TODO(EhWhoAmI): Add multiple currency support
struct Wallet {
    Wallet() = default;
    Wallet(entt::entity _currency, double _balance) : balance(_balance), currency(_currency) {}
 
    Wallet& operator+=(const double amount) {
        this->balance += amount;
        change += amount;
        return *this;
    }
    Wallet& operator-=(const double amount) {
        this->balance -= amount;
        change -= amount;
        GDP_change += amount;
        // Record the money delta since last reset
        return *this;
    }
 
    // Basic multiplication that logs the change
    // TODO(EhWhoAmI): Make sure this is correct
    Wallet& operator*=(const double coefficent) {
        double newbalance = this->balance * coefficent;
        double change = newbalance - this->balance;
        if (change > 0) {
            *this += change;
        } else if (change < 0) {
            *this -= change * -1;
        }
        return *this;
    }
 
    operator double() const { return balance; }
 
    Wallet& operator=(double _balance) {
        change += (_balance - balance);
        if ((_balance - balance) < 0) {
            GDP_change += _balance - balance;
        }
        balance = _balance;
        return *this;
    }
 
    double GetBalance() const { return balance; }
 
    double GetChange() const { return change; }
 
    void Reset() {
        change = 0;
        GDP_change = 0;
    }
    double GetGDPChange() { return GDP_change; }
 
 private:
    double balance = 0;
    double change = 0;
    // Only records when spending money, so when money decreases
    double GDP_change = 0;
    entt::entity currency;
};
 
struct MarketAgent {
    entt::entity market;
};
 
// This trade node has international connections
// For space connections, the spaceport struct exists
struct InternationalPort {};
 
struct Commercial {
    entt::entity city;
    int size;
};
 
// Something that hires people, and will pay the people
struct Employer {
    int population_needed;
    int population_fufilled;
    int population_change = 0;
    entt::entity segment;
 
    // Hiring freezes and layoff flags
};
 
struct LaborInformation {
    int working_population;
    int employed_population;
};
 
struct FactoryProducing {};
 
// This facility is bankrolled by something else, so if they run out of money
// they can go to this wallet to ask for cash?
struct Owned {
    entt::entity owner;
};
 
struct TradePartners : std::vector<entt::entity> {};
}  // namespace cqsp::core::components