resourceledger.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 <cstdint>
#include <map>
#include <string>
#include <vector>
 
namespace cqsp::core::components {
enum class GoodEntity : uint32_t { null = static_cast<uint32_t>(-1) };
 
// NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
constexpr GoodEntity ToGoodEntity(uint32_t val) { return static_cast<GoodEntity>(val); }
class ResourceLedger;
class ResourceVector;
 
typedef std::map<GoodEntity, double> LedgerMap;
 
class /* [[deprecated]] */ ResourceMap : private LedgerMap {
 public:
    ResourceMap() = default;
    ~ResourceMap() = default;
 
    double operator[](const GoodEntity) const;
 
    bool EnoughToTransfer(const ResourceMap& amount);
 
    void operator-=(const ResourceMap&);
    void operator+=(const ResourceMap&);
    void operator*=(const ResourceMap&);
    void operator/=(const ResourceMap&);
 
    void operator-=(const ResourceLedger&);
    void operator+=(const ResourceLedger&);
    void operator*=(const ResourceLedger&);
    void operator/=(const ResourceLedger&);
 
    void operator-=(const ResourceVector&);
    void operator+=(const ResourceVector&);
    void operator*=(const ResourceVector&);
    void operator/=(const ResourceVector&);
 
    void operator-=(const double value);
    void operator+=(const double value);
    void operator*=(const double value);
    void operator/=(const double value);
 
    ResourceMap operator-(const ResourceMap&) const;
    ResourceMap operator+(const ResourceMap&) const;
    ResourceMap operator*(const ResourceMap&) const;
    ResourceMap operator/(const ResourceMap&) const;
    ResourceMap operator-(const double value) const;
    ResourceMap operator+(const double value) const;
    ResourceMap operator*(const double value) const;
    ResourceMap operator/(const double value) const;
 
    bool operator<(const ResourceMap&);
 
    bool operator>(const ResourceMap&);
 
    bool operator<=(const ResourceMap&);
 
    bool operator>=(const ResourceMap&);
 
    bool LedgerEquals(const ResourceMap&);
 
    bool operator>(const double&);
 
    bool operator<(const double&);
 
    bool operator==(const double&);
 
    bool operator<=(const double&);
    bool operator>=(const double&);
 
    void AssignFrom(const ResourceMap&);
 
    void TransferTo(ResourceMap&, const ResourceMap&);
    // Equivalant to this += other * double
    void MultiplyAdd(const ResourceMap&, double);
    void MultiplyAdd(const ResourceVector&, double);
 
    void RemoveResourcesLimited(const ResourceMap&);
 
    ResourceMap LimitedRemoveResources(const ResourceMap&);
 
    ResourceMap UnitLedger(const double);
 
    // Add all the positive values in the other ledger to this ledger
    // Essentially this += other (if idx > 0)
    void AddPositive(const ResourceMap&);
 
    // Add all the negative values in the other ledger to this ledger
    // Essentially this += abs(other) (if idx < 0)
    void AddNegative(const ResourceMap&);
 
    ResourceMap Clamp(const double, const double);
 
    ResourceMap SafeDivision(const ResourceMap&);
 
    ResourceMap SafeDivision(const ResourceMap&, double);
 
    double Average();
 
    double Min();
    double Max();
 
    bool HasAllResources(const ResourceMap&);
 
    bool HasGood(GoodEntity good) { return (*this).find(good) != (*this).end(); }
 
    double GetSum();
 
    double MultiplyAndGetSum(ResourceMap& 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;
};
 
class ResourceVector : public std::vector<std::pair<GoodEntity, double>> {
    typedef std::pair<GoodEntity, double> LedgerPair;
    typedef std::vector<LedgerPair> LedgerVector;
 
 public:
    ResourceVector() = default;
    ~ResourceVector() = default;
 
    void operator-=(const ResourceMap&);
    void operator+=(const ResourceMap&);
    void operator*=(const ResourceMap&);
    void operator/=(const ResourceMap&);
 
    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);
 
    ResourceVector operator-(const double value) const;
    ResourceVector operator+(const double value) const;
    ResourceVector operator*(const double value) const;
    ResourceVector operator/(const double value) const;
 
    ResourceVector operator+(const ResourceVector& other) const;
    ResourceVector operator*(const ResourceVector& other) const;
 
    double Average();
 
    double Min();
    double Max();
    GoodEntity MinGood();
    GoodEntity MaxGood();
 
    void Finalize();
 
    bool HasGood(const GoodEntity& good) const;
 
    double operator[](const GoodEntity& good) const;
 
    double GetSum();
 
    double MultiplyAndGetSum(const ResourceLedger& other) const;
 
    bool contains(const GoodEntity& entity) const;
 
    // All the things that we get from map
    using LedgerVector::operator=;
    using LedgerVector::begin;
    using LedgerVector::cbegin;
    using LedgerVector::cend;
    using LedgerVector::clear;
    using LedgerVector::crbegin;
    using LedgerVector::crend;
    using LedgerVector::emplace;
    using LedgerVector::empty;
    using LedgerVector::end;
    using LedgerVector::erase;
    using LedgerVector::rbegin;
    using LedgerVector::rend;
    using LedgerVector::size;
};
 
class ResourceLedger {
 private:
    std::vector<double> ledger;
 
 public:
    explicit ResourceLedger(size_t count);
 
    operator ResourceMap() const;
 
    double operator[](const GoodEntity value) const;
    double& operator[](const GoodEntity value);
 
    bool EnoughToTransfer(const ResourceLedger& amount);
 
    void operator-=(const ResourceLedger&);
    void operator+=(const ResourceLedger&);
    void operator*=(const ResourceLedger&);
    void operator/=(const ResourceLedger&);
 
    void operator-=(const ResourceMap&);
    void operator+=(const ResourceMap&);
    void operator*=(const ResourceMap&);
    void operator/=(const ResourceMap&);
 
    void operator-=(const ResourceVector&);
    void operator+=(const ResourceVector&);
    void operator*=(const ResourceVector&);
    void operator/=(const ResourceVector&);
 
    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 ResourceMap&) const;
    ResourceLedger operator+(const ResourceMap&) const;
    ResourceLedger operator*(const ResourceMap&) const;
    ResourceLedger operator/(const ResourceMap&) 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 operator>(const double&);
 
    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& ledger_to, const ResourceLedger& amount);
    // Equivalent to this += other * double
    void MultiplyAdd(const ResourceLedger&, 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 MultiplyAndGetSum(const ResourceMap& other) const;
    double MultiplyAndGetSum(const ResourceLedger& other) const;
 
    double Average() const;
 
    double Min() const;
    double Max() const;
 
    double GetSum();
 
    auto begin() { return ledger.begin(); }
 
    auto end() { return ledger.end(); }
 
    size_t size() { return ledger.size(); }
 
    void clear();
};
 
ResourceMap CopyVals(const ResourceMap& keys, const ResourceMap& values);
}  // namespace cqsp::core::components