nation.hpp

Go to the documentation of this file.

// Symphony of Empires
// Copyright (C) 2021, Symphony of Empires contributors
//
// 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/>.
//
// ----------------------------------------------------------------------------
// Name:
//      nation.hpp
//
// Abstract:
//      Does some important stuff.
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <cstdint>
#include <queue>
#include <deque>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <string>
#include <vector>
#include <functional>
#include "eng3d/string.hpp"
 
#include "objects.hpp"
#include "event.hpp"
#include "indpobj.hpp"
 
class Province;
struct Technology;
class Pop;
namespace TreatyClause {
    class BaseClause;
}
struct Technology;
class Nation : public RefnameEntity<NationId> {
    void do_diplomacy() {
        //diplomatic_timer = glm::max((60 * 48) - glm::min(10.f * 48.f, prestige / 100.f), 4.f);
        diplomatic_timer = 48;
    }
 
    bool can_do_diplomacy() const {
        return diplomatic_timer == 0;
    }
    Nation& operator=(const Nation&) = default;
public:
    struct Relation {
        bool is_allied() const {
            return alliance > 0.f && !has_war;
        }
 
        bool is_customs_union() const {
            return alliance > 0.5f;
        }
 
        bool has_landpass() const {
            return relation > 0.5f || alliance > 0.f || has_war;
        }
 
        float relation = 0.f;
        bool has_war = false;
        float alliance = 0.f; // From 0 to 1; 0 = diplomatic alliance, tariiff excemption
                              // 1 = political alliance, after this they can form a single country
    };
 
    struct ClientHint {
        uint32_t color;
        Eng3D::StringRef name;
        IdeologyId ideology_id;
    };
 
    void declare_war(Nation& nation, std::vector<TreatyClause::BaseClause*> clauses = std::vector<TreatyClause::BaseClause*>());
    bool is_ally(const Nation& nation) const;
    bool is_enemy(const Nation& nation) const;
    void auto_relocate_capital();
    void set_policy(const Policies& policies);
    bool is_accepted_language(const Language& language) const;
    bool is_accepted_religion(const Religion& relgion) const;
    float get_tax(const Pop& pop) const;
    void give_province(Province& province);
    void control_province(Province& province);
    const Nation::ClientHint& get_client_hint() const;
    float get_research_points() const;
    bool can_research(const Technology& tech) const;
    void change_research_focus(const Technology& tech);
    void get_allies(std::function<void(const Nation&)> fn) const;
 
    bool exists() const {
        return !(controlled_provinces.empty());
    }
 
    const Ideology::Subideology& get_subideology() const;
 
    // Policies
    bool can_directly_control_factories() const;
 
    void make_puppet(const Nation& master) {
        this->is_puppeted = true;
        this->puppet_master_id = master.get_id();
    }
 
    bool is_puppeted_by(const Nation& master) const {
        return this->is_puppeted && this->puppet_master_id == master.get_id();
    }
 
    Eng3D::StringRef name;
    float prestige = 0.1f; // Amount of prestige
    // Total budget of the nation (money in ark), this is not equal to GDP, the GDP is the total sum of the price
    // of all products in the nation, which are volatile unless they are sold
    float budget = 10000.f;
    // Default and can be disabled by the player
    bool ai_controlled = true;
    bool ai_do_cmd_troops = true;
 
    bool is_puppeted = false;
    NationId puppet_master_id; // Pupeeter of this nation (if any)
    ProvinceId capital_id; // The capital of this nation (can be invalid id)
    IdeologyId ideology_id; // Current ideology of the nation
    SubideologyId subideology_id; // Current subideology
    TechnologyId focus_tech_id; // Current tech being researched
    Policies current_policy; // Current policy of this nation
    std::vector<float> commodity_production; // Commodity production for each commodity
    uint16_t diplomatic_timer; // Time until a diplomacy can be done
    // Accepted languages in this nation, the accepted languages may have some bonuses on provinces *totally*
    // owned by this nation
    std::vector<float> language_acceptance;
    std::vector<float> religion_discrim;
    // List of provinces which are owned by this nation (including partial ownership)
    std::vector<ProvinceId> owned_provinces;
    std::vector<ProvinceId> controlled_provinces;
    std::deque<Event> inbox; // Inbox of the nation; events that require our attention / should be processed
    std::vector<float> research; // Progress on technologies (1:1)
    std::vector<Nation::ClientHint> client_hints; // Hints for the client on how to draw a nation on the client
    std::unordered_map<std::string, float> flags; // Flags that can be manipulated by events
    std::string client_username; // Used by clients to store usernames from nations - not saved
};
template<>
struct Eng3D::Deser::Serializer<Nation::Relation> {
    template<bool is_const>
    using type = typename Eng3D::Deser::CondConstType<is_const, Nation::Relation>::type;
    template<bool is_serialize>
    static inline void deser_dynamic(Eng3D::Deser::Archive& ar, type<is_serialize>& obj) {
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.alliance);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.has_war);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.relation);
    }
};
template<>
struct Eng3D::Deser::Serializer<Nation::ClientHint> {
    template<bool is_const>
    using type = typename Eng3D::Deser::CondConstType<is_const, Nation::ClientHint>::type;
    template<bool is_serialize>
    static inline void deser_dynamic(Eng3D::Deser::Archive& ar, type<is_serialize>& obj) {
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.color);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.name);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.ideology_id);
    }
};
template<>
struct Eng3D::Deser::Serializer<Nation> {
    template<bool is_const>
    using type = typename Eng3D::Deser::CondConstType<is_const, Nation>::type;
    template<bool is_serialize>
    static inline void deser_dynamic(Eng3D::Deser::Archive& ar, type<is_serialize>& obj) {
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.cached_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.name);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.ref_name);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.is_puppeted);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.puppet_master_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.prestige);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.budget);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.capital_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.commodity_production);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.language_acceptance);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.religion_discrim);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.owned_provinces);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.controlled_provinces);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.current_policy);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.diplomatic_timer);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.inbox);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.client_hints);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.ideology_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.subideology_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.research);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.focus_tech_id);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.flags);
    }
};