NDT/EtrediaEmpires
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enterprise salary and API

Browse Source 
- 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
This commit is contained in:
legatt 2025-08-06 17:52:37 +03:00
parent bbf45e832c
commit ff6c146153
22 changed files with 318 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ECSAPI/ECS/include/ee_ecs/api.hpp
View File

@ -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);
}

15
ECSAPI/ECS/include/ee_ecs/data.hpp
View File

@ -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;
};
}

4
ECSAPI/ECS/include/ee_ecs/world.hpp
View File

@ -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,

28
ECSAPI/ECS/src/api.cpp
View File

@ -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;
}

6
ECSAPI/ECS/src/world.cpp
View File

@ -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,

2
ECSAPI/ECS/test/test_conf.hpp
View File

@ -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);

4
ECSAPI/ECS/test/world.cpp
View File

@ -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 = {

2
ECSAPI/Economy/CMakeLists.txt
View File

@ -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/")

6
ECSAPI/Economy/include/ee_economy/components/deliverer.hpp
View File

@ -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

39
ECSAPI/Economy/include/ee_economy/components/enterprise.hpp
View File

@ -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;
update_efficiency();
}
void multiply_base_efficiency(double factor)
{
this->base_efficiency *= factor;
update_efficiency();
}
void multiply_factor_efficiency(double factor)
{
this->factor_efficiency *= factor;
this->factor_efficiency = value;
update_efficiency();
}
};

2
ECSAPI/Economy/include/ee_economy/components/miner.hpp
View File

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

3
ECSAPI/Economy/include/ee_economy/components/state.hpp
View File

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

12
ECSAPI/Economy/include/ee_economy/defines.hpp
View File

@ -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,

4
ECSAPI/Economy/include/ee_economy/systems.hpp
View File

@ -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);

35
ECSAPI/Economy/src/systems/delivering.cpp
View File

@ -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)
deliver_value = contract.value;
if (contract.amount < enterprise.efficiency)
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;
});
}
}

20
ECSAPI/Economy/src/systems/enterprise_routine.cpp Normal file
View File

@ -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);
}
}
}

2
ECSAPI/Economy/src/systems/mining.cpp
View File

@ -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;

2
ECSAPI/Economy/test/CMakeLists.txt
View File

@ -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

120
ECSAPI/Economy/test/systems/delivering.cpp
View File

@ -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_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
deliverer_enterprise.set_base_efficiency(1.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_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
deliverer_enterprise.set_base_efficiency(1.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_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
deliverer_enterprise.set_base_efficiency(1.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_deliverer.contracts.push_back({.from = miner, .to = storage, .value = 10.0});
deliverer_enterprise.set_base_efficiency(15.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);
}

29
ECSAPI/Economy/test/systems/enterprise_routine.cpp Normal file
View File

@ -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);
}

31
ECSAPI/Economy/test/systems/mining.cpp
View File

@ -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);
}