Implement artisanal production

src/openvic-simulation/economy/production/ArtisanalProducer.cpp

@@ -1,13 +1,65 @@
 #include "ArtisanalProducer.hpp"
 
+#include "openvic-simulation/economy/GoodDefinition.hpp"
+#include "openvic-simulation/economy/trading/BuyResult.hpp"
+#include "openvic-simulation/economy/trading/SellResult.hpp"
+
 using namespace OpenVic;
 
 ArtisanalProducer::ArtisanalProducer(
+	MarketInstance& new_market_instance,
+	ModifierEffectCache const& new_modifier_effect_cache,
+	Pop& new_pop,
+	Pop::pop_size_t new_previous_pop_size,
+	fixed_point_t new_inputs_bought_scalar,
 	ProductionType const& new_production_type,
-	GoodDefinition::good_definition_map_t&& new_stockpile,
-	fixed_point_t new_current_production,
-	GoodDefinition::good_definition_map_t&& new_current_needs
-) : production_type { new_production_type },
-	stockpile { std::move(new_stockpile) },
-	current_production { new_current_production },
-	current_needs { std::move(new_current_needs) } {}
+	fixed_point_t new_current_production
+) : market_instance { new_market_instance },
+	modifier_effect_cache { new_modifier_effect_cache },
+	pop { new_pop },
+	previous_pop_size { new_previous_pop_size },
+	inputs_bought_scalar { new_inputs_bought_scalar },
+	production_type { new_production_type },
+	current_production { new_current_production }
+	{}
+
+void ArtisanalProducer::artisan_tick() {
+	current_production = production_type.get_base_output_quantity()
+		* inputs_bought_scalar
+		* previous_pop_size / production_type.get_base_workforce_size();
+
+	GoodDefinition const& output_good = production_type.get_output_good();
+	if (current_production > 0) {
+		market_instance.place_market_sell_order({
+			output_good,
+			current_production,
+			[this](const SellResult sell_result) -> void {
+				//TODO add artisanal income to pop (part of https://github.com/OpenVicProject/OpenVic-Simulation/issues/225 )
+			}
+		});
+	}
+
+	const fixed_point_t total_cash_to_spend = pop.get_cash();
+	if (production_type.get_input_goods().empty()) {
+		inputs_bought_scalar = fixed_point_t::_1();
+	}
+	else if (total_cash_to_spend > 0) {
+		int input_goods_count = static_cast<int>(production_type.get_input_goods().size());
+		for (auto const& [input_good_ptr, base_desired_quantity] : production_type.get_input_goods()) {
+			const fixed_point_t money_to_spend = total_cash_to_spend / input_goods_count;
+			const fixed_point_t desired_quantity = base_desired_quantity * pop.get_size() / production_type.get_base_workforce_size();
+			//TODO pop cash -= money_to_spend
+			market_instance.place_buy_up_to_order({
+				*input_good_ptr,
+				desired_quantity,
+				money_to_spend,
+				[this, desired_quantity](const BuyResult buy_result) -> void {
+					//TODO pop cash += buy_result.get_money_left()
+					inputs_bought_scalar = std::min(inputs_bought_scalar, buy_result.get_quantity_bought() / desired_quantity);
+				}
+			});
+		}
+	}
+
+	previous_pop_size = pop.get_size();
+}

src/openvic-simulation/economy/production/ArtisanalProducer.hpp

@@ -1,22 +1,33 @@
 #pragma once
 
-#include "openvic-simulation/economy/GoodDefinition.hpp"
 #include "openvic-simulation/economy/production/ProductionType.hpp"
+#include "openvic-simulation/economy/trading/MarketInstance.hpp"
+#include "openvic-simulation/modifier/ModifierEffectCache.hpp"
+#include "openvic-simulation/pop/Pop.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
 	struct ArtisanalProducer {
 	private:
+		MarketInstance& market_instance;
+		ModifierEffectCache const& modifier_effect_cache;
+		Pop& pop;
+		Pop::pop_size_t previous_pop_size;
+		fixed_point_t inputs_bought_scalar;
 		ProductionType const& PROPERTY(production_type);
-		GoodDefinition::good_definition_map_t PROPERTY(stockpile);
 		fixed_point_t PROPERTY(current_production);
-		GoodDefinition::good_definition_map_t PROPERTY(current_needs);
 
 	public:
 		ArtisanalProducer(
-			ProductionType const& new_production_type, GoodDefinition::good_definition_map_t&& new_stockpile,
-			fixed_point_t new_current_production, GoodDefinition::good_definition_map_t&& new_current_needs
+			MarketInstance& new_market_instance,
+			ModifierEffectCache const& new_modifier_effect_cache,
+			Pop& new_pop,
+			Pop::pop_size_t new_previous_pop_size,
+			fixed_point_t new_inputs_bought_scalar,
+			ProductionType const& new_production_type,
+			fixed_point_t new_current_production
 		);
+		void artisan_tick();
 	};
 }

src/openvic-simulation/economy/trading/BuyResult.cpp

@@ -0,0 +1,11 @@
+#include "BuyResult.hpp"
+
+using namespace OpenVic;
+
+BuyResult::BuyResult(
+    const fixed_point_t new_quantity_bought,
+    const fixed_point_t new_money_left
+) :
+    quantity_bought { new_quantity_bought },
+    money_left { new_money_left }
+    {}

src/openvic-simulation/economy/trading/BuyResult.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+
+namespace OpenVic {
+	struct BuyResult {
+	private:
+		fixed_point_t PROPERTY(quantity_bought);
+		fixed_point_t PROPERTY(money_left);
+	public:
+		BuyResult(
+			const fixed_point_t new_quantity_bought,
+			const fixed_point_t new_money_left
+		);
+	};
+}

src/openvic-simulation/economy/trading/BuyUpToOrder.cpp

@@ -0,0 +1,14 @@
+#include "BuyUpToOrder.hpp"
+
+using namespace OpenVic;
+
+BuyUpToOrder::BuyUpToOrder(
+	GoodDefinition const& new_good,
+	const fixed_point_t new_max_quantity,
+	const fixed_point_t new_money_to_spend,
+	const std::function<void(const BuyResult)> new_after_trade
+) : good { &new_good },
+	max_quantity { new_max_quantity },
+	money_to_spend { new_money_to_spend },
+	after_trade { new_after_trade }
+	{}

src/openvic-simulation/economy/trading/BuyUpToOrder.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "openvic-simulation/economy/GoodDefinition.hpp"
+#include "openvic-simulation/economy/trading/BuyResult.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/utility/Getters.hpp"
+
+namespace OpenVic {
+	struct BuyUpToOrder {
+	private:
+		GoodDefinition const* const PROPERTY(good);
+		const fixed_point_t PROPERTY(max_quantity);
+		const fixed_point_t PROPERTY(money_to_spend);
+		const std::function<void(const BuyResult)> PROPERTY(after_trade);
+
+	public:
+		BuyUpToOrder(
+			GoodDefinition const& new_good,
+			const fixed_point_t new_max_quantity,
+			const fixed_point_t new_money_to_spend,
+			const std::function<void(const BuyResult)> new_after_trade
+		);
+	};
+}

src/openvic-simulation/economy/trading/MarketInstance.cpp

@@ -9,6 +9,16 @@ bool MarketInstance::setup(GoodInstanceManager& new_good_instance_manager) {
 	return true;
 }
 
+void MarketInstance::place_buy_up_to_order(const BuyUpToOrder buy_up_to_order) {
+	GoodDefinition const* const good = buy_up_to_order.get_good();
+	GoodInstance* const good_instance = good_instance_manager->get_good_instance_by_identifier(good->get_identifier());
+	good_instance->add_buy_up_to_order(
+		buy_up_to_order.get_max_quantity(),
+		buy_up_to_order.get_money_to_spend(),
+		buy_up_to_order.get_after_trade()
+	);
+}
+
 void MarketInstance::place_market_sell_order(const MarketSellOrder market_sell_order) {
 	GoodDefinition const* const good = market_sell_order.get_good();
 	GoodInstance* const good_instance = good_instance_manager->get_good_instance_by_identifier(good->get_identifier());

src/openvic-simulation/economy/trading/MarketInstance.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openvic-simulation/economy/GoodInstance.hpp"
+#include "openvic-simulation/economy/trading/BuyUpToOrder.hpp"
 #include "openvic-simulation/economy/trading/MarketSellOrder.hpp"
 
 namespace OpenVic {
@@ -9,6 +10,7 @@ namespace OpenVic {
 		GoodInstanceManager* PROPERTY(good_instance_manager);
 	public:
 		bool setup(GoodInstanceManager& new_good_instance_manager);
+		void place_buy_up_to_order(const BuyUpToOrder buy_up_to_order);
 		void place_market_sell_order(const MarketSellOrder market_sell_order);
 		void execute_orders();
 	};