Enterprise salary and API

- Enterprises have action type, money, salary and bankruption status
- Enterprise add and multiply functions replaced with setters
- Delivery contracts have cost, distance and sponsor reference. Value renamed to amount
- Integer values use static sizes types
- Action CONTAIN renamed to STORE
- Enterprises skip their action if is bankrupt
- Delivering transfers money from sponsor to deliverer due contract
- Enterprise routine system processes salaries and bankruptcy
- ee_ecs data structures renamed with snake_case
- Get enterprises info request

ECSAPI/ECS/include/ee_ecs/api.hpp

@@ -1,11 +1,14 @@
 #pragma once
+#include <vector>
 #include "data.hpp"
 
 namespace ee_ecs
 {
 
-	void init(InitConfiguration config);
+	void init(init_configuration config);
 	void start();
-	void stop();
 
+	template<typename  T>
+		const std::vector<enterprise_info> get_all_enterprises();
+	//const enterprise_info get_enterprise(uint32_t id);
 }

ECSAPI/ECS/include/ee_ecs/data.hpp

@@ -1,13 +1,24 @@
 #pragma once
 #include <unordered_map>
 #include <ee_economy/economy.hpp>
+#include <variant>
 
 namespace ee_ecs
 {
 
-    struct InitConfiguration
+    struct init_configuration
 	{
-		std::unordered_map<short, ee_economy::container> states;
+		std::unordered_map<int16_t, ee_economy::container> states;
+	};
+
+	struct enterprise_info
+	{
+		const ee_economy::enterprise* info = nullptr;
+		const ee_economy::container* storage = nullptr;
+		std::variant<
+			const ee_economy::miner*,
+			const ee_economy::deliverer*
+		> special_info;
 	};
 
 }

ECSAPI/ECS/include/ee_ecs/world.hpp

@@ -12,7 +12,7 @@ namespace ee_ecs
 
 	private:
 		entt::registry registry;
-		std::unordered_map<short, entt::entity> states_table;
+		std::unordered_map<int16_t, entt::entity> states_table;
 
 		void update_enterprises();
 
@@ -20,7 +20,7 @@ namespace ee_ecs
 		// Run every registered system
 		void update();
 
-		entt::entity register_state(const short id, const ee_economy::container &resources);
+		entt::entity register_state(const int16_t id, const ee_economy::container &resources);
 		
 		entt::entity spawn_enterprise(
 			const bool is_building,

ECSAPI/ECS/src/api.cpp

@@ -4,7 +4,7 @@
 
 static ee_ecs::world world_instance;
 
-void ee_ecs::init(ee_ecs::InitConfiguration config)
+void ee_ecs::init(ee_ecs::init_configuration config)
 {
 	for (auto& [id, container]: config.states)
     {
@@ -14,11 +14,31 @@ void ee_ecs::init(ee_ecs::InitConfiguration config)
 
 void ee_ecs::start()
 {
-	
+	while (true) {}
 }
 
-void ee_ecs::stop()
+template<typename T>
+    const std::vector<ee_ecs::enterprise_info> ee_ecs::get_all_enterprises()
 {
+    std::vector<enterprise_info> result;
+    //TODO: REPLACE VIEWS WITH GROUPS!
+    auto enterprises = world_instance.get_registry().group<>(entt::get<
+        ee_economy::enterprise,
+        ee_economy::container,
+        T
+    >);
+    result.reserve(enterprises.size_hint()); 
 
+    for (auto [entity, enterprise, container, action]: enterprises.each())
+    {
+        enterprise_info eninfo;
+        eninfo.info = &enterprise;
+        
+        eninfo.storage = &container;
+        eninfo.special_info = &action;
+
+        result.push_back(eninfo);
+    }
+
+    return result;
 }
-

ECSAPI/ECS/src/world.cpp

@@ -4,7 +4,10 @@
 
 void ee_ecs::world::update_enterprises()
 {
+	ee_economy::enterprise_routine(this->registry);
+
 	ee_economy::mining(this->registry);
+	ee_economy::delivering(this->registry);
 }
 
 void ee_ecs::world::update()
@@ -12,7 +15,7 @@ void ee_ecs::world::update()
 	this->update_enterprises();
 }
 
-entt::entity ee_ecs::world::register_state(const short id, const ee_economy::container &resources)
+entt::entity ee_ecs::world::register_state(const int16_t id, const ee_economy::container &resources)
 {
 	if (this->states_table.contains(id))
 		throw std::invalid_argument("State with this Id is already registered");
@@ -45,6 +48,7 @@ entt::entity ee_ecs::world::spawn_enterprise(
 		entity,
 		is_building,
 		state,
+		action,
 
 		defaults.base_efficiency * defaults.factor_efficiency,
 

ECSAPI/ECS/test/test_conf.hpp

@@ -9,7 +9,7 @@ struct WorldBenchmark : testing::Test
 
     void SetUp()
     {
-        for (short i = 0; i < 1000; i++)
+        for (int16_t i = 0; i < 1000; i++)
         {
             ee_economy::container resources = {.capacity = 100.0};
             resources.add(ee_economy::RESOURCE_TYPE::COAL, 100.0);

ECSAPI/ECS/test/world.cpp

@@ -34,7 +34,7 @@ TEST(WorldTest, SpawnMiner)
     ee_ecs::world world;
 
     entt::entity state = world.get_registry().create();
-    world.get_registry().emplace<ee_economy::state>(state, (short)0);
+    world.get_registry().emplace<ee_economy::state>(state, (int16_t)0);
     world.get_registry().emplace<ee_economy::container>(state, 100.0);
 
     ee_economy::enterprise_defaults defaults = {
@@ -59,7 +59,7 @@ TEST(WorldTest, SpawnDeliverer)
     ee_ecs::world world;
 
     entt::entity state = world.get_registry().create();
-    world.get_registry().emplace<ee_economy::state>(state, (short)0);
+    world.get_registry().emplace<ee_economy::state>(state, (int16_t)0);
     world.get_registry().emplace<ee_economy::container>(state, 100.0);
 
     ee_economy::enterprise_defaults defaults = {

ECSAPI/Economy/CMakeLists.txt

@@ -7,7 +7,7 @@ set(HEADERS_COMPONENTS "container.hpp" "enterprise.hpp" "state.hpp" "tags.hpp"
   "miner.hpp" "producer.hpp" "deliverer.hpp")
 
 set(SOURCES "Economy.cpp")
-set(SOURCES_SYSTEMS "mining.cpp" "delivering.cpp")
+set(SOURCES_SYSTEMS "enterprise_routine.cpp" "mining.cpp" "delivering.cpp")
 
 list(TRANSFORM HEADERS PREPEND "include/ee_economy/")
 list(TRANSFORM HEADERS_COMPONENTS PREPEND "include/ee_economy/components/")

ECSAPI/Economy/include/ee_economy/components/deliverer.hpp

@@ -8,7 +8,11 @@ namespace ee_economy
     {
         entt::entity from;
         entt::entity to;
-        double value = 0.0;
+        entt::entity sponsor;
+
+        double amount = 0.0;
+        double cost = 0.0;
+        double distance = 1.0;
     };
 
     struct deliverer

ECSAPI/Economy/include/ee_economy/components/enterprise.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <ee_economy/economy.hpp>
 #include <entt/entt.hpp>
 #include <vector>
 
@@ -8,7 +9,13 @@ namespace ee_economy
 	{
 		bool is_building = false;
 		entt::entity state;
+		ACTION_TYPE action = ACTION_TYPE::STORE;
 
+		/*
+		* Mining - Amount of mined resource
+		* Delivering - Amount of resource that can be delivered by one truck
+		* Production - 
+		*/
 		double efficiency = 0.;
 		double base_efficiency = 0.;
 		double factor_efficiency = 1.;
@@ -16,32 +23,32 @@ namespace ee_economy
 		std::vector<entt::entity> links_from;
 		std::vector<entt::entity> links_to;
 
+		uint16_t staff_size = 1;
+		
+		// This can be splitted in percents between bank enterprises in future
+		double total_money = 0;
+		double salary = 0;
+		bool is_bankrupt = false;
+
+		void set_money(double value)
+		{
+			total_money = value;
+		}
+
 		inline void update_efficiency()
 		{
 			this->efficiency = this->base_efficiency * this->factor_efficiency;
 		}
 
-		void add_base_efficiency(double delta)
+		void set_base_efficiency(double value)
 		{
-			this->base_efficiency += delta;
+			this->base_efficiency = value;
 			update_efficiency();
 		}
 
-		void add_factor_efficiency(double delta)
+		void set_factor_efficiency(double value)
 		{
-			this->factor_efficiency += delta;
+			this->factor_efficiency = value;
-			update_efficiency();
-		}
-
-		void multiply_base_efficiency(double factor)
-		{
-			this->base_efficiency *= factor;
-			update_efficiency();
-		}
-
-		void multiply_factor_efficiency(double factor)
-		{
-			this->factor_efficiency *= factor;
 			update_efficiency();
 		}
 	};

ECSAPI/Economy/include/ee_economy/components/miner.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "../defines.hpp"
+#include <ee_economy/economy.hpp>
 #include <entt/entt.hpp>
 
 namespace ee_economy

ECSAPI/Economy/include/ee_economy/components/state.hpp

@@ -1,8 +1,9 @@
 #pragma once
+#include <cstdint>
 
 namespace ee_economy
 {
     struct state {
-        short external_id = -1;
+        int16_t external_id = -1;
     };
 }

ECSAPI/Economy/include/ee_economy/defines.hpp

@@ -1,28 +1,32 @@
 #pragma once
 
+#include <cstdint>
+
 namespace ee_economy
 {
 	const double TOLERANCE = 0.001;
 
-	enum struct ACTION_TYPE : unsigned char
+	const double BASE_FUEL_PER_KM = 1.0;
+
+	enum struct ACTION_TYPE : uint8_t
 	{
 		MINING,
 		PRODUCTION,
 		DELIVERY,
-		CONTAIN,
+		STORE,
 		DESTRUCTION,
 		BUILD,
 		TRADE
 	};
 
-	enum struct CONTAINABLE_TYPE : unsigned char
+	enum struct CONTAINABLE_TYPE : uint8_t
 	{
 		RESOURCE,
 		GOODS,
 		SERVICE
 	};
 
-	enum struct RESOURCE_TYPE : unsigned char
+	enum struct RESOURCE_TYPE : uint8_t
 	{
 		NONE,
 

ECSAPI/Economy/include/ee_economy/systems.hpp

@@ -3,10 +3,12 @@
 
 namespace ee_economy
 {
+	void enterprise_routine(entt::registry& registry);
+
 	void mining(entt::registry& registry);
 	// void producing(entt::registry& registry);
 	void delivering(entt::registry& registry);
-	// void storaging(entt::registry& registry); ?
+	// void storaging(entt::registry& registry); // consume money for storage time
 	// void destructing(entt::registry& registry);
 	// void building(entt::registry& registry);
 	// void trading(entt::registry& registry);

ECSAPI/Economy/src/systems/delivering.cpp

@@ -2,32 +2,55 @@
 
 void ee_economy::delivering(entt::registry &registry)
 {
-    auto deliverers = registry.view<enterprise, deliverer>();
+    auto deliverers = registry.view<enterprise, deliverer, container>();
 
-    for (auto [entity, enterprise, deliverer]: deliverers.each())
+    for (auto [entity, enterprise, deliverer, storage]: deliverers.each())
     {
+        if (enterprise.is_bankrupt) continue;
+
         for (deliver_contract &contract: deliverer.contracts)
         {
+            double paid_amount = contract.amount;
+            
+            if (contract.cost > 0)
+            {
+                ee_economy::enterprise &sponsor = registry.get<ee_economy::enterprise>(contract.sponsor);
+                
+                double cost_per_one = contract.cost / contract.amount;
+                double payment = contract.cost;
+
+                if (payment > sponsor.total_money)
+                {
+                    payment = (int)(sponsor.total_money / cost_per_one) * cost_per_one;
+                    paid_amount = payment / cost_per_one;
+                }
+                sponsor.set_money(sponsor.total_money - payment);
+                enterprise.set_money(enterprise.total_money + payment);
+                contract.cost -= payment;
+            }
+
             container &from_storage = registry.get<container>(contract.from);
             container &to_storage = registry.get<container>(contract.to);
 
             double deliver_value = enterprise.efficiency;
-            if (contract.value < enterprise.efficiency)
+            if (contract.amount < enterprise.efficiency)
-                deliver_value = contract.value;
+                deliver_value = contract.amount;
             if (to_storage.total + deliver_value > to_storage.capacity)
                 deliver_value = to_storage.capacity - to_storage.total;
             if (deliver_value > from_storage.content[deliverer.resource])
                 deliver_value = from_storage.content[deliverer.resource];
+            if (deliver_value > paid_amount)
+                deliver_value = paid_amount;
             if (deliver_value < 0.0)
                 deliver_value = 0.0;
 
             to_storage.add(deliverer.resource, deliver_value);
             from_storage.add(deliverer.resource, -deliver_value);
-            contract.value -= deliver_value;
+            contract.amount -= deliver_value;
         }
 
         std::erase_if(deliverer.contracts, [](const deliver_contract &contract) {
-            return contract.value <= 0.0;
+            return contract.amount <= 0.0;
         });
     }
 }

ECSAPI/Economy/src/systems/enterprise_routine.cpp

@@ -0,0 +1,20 @@
+#include <ee_economy/economy.hpp>
+
+void ee_economy::enterprise_routine(entt::registry &registry)
+{
+    auto enterprises = registry.view<enterprise>();
+
+    for (auto [entity, enterprise]: enterprises.each())
+    {
+        double salary_debt = enterprise.salary * enterprise.staff_size;
+        if (enterprise.total_money < salary_debt)
+        {
+            enterprise.is_bankrupt = true;
+            enterprise.set_money(0.0);
+        }
+        else
+        {
+            enterprise.set_money(enterprise.total_money - salary_debt);
+        }
+    }
+}

ECSAPI/Economy/src/systems/mining.cpp

@@ -6,6 +6,8 @@ void ee_economy::mining(entt::registry &registry)
 
 	for (auto [entity, enterprise, miner, local_storage]: miners.each())
 	{
+		if (enterprise.is_bankrupt) continue;
+
 		container& state = registry.get<container>(enterprise.state);
 
 		double mined_value = enterprise.efficiency;

ECSAPI/Economy/test/CMakeLists.txt

@@ -1,7 +1,7 @@
 # List sources
 
 set(SOURCES "test_conf.hpp" "main.cpp"
-    "systems/mining.cpp" "systems/delivering.cpp")
+    "systems/enterprise_routine.cpp" "systems/mining.cpp" "systems/delivering.cpp")
 
 # Find dependencies
 

ECSAPI/Economy/test/systems/delivering.cpp

@@ -10,8 +10,8 @@ TEST_F(SystemsTest, DeliverySingleNormal)
     ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
 
     deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
-    deliverer_enterprise.add_base_efficiency(1.0);
+    deliverer_enterprise.set_base_efficiency(1.0);
-    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 10.0});
 
     ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
     ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
@@ -27,6 +27,7 @@ TEST_F(SystemsTest, DeliverySingleNormal)
     ASSERT_DOUBLE_EQ(from_container.content[ee_economy::RESOURCE_TYPE::COAL], 14.0);
     ASSERT_DOUBLE_EQ(to_container.total, 1.0);
     ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 1.0);
+    ASSERT_EQ(deliverer_deliverer.contracts.size(), 1);
 }
 
 TEST_F(SystemsTest, DeliverySingleEmpty)
@@ -37,8 +38,8 @@ TEST_F(SystemsTest, DeliverySingleEmpty)
     ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
 
     deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
-    deliverer_enterprise.add_base_efficiency(1.0);
+    deliverer_enterprise.set_base_efficiency(1.0);
-    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 10.0});
 
     ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
     ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
@@ -52,6 +53,7 @@ TEST_F(SystemsTest, DeliverySingleEmpty)
     ASSERT_DOUBLE_EQ(from_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.0);
     ASSERT_DOUBLE_EQ(to_container.total, 0.0);
     ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.0);
+    ASSERT_EQ(deliverer_deliverer.contracts.size(), 1);
 }
 
 TEST_F(SystemsTest, DeliverySinglePoor)
@@ -62,8 +64,8 @@ TEST_F(SystemsTest, DeliverySinglePoor)
     ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
 
     deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
-    deliverer_enterprise.add_base_efficiency(1.0);
+    deliverer_enterprise.set_base_efficiency(1.0);
-    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 10.0});
 
     ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
     ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
@@ -79,6 +81,7 @@ TEST_F(SystemsTest, DeliverySinglePoor)
     ASSERT_DOUBLE_EQ(from_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.0);
     ASSERT_DOUBLE_EQ(to_container.total, 0.5);
     ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.5);
+    ASSERT_EQ(deliverer_deliverer.contracts.size(), 1);
 }
 
 TEST_F(SystemsTest, DeliverySingleFinishContract)
@@ -89,8 +92,8 @@ TEST_F(SystemsTest, DeliverySingleFinishContract)
     ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
 
     deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
-    deliverer_enterprise.add_base_efficiency(16.0);
+    deliverer_enterprise.set_base_efficiency(15.0);
-    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 10.0});
 
     ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
     ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
@@ -108,3 +111,104 @@ TEST_F(SystemsTest, DeliverySingleFinishContract)
     ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 10.0);
     ASSERT_EQ(deliverer_deliverer.contracts.size(), 0);
 }
+
+TEST_F(SystemsTest, DeliveryMultipleFinishPoorCycle)
+{
+    // [Miner -> Storage | Storage -> Miner] by Deliverer
+
+    ee_economy::enterprise &deliverer_enterprise = registry.get<ee_economy::enterprise>(deliverer);
+    ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
+
+    deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
+    deliverer_enterprise.set_base_efficiency(16.0);
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 20.0});
+    deliverer_deliverer.contracts.push_back({.from = storage, .to = miner, .amount = 5.0});
+
+    ee_economy::container &miner_container = registry.get<ee_economy::container>(miner);
+    ee_economy::container &storage_container = registry.get<ee_economy::container>(storage);
+    
+    miner_container.capacity = 15.0;
+    miner_container.add(ee_economy::RESOURCE_TYPE::COAL, 15.0);
+
+    storage_container.capacity = 15.0;
+
+    ee_economy::delivering(registry);
+
+    ASSERT_DOUBLE_EQ(miner_container.total, 5.0);
+    ASSERT_DOUBLE_EQ(miner_container.content[ee_economy::RESOURCE_TYPE::COAL], 5.0);
+    ASSERT_DOUBLE_EQ(storage_container.total, 10.0);
+    ASSERT_DOUBLE_EQ(storage_container.content[ee_economy::RESOURCE_TYPE::COAL], 10.0);
+    ASSERT_EQ(deliverer_deliverer.contracts.size(), 1);
+    ASSERT_EQ(deliverer_deliverer.contracts[0].from, miner);
+}
+
+TEST_F(SystemsTest, DeliveryPayment)
+{
+    // [Miner -> Storage] by Deliverer for $Miner
+    // [Miner -> Storage] by Deliverer
+
+    ee_economy::enterprise &deliverer_enterprise = registry.get<ee_economy::enterprise>(deliverer);
+    ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
+
+    deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
+    deliverer_enterprise.set_base_efficiency(10.0);
+    deliverer_deliverer.contracts.push_back({
+        .from = miner,
+        .to = storage,
+        .sponsor = miner,
+        .amount = 10.0,
+        .cost = 100.0
+    });
+
+    ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
+    ee_economy::enterprise &from_enterprise = registry.get<ee_economy::enterprise>(miner);
+    ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
+    
+    from_container.capacity = 10.0;
+    from_container.add(ee_economy::RESOURCE_TYPE::COAL, 10.0);
+    from_enterprise.set_money(95.0);
+
+    to_container.capacity = 10.0;
+
+    ee_economy::delivering(registry);
+
+    ASSERT_DOUBLE_EQ(from_container.total, 1.0);
+    ASSERT_DOUBLE_EQ(from_container.content[ee_economy::RESOURCE_TYPE::COAL], 1.0);
+    ASSERT_DOUBLE_EQ(to_container.total, 9.0);
+    ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 9.0);
+    ASSERT_DOUBLE_EQ(from_enterprise.total_money, 5.0);
+    ASSERT_DOUBLE_EQ(deliverer_enterprise.total_money, 90.0);
+
+    ee_economy::deliver_contract contract = deliverer_deliverer.contracts[0];
+    ASSERT_DOUBLE_EQ(contract.cost, 10.0);
+    ASSERT_DOUBLE_EQ(contract.amount, 1.0);
+}
+
+TEST_F(SystemsTest, DeliveryBankrupt)
+{
+    // [Miner -> Storage] by Deliverer
+
+    ee_economy::enterprise &deliverer_enterprise = registry.get<ee_economy::enterprise>(deliverer);
+    ee_economy::deliverer &deliverer_deliverer = registry.get<ee_economy::deliverer>(deliverer);
+
+    deliverer_deliverer.resource = ee_economy::RESOURCE_TYPE::COAL;
+    deliverer_deliverer.contracts.push_back({.from = miner, .to = storage, .amount = 10.0});
+    deliverer_enterprise.set_base_efficiency(1.0);
+    deliverer_enterprise.is_bankrupt = true;
+
+    ee_economy::container &from_container = registry.get<ee_economy::container>(miner);
+    ee_economy::container &to_container = registry.get<ee_economy::container>(storage);
+    
+    from_container.capacity = 15.0;
+    from_container.add(ee_economy::RESOURCE_TYPE::COAL, 15.0);
+
+    to_container.capacity = 15.0;
+
+    ee_economy::delivering(registry);
+
+    ASSERT_DOUBLE_EQ(from_container.total, 15.0);
+    ASSERT_DOUBLE_EQ(from_container.content[ee_economy::RESOURCE_TYPE::COAL], 15.0);
+    ASSERT_DOUBLE_EQ(to_container.total, 0.0);
+    ASSERT_DOUBLE_EQ(to_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.0);
+    ASSERT_EQ(deliverer_deliverer.contracts.size(), 1);
+}

ECSAPI/Economy/test/systems/enterprise_routine.cpp

@@ -0,0 +1,29 @@
+#include <gtest/gtest.h>
+#include <ee_economy/economy.hpp>
+#include "../test_conf.hpp"
+
+TEST_F(SystemsTest, RoutineNormal)
+{
+    ee_economy::enterprise &miner_enterprise = registry.get<ee_economy::enterprise>(miner);
+    miner_enterprise.set_money(1000000000.0);
+    miner_enterprise.salary = 100000.0;
+    miner_enterprise.staff_size = 10;
+
+    ee_economy::enterprise_routine(registry);
+
+    ASSERT_DOUBLE_EQ(miner_enterprise.total_money, 999000000.0);
+    ASSERT_FALSE(miner_enterprise.is_bankrupt);
+}
+
+TEST_F(SystemsTest, RoutineBankruptcy)
+{
+    ee_economy::enterprise &miner_enterprise = registry.get<ee_economy::enterprise>(miner);
+    miner_enterprise.set_money(1000000.0);
+    miner_enterprise.salary = 100000.0;
+    miner_enterprise.staff_size = 11;
+
+    ee_economy::enterprise_routine(registry);
+
+    ASSERT_DOUBLE_EQ(miner_enterprise.total_money, 0.0);
+    ASSERT_TRUE(miner_enterprise.is_bankrupt);
+}

ECSAPI/Economy/test/systems/mining.cpp

@@ -14,7 +14,7 @@ TEST_F(SystemsTest, MiningNormal)
 
     miner_container.capacity = 5.0;
     miner_miner.resource = ee_economy::RESOURCE_TYPE::COAL;
-    miner_enterprise.add_base_efficiency(0.1);
+    miner_enterprise.set_base_efficiency(0.1);
 
     ee_economy::mining(registry);
 
@@ -35,7 +35,7 @@ TEST_F(SystemsTest, MiningEmptyState)
 
     miner_container.capacity = 5.0;
     miner_miner.resource = ee_economy::RESOURCE_TYPE::COAL;
-    miner_enterprise.add_base_efficiency(0.1);
+    miner_enterprise.set_base_efficiency(0.1);
 
     ee_economy::mining(registry);
 
@@ -57,7 +57,7 @@ TEST_F(SystemsTest, MiningPoorState)
 
     miner_container.capacity = 5.0;
     miner_miner.resource = ee_economy::RESOURCE_TYPE::COAL;
-    miner_enterprise.add_base_efficiency(0.1);
+    miner_enterprise.set_base_efficiency(0.1);
 
     ee_economy::mining(registry);
 
@@ -79,7 +79,7 @@ TEST_F(SystemsTest, MiningReachCap)
 
     miner_container.capacity = 0.05;
     miner_miner.resource = ee_economy::RESOURCE_TYPE::COAL;
-    miner_enterprise.add_base_efficiency(0.1);
+    miner_enterprise.set_base_efficiency(0.1);
 
     ee_economy::mining(registry);
 
@@ -88,3 +88,26 @@ TEST_F(SystemsTest, MiningReachCap)
     ASSERT_DOUBLE_EQ(miner_container.total, 0.05);
     ASSERT_DOUBLE_EQ(miner_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.05);
 }
+
+TEST_F(SystemsTest, MiningBankrupt)
+{
+    ee_economy::container &state_container = registry.get<ee_economy::container>(state);
+    ee_economy::container &miner_container = registry.get<ee_economy::container>(miner);
+    ee_economy::enterprise &miner_enterprise = registry.get<ee_economy::enterprise>(miner);
+    ee_economy::miner &miner_miner = registry.get<ee_economy::miner>(miner);
+    
+    state_container.capacity = 15.0;
+    state_container.add(ee_economy::RESOURCE_TYPE::COAL, 10.0);
+
+    miner_container.capacity = 5.0;
+    miner_miner.resource = ee_economy::RESOURCE_TYPE::COAL;
+    miner_enterprise.set_base_efficiency(0.1);
+    miner_enterprise.is_bankrupt = true;
+
+    ee_economy::mining(registry);
+
+    ASSERT_DOUBLE_EQ(state_container.total, 10.0);
+    ASSERT_DOUBLE_EQ(state_container.content[ee_economy::RESOURCE_TYPE::COAL], 10.0);
+    ASSERT_DOUBLE_EQ(miner_container.total, 0.0);
+    ASSERT_DOUBLE_EQ(miner_container.content[ee_economy::RESOURCE_TYPE::COAL], 0.0);
+}