feat: implemented ProductionType, implemented (broken) loading for it

2 files changed, 334 insertions, 0 deletions

diff --git a/src/openvic-simulation/economy/ProductionType.cpp b/src/openvic-simulation/economy/ProductionType.cpp
new file mode 100644
index 0000000..c5e131d
--- /dev/null
+++ b/src/openvic-simulation/economy/ProductionType.cpp
@@ -0,0 +1,223 @@
+#include "ProductionType.hpp"
+
+using namespace OpenVic;
+using namespace OpenVic::NodeTools;
+
+EmployedPop::EmployedPop(const PopType* pop_type, effect_t effect, fixed_point_t effect_multiplier, fixed_point_t amount)
+	: pop_type { pop_type }, effect { effect }, effect_multiplier { effect_multiplier }, amount { amount } {}
+
+const PopType* EmployedPop::get_pop_type() const {
+	return pop_type;
+}
+
+EmployedPop::effect_t EmployedPop::get_effect() const {
+	return effect;
+}
+
+fixed_point_t EmployedPop::get_effect_multiplier() const {
+	return effect_multiplier;
+}
+
+fixed_point_t EmployedPop::get_amount() const {
+	return amount;
+}
+
+ProductionType::ProductionType(ARGS(type_t, const Good*)) : HasIdentifier { identifier }, owner { owner },
+	employees { employees }, type { type }, workforce { workforce }, input_goods { input_goods }, output_goods { output_goods },
+	value { value }, bonuses { bonuses }, efficiency { efficiency }, coastal { coastal }, farm { farm }, mine { mine } {}
+
+EmployedPop const& ProductionType::get_owner() const {
+	return owner;
+}
+
+std::vector<EmployedPop> const& ProductionType::get_employees() const {
+	return employees;
+}
+
+ProductionType::type_t ProductionType::get_type() const {
+	return type;
+}
+
+uint32_t ProductionType::get_workforce() const {
+	return workforce;
+}
+
+std::map<const Good*, fixed_point_t> const& ProductionType::get_input_goods() {
+	return input_goods;
+}
+
+const Good* ProductionType::get_output_goods() const {
+	return output_goods;
+}
+
+fixed_point_t ProductionType::get_value() const {
+	return value;
+}
+
+std::vector<Bonus> const& ProductionType::get_bonuses() {
+	return bonuses;
+}
+
+std::map<const Good*, fixed_point_t> const& ProductionType::get_efficiency() {
+	return efficiency;
+}
+
+bool ProductionType::is_coastal() const {
+	return coastal;
+}
+
+bool ProductionType::is_farm() const {
+	return farm;
+}
+
+bool ProductionType::is_mine() const {
+	return mine;
+}
+
+ProductionTypeManager::ProductionTypeManager() : production_types { "production types" } {}
+
+node_callback_t ProductionTypeManager::_expect_employed_pop(GoodManager& good_manager, PopManager& pop_manager,
+	callback_t<EmployedPop> cb) {
+	
+	return [this, &good_manager, &pop_manager, &cb](ast::NodeCPtr node) -> bool {
+		std::string_view pop_type, effect;
+		fixed_point_t effect_multiplier = 1, amount = 1;
+
+		bool res = expect_dictionary_keys(
+			"pop_type", ONE_EXACTLY, expect_identifier(assign_variable_callback(pop_type)),
+			"effect", ONE_EXACTLY, expect_identifier(assign_variable_callback(effect)),
+			"effect_multiplier", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(effect_multiplier)),
+			"amount", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(amount))
+		)(node);
+
+		const PopType* found_pop_type = pop_manager.get_pop_type_by_identifier(pop_type);
+		if (found_pop_type == nullptr) {
+			Logger::error("Found invalid pop type ", pop_type, " while parsing production types!");
+			return false;
+		}
+
+		EmployedPop::effect_t found_effect;
+		if (effect == "input") found_effect = EmployedPop::effect_t::INPUT;
+		else if (effect == "output") found_effect = EmployedPop::effect_t::OUTPUT;
+		else if (effect == "throughput") found_effect = EmployedPop::effect_t::THROUGHPUT;
+		else {
+			Logger::error("Found invalid effect ", effect, " while parsing production types!");
+			return false;
+		}
+
+		return res & cb(EmployedPop { found_pop_type, found_effect, effect_multiplier, amount });
+	};
+}
+
+node_callback_t ProductionTypeManager::_expect_employed_pop_list(GoodManager& good_manager, PopManager& pop_manager,
+	callback_t<std::vector<EmployedPop>> cb) {
+	
+	return [this, &good_manager, &pop_manager, &cb](ast::NodeCPtr node) -> bool {
+		std::vector<EmployedPop> employed_pops;
+		bool res = expect_list([this, &good_manager, &pop_manager, &employed_pops](ast::NodeCPtr node) -> bool {
+			EmployedPop* owner = nullptr;
+			bool res_partial = _expect_employed_pop(good_manager, pop_manager, assign_variable_callback(*owner))(node);
+			if (owner != nullptr)
+				employed_pops.push_back(*owner);
+			return res_partial;
+		})(node);
+		return res & cb(employed_pops);
+	};
+}
+
+bool ProductionTypeManager::add_production_type(ARGS(std::string_view, std::string_view), GoodManager& good_manager) {
+	if (identifier.empty()) {
+		Logger::error("Invalid production type identifier - empty!");
+		return false;
+	}
+
+	ProductionType::type_t type_enum;
+	if (type == "factory") type_enum = ProductionType::type_t::FACTORY;
+	else if (type == "rgo") type_enum = ProductionType::type_t::RGO;
+	else if (type == "artisan") type_enum = ProductionType::type_t::ARTISAN;
+	else {
+		Logger::error("Bad type ", type, " for production type ", identifier, "!");
+		return false;
+	}
+
+	const Good* output = good_manager.get_good_by_identifier(output_goods);
+	if (output == nullptr) {
+		Logger::error("Invalid output for production type ", output_goods, "!");
+		return false;
+	}
+
+	return production_types.add_item({ 
+		identifier, owner, employees, type_enum, workforce, input_goods,
+		output, value, bonuses, efficiency, coastal, farm, mine 
+	});
+}
+
+bool ProductionTypeManager::load_production_types_file(GoodManager& good_manager, PopManager& pop_manager, ast::NodeCPtr root) {
+	size_t expected_types = 0;
+
+	//pass 1: find and store template identifiers
+	std::set<std::string_view> templates;
+	bool ret = expect_dictionary([this, &expected_types, &templates](std::string_view key, ast::NodeCPtr value) -> bool {
+		std::string_view template_id = "";
+		bool ret = expect_dictionary_keys(ALLOW_OTHER_KEYS,
+			"template", ZERO_OR_ONE, expect_identifier(assign_variable_callback(template_id))
+		)(value);
+
+		if (!template_id.empty())
+			templates.emplace(template_id);
+		else expected_types++;
+
+		return ret;
+	})(root);
+
+	//pass 2: create and populate the template map
+	std::map<std::string_view, ast::NodeCPtr> template_map; 
+	expect_dictionary([this, &templates, &template_map](std::string_view key, ast::NodeCPtr value) -> bool {
+		if (templates.contains(key))
+			template_map.emplace(key, value);
+		return true;
+	})(root);
+
+	//pass 3: actually load production types
+	production_types.reserve(production_types.size() + expected_types);
+	ret &= expect_dictionary(
+		[this, &good_manager, &pop_manager, &template_map](std::string_view key, ast::NodeCPtr node) -> bool {
+			EmployedPop* owner;
+			std::vector<EmployedPop> employees;
+			std::string_view type;
+			uint32_t workforce;
+			std::map<const Good*, fixed_point_t> input_goods;
+			std::string_view output_goods;
+			fixed_point_t value;
+			std::vector<Bonus> bonuses;
+			std::map<const Good*, fixed_point_t> efficiency;
+			bool coastal = false; //is_coastal
+			bool farm = false;
+			bool mine = false;
+
+			return expect_dictionary_keys(ALLOW_OTHER_KEYS,
+				"owner", ONE_EXACTLY, _expect_employed_pop(
+					good_manager, pop_manager, move_variable_callback(*owner)),
+				"employees", ONE_EXACTLY, _expect_employed_pop_list(
+					good_manager, pop_manager, move_variable_callback(employees)),
+				"type", ONE_EXACTLY, expect_identifier(assign_variable_callback(type)),
+				"workforce", ONE_EXACTLY, expect_uint(assign_variable_callback(workforce)),
+				"input_goods", ZERO_OR_ONE, good_manager.expect_good_decimal_map(assign_variable_callback(input_goods)),
+				"output_goods_id", ONE_EXACTLY, expect_identifier(assign_variable_callback(output_goods)),
+				"value", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(value)),
+				//"bonus", ONE_OR_MORE, TODO
+				"efficiency", ZERO_OR_ONE, good_manager.expect_good_decimal_map(assign_variable_callback(efficiency)),
+				"is_coastal", ZERO_OR_ONE, expect_bool(assign_variable_callback(coastal)),
+				"farm", ZERO_OR_ONE, expect_bool(assign_variable_callback(farm)),
+				"mine", ZERO_OR_ONE, expect_bool(assign_variable_callback(mine))
+			)(node) & add_production_type(
+				key, *owner, employees, type, workforce, input_goods, output_goods, value, 
+				bonuses, efficiency, coastal, farm, mine, good_manager
+			);
+		}
+	)(root);
+
+	production_types.lock();
+
+	return ret;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/economy/ProductionType.hpp b/src/openvic-simulation/economy/ProductionType.hpp
new file mode 100644
index 0000000..abe70ce
--- /dev/null
+++ b/src/openvic-simulation/economy/ProductionType.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <string_view>
+#include <vector>
+#include <set>
+#include "openvic-simulation/economy/Good.hpp"
+#include "openvic-simulation/pop/Pop.hpp"
+#include "openvic-simulation/types/IdentifierRegistry.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/dataloader/NodeTools.hpp"
+#include "openvic-dataloader/v2script/AbstractSyntaxTree.hpp"
+
+#define ARGS(enum_type, output) std::string_view identifier, EmployedPop owner, std::vector<EmployedPop> employees, enum_type type, \
+								uint32_t workforce, std::map<const Good*, fixed_point_t> input_goods, output output_goods, \
+								fixed_point_t value, std::vector<Bonus> bonuses, std::map<const Good*, fixed_point_t> efficiency, \
+								bool coastal, bool farm, bool mine
+
+namespace OpenVic {
+	struct ProductionTypeManager;
+
+	struct EmployedPop {
+		friend struct ProductionTypeManager;
+
+	private:
+		const PopType* pop_type;
+		const enum struct effect_t {
+			INPUT,
+			OUTPUT,
+			THROUGHPUT
+		} effect;
+		const fixed_point_t effect_multiplier;
+		const fixed_point_t amount;
+
+		EmployedPop(const PopType* pop_type, effect_t effect, fixed_point_t effect_multiplier, fixed_point_t amount);
+	
+	public:
+		const PopType* get_pop_type() const;
+		effect_t get_effect() const;
+		fixed_point_t get_effect_multiplier() const;
+		fixed_point_t get_amount() const;
+	};
+
+	struct Bonus {
+		//TODO: trigger condition(s)
+		const fixed_point_t value;
+	};
+
+	struct ProductionType : HasIdentifier {
+		friend struct ProductionTypeManager;
+
+	private:
+		const EmployedPop owner;
+		const std::vector<EmployedPop> employees;
+		const enum struct type_t {
+			FACTORY,
+			RGO,
+			ARTISAN
+		} type;
+		const uint32_t workforce;
+
+		const std::map<const Good*, fixed_point_t> input_goods; //farms generally lack this
+		const Good* output_goods;
+		const fixed_point_t value;
+		const std::vector<Bonus> bonuses; //some
+
+		const std::map<const Good*, fixed_point_t> efficiency; //some
+		const bool coastal; //is_coastal some(false)
+		
+		const bool farm; //some (false)
+		const bool mine; //some (false)
+
+		ProductionType(ARGS(type_t, const Good*));
+
+	public:
+		ProductionType(ProductionType&&) = default;
+
+		EmployedPop const& get_owner() const;
+		std::vector<EmployedPop> const& get_employees() const;
+		type_t get_type() const;
+		uint32_t get_workforce() const;
+
+		std::map<const Good*, fixed_point_t> const& get_input_goods();
+		const Good* get_output_goods() const;
+		fixed_point_t get_value() const;
+		std::vector<Bonus> const& get_bonuses();
+
+		std::map<const Good*, fixed_point_t> const& get_efficiency();
+		bool is_coastal() const;
+
+		bool is_farm() const;
+		bool is_mine() const;
+	};
+
+	struct ProductionTypeManager {
+	private:
+		IdentifierRegistry<ProductionType> production_types;
+
+		NodeTools::node_callback_t _expect_employed_pop(GoodManager& good_manager, PopManager& pop_manager, 
+			NodeTools::callback_t<EmployedPop> cb);
+		NodeTools::node_callback_t _expect_employed_pop_list(GoodManager& good_manager, PopManager& pop_manager, 
+			NodeTools::callback_t<std::vector<EmployedPop>> cb);
+	
+	public:
+		ProductionTypeManager();
+
+		bool add_production_type(ARGS(std::string_view, std::string_view), GoodManager& good_manager);
+		IDENTIFIER_REGISTRY_ACCESSORS(ProductionType, production_type)
+
+		bool load_production_types_file(GoodManager& good_manager, PopManager& pop_manager, ast::NodeCPtr root);
+	};
+}
\ No newline at end of file