world.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:
//      world.hpp
//
// Abstract:
//      Does some important stuff.
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <cstdlib>
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <mutex>
#include <string>
#include <memory>
#include <array>
 
#include <glm/vec2.hpp>
 
#include "eng3d/profiler.hpp"
#include "eng3d/string.hpp"
#include "eng3d/log.hpp"
#include "eng3d/luavm.hpp"
 
#include "nation.hpp"
#include "product.hpp"
#include "indpobj.hpp"
#include "building.hpp"
#include "indpobj.hpp"
#include "indpobj.hpp"
#include "server/lua_api.hpp"
#include "server/economy.hpp"
#include "province.hpp"
#include "unit.hpp"
#include "indpobj.hpp"
#include "event.hpp"
#include "diplomacy.hpp"
#include "indpobj.hpp"
 
// Create a new list from a type, with helper functions
#define LIST_FOR_TYPE(type, list, list_type)\
    inline const list_type<type*>& get_list(const type* = nullptr) const {\
        return list;\
    };\
    inline list_type<type*>& get_list(const type* = nullptr) {\
        return list;\
    };\
    list_type<type*> list;
 
#define CONST_LIST_FOR_LOCAL_TYPE(type, list, list_type)\
    inline const list_type<type>& get_list(const type* = nullptr) const {\
        return list;\
    };\
    inline list_type<type>& get_list(const type* = nullptr) {\
        return list;\
    };\
    inline void insert(type& ptr) {\
        auto& type_list = this->get_list((type*)nullptr);\
        std::scoped_lock lock(list_mutex);\
        ptr.cached_id = type::Id(type_list.size());\
        Eng3D::Log::debug("world_insert", "Inserting object " #type " with ID=" + std::to_string(static_cast<size_t>(ptr.cached_id)));\
        type_list.push_back(ptr);\
    };\
    list_type<type> list;
 
#define LIST_FOR_LOCAL_TYPE(type, list, list_type)\
    inline const list_type<type>& get_list(const type* = nullptr) const {\
        return list;\
    };\
    inline list_type<type>& get_list(const type* = nullptr) {\
        return list;\
    };\
    inline void insert(type& ptr) {\
        auto& type_list = this->get_list((type*)nullptr);\
        std::scoped_lock lock(list_mutex);\
        ptr.cached_id = type::Id(type_list.size());\
        Eng3D::Log::debug("world_insert", "Inserting object " #type " with ID=" + std::to_string(static_cast<size_t>(ptr.cached_id)));\
        type_list.push_back(ptr);\
    };\
    inline void remove(type& ptr) {\
        size_t cached_id = static_cast<size_t>(this->get_id<type>(ptr));\
        auto& type_list = this->get_list((type*)nullptr);\
        std::scoped_lock lock(list_mutex);\
        cached_id = type_list.size();\
        Eng3D::Log::debug("world_remove", "Removing object " #type " with ID=" + std::to_string(static_cast<size_t>(cached_id)));\
        for(size_t i = cached_id + 1; i < type_list.size(); i++)\
            type_list[i].cached_id = type::Id(static_cast<size_t>(type_list[i].cached_id) - 1);\
        type_list.erase(type_list.begin() + cached_id);\
    };\
    list_type<type> list;
 
// Contains the main world class object, containing all the data relevant for the simulation
class World {
public:
    constexpr static unsigned int ticks_per_month = 30;
 
    World() = default;
    World& operator=(const World&) = delete;
    ~World() = default;
    static World& get_instance() {
        extern World g_world;
        return g_world;
    }
    void do_tick();
    void init_lua();
    void load_initial();
    void load_mod();
    void fire_special_event(const std::string_view event_ref_name, const std::string_view nation_ref_name, const std::string_view other_nation_ref_name);
    Eng3D::Profiler profiler;
 
    LIST_FOR_LOCAL_TYPE(Commodity, commodities, std::vector)
    LIST_FOR_LOCAL_TYPE(Language, languages, std::vector)
    LIST_FOR_LOCAL_TYPE(PopType, pop_types, std::vector)
    LIST_FOR_LOCAL_TYPE(UnitType, unit_types, std::vector)
    LIST_FOR_LOCAL_TYPE(BuildingType, building_types, std::vector)
    LIST_FOR_LOCAL_TYPE(Ideology, ideologies, std::vector)
    LIST_FOR_LOCAL_TYPE(Religion, religions, std::vector)
    LIST_FOR_LOCAL_TYPE(Technology, technologies, std::vector)
    LIST_FOR_LOCAL_TYPE(TerrainType, terrain_types, std::vector)
    CONST_LIST_FOR_LOCAL_TYPE(Province, provinces, std::vector)
    CONST_LIST_FOR_LOCAL_TYPE(Nation, nations, std::vector)
    LIST_FOR_LOCAL_TYPE(Event, events, std::vector)
    LIST_FOR_LOCAL_TYPE(Treaty, treaties, std::vector)
    UnitManager unit_manager;
    ProvinceManager province_manager;
    Economy::EconomyState economy_state;
 
    template<typename T>
    inline void insert(T& ptr) {
        auto& list = this->get_list((T*)nullptr);
        list_mutex.lock();
        ptr.cached_id = list.size();
        assert(ptr.cached_id < static_cast<typename T::Id>(-2));
        list.push_back((T*)&ptr);
        list_mutex.unlock();
    }
 
    template<typename T>
    inline void remove(T& ptr) {
        size_t cached_id = static_cast<size_t>(this->get_id<T>(ptr));
        auto& list = this->get_list((T*)nullptr);
        list_mutex.lock();
        for(size_t i = cached_id + 1; i < list.size(); i++)
            list[i].cached_id = T::Id(static_cast<size_t>(list[i].cached_id) - 1);
        // Remove the element itself
        list.erase(list.begin() + cached_id);
        list_mutex.unlock();
    }
 
    template<typename T>
    inline typename T::Id get_id(const T& obj) const {
        return obj.cached_id;
    }
 
    inline float get_dist_from_equator(float y) const {
        return std::fabs(std::fabs(y) - (this->width / 2.0));
    }
 
    std::vector<Nation::Relation> relations;
 
    Nation::Relation& get_relation(NationId a, NationId b) {
        assert(a != b);
        if(b > a) std::swap(a, b);
        return relations[a + b * nations.size()];
    }
 
    const Nation::Relation& get_relation(NationId a, NationId b) const {
        assert(a != b);
        if(b > a) std::swap(a, b);
        return relations[a + b * nations.size()];
    }
 
    int get_year(void) const {
        return this->time / this->ticks_per_month / 12;
    }
 
    int get_month(void) const {
        return (this->time / this->ticks_per_month) % 12;
    }
 
    int get_day(void) const {
        return this->time % this->ticks_per_month;
    }
 
    Eng3D::LuaVM lua;
 
    // 2D Array of tiles
    std::unique_ptr<ProvinceId[]> tiles;
    size_t width, height;
    int time;
 
    bool needs_to_sync = false;
    std::mutex world_mutex;
    std::mutex list_mutex;
    std::mutex inbox_mutex;
    std::vector<std::pair<Decision, NationId>> taken_decisions;
};
template<>
struct Eng3D::Deser::Serializer<World> {
    template<bool is_const>
    using type = typename Eng3D::Deser::CondConstType<is_const, World>::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.width);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.height);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.time);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.commodities);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.unit_types);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.religions);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.languages);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.pop_types);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.terrain_types);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.building_types);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.ideologies);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.technologies);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.nations);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.provinces);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.events);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.treaties);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.unit_manager);
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, obj.relations);
 
        // Savefiles do not contain the tiles
        bool has_tiles = obj.tiles.get() != nullptr;
        Eng3D::Deser::deser_dynamic<is_serialize>(ar, has_tiles);
        if(has_tiles) {
            if constexpr(is_serialize) {
                // Serialize all tiles
                ar.expand(obj.width * obj.height * sizeof(ProvinceId));
                ar.copy_from(obj.tiles.get(), obj.width * obj.height * sizeof(ProvinceId));
            } else {
                // In order to avoid post-deserialization relational patcher, we will simply allocate everything with "empty" objects,
                // then we will fill those spots as we deserialize
                obj.tiles.reset(new ProvinceId[obj.width * obj.height]);
                // Deserialize all tiles
                ar.copy_to(obj.tiles.get(), obj.width * obj.height * sizeof(ProvinceId));
            }
        }
    }
};
 
extern World g_world;