258 lines
9 KiB
C++
258 lines
9 KiB
C++
#include "game/sim/economy.h"
|
|
#include "game/sim/numeric.h"
|
|
|
|
#include "check.h"
|
|
|
|
using namespace sots::sim;
|
|
|
|
static void test_interest() {
|
|
CHECK_EQ(SavingsInterest(1000, true), 10);
|
|
CHECK_EQ(SavingsInterest(199, true), 1); // 1.99 truncates
|
|
CHECK_EQ(SavingsInterest(1000, false), 0); // no systems, no interest
|
|
CHECK_EQ(SavingsInterest(-500, true), 0);
|
|
CHECK_EQ(SavingsInterest(0, true), 0);
|
|
|
|
CHECK_EQ(DebtInterest(-1000), 150);
|
|
CHECK_EQ(DebtInterest(-7), 1); // 1.05 truncates
|
|
CHECK_EQ(DebtInterest(5), 0);
|
|
CHECK_EQ(DebtInterest(0), 0);
|
|
|
|
CHECK_EQ(MaintenanceCost(100, 2.0), 50);
|
|
CHECK_EQ(MaintenanceCost(100, 1.9), 100); // divisor truncates to 1
|
|
CHECK_EQ(MaintenanceCost(100, 0.5), 100); // divisor 0 guarded
|
|
|
|
CHECK_EQ(SaturatingAdd(1900000000, 500000000), 2000000000);
|
|
CHECK_EQ(SaturatingAdd(-1900000000, -500000000), -2000000000);
|
|
CHECK_EQ(SaturatingAdd(5, -7), -2);
|
|
}
|
|
|
|
static void test_research_points() {
|
|
// 50000 / 50 = 1000; x1.15 = 1150; x0.5 = 575; x0.85 = 488.75 -> 488
|
|
CHECK_EQ(ResearchPointsFromMoney(50000, 1, 1, 0, 0, 1, 1, 1), 488);
|
|
// (ResMod + shrm + TRM) = 2 -> 977.5 -> 977
|
|
CHECK_EQ(ResearchPointsFromMoney(50000, 1, 1, 0.5, 0.5, 1, 1, 1), 977);
|
|
// difficulty 0.5 -> 244.375 -> 244
|
|
CHECK_EQ(ResearchPointsFromMoney(50000, 0.5, 1, 0, 0, 1, 1, 1), 244);
|
|
// tech x2, server x0.5, scale x1 -> unchanged 488
|
|
CHECK_EQ(ResearchPointsFromMoney(50000, 1, 1, 0, 0, 2, 0.5, 1), 488);
|
|
CHECK_EQ(ResearchPointsFromMoney(0, 1, 1, 0, 0, 1, 1, 1), 0);
|
|
// 100 money -> 0.9775 -> 0
|
|
CHECK_EQ(ResearchPointsFromMoney(100, 1, 1, 0, 0, 1, 1, 1), 0);
|
|
}
|
|
|
|
static void test_expenses() {
|
|
std::vector<ExpenseSlider> s = {{100, 300, 250}, {50, 60, 100}};
|
|
// minimums 150; extras 150 + 10 = 160; headroom 1000-150 = 850 -> 310
|
|
CHECK_EQ(ExpenseTotal(s, 1000), 310);
|
|
// headroom 200-150 = 50 -> 200
|
|
CHECK_EQ(ExpenseTotal(s, 200), 200);
|
|
CHECK_EQ(ExpenseTotal({}, 1000), 0);
|
|
}
|
|
|
|
static BudgetInputs base_inputs() {
|
|
BudgetInputs in;
|
|
in.savings = 10000;
|
|
in.ownsSystems = true;
|
|
in.systemIncome = {5000, 3000, -200};
|
|
in.tradeIncome = 1000;
|
|
in.maintenance = 2000;
|
|
in.maintenanceDivisor = 1.0;
|
|
in.constructionDemand = 500;
|
|
in.researchRate = 0.5;
|
|
in.hasResearchTarget = true;
|
|
return in;
|
|
}
|
|
|
|
static void test_budget_hand_case() {
|
|
Budget b = ComputeBudget(base_inputs(), false);
|
|
CHECK_EQ(b.savingsInterest, 100);
|
|
CHECK_EQ(b.debtInterest, 0);
|
|
CHECK_EQ(b.systemIncomePositive, 8000);
|
|
CHECK_EQ(b.systemIncomeNegative, 200);
|
|
CHECK_EQ(b.maintenance, 2000);
|
|
CHECK_EQ(b.expenses, 0);
|
|
// 8000 + 1000 + 100 - 200 - 2000 = 6900
|
|
CHECK_EQ(b.available, 6900);
|
|
CHECK_EQ(b.construction, 500);
|
|
// (6900 - 500) x 0.5 = 3200
|
|
CHECK_EQ(b.researchMoney, 3200);
|
|
// 3200/50 = 64; x1.15 = 73.6; x0.5 = 36.8; x0.85 = 31.28 -> 31
|
|
CHECK_EQ(b.researchPoints, 31);
|
|
CHECK_EQ(b.totalResearchPoints, 31);
|
|
CHECK(b.hasResearchAllocation);
|
|
CHECK_EQ(b.researchMoneyKept, 3200);
|
|
CHECK_EQ(b.bonusIncome, 0);
|
|
CHECK_EQ(b.savingsGiven, 0);
|
|
// 6900 - 500 - 3200
|
|
CHECK_EQ(b.net, 3200);
|
|
}
|
|
|
|
static void test_budget_projected() {
|
|
Budget b = ComputeBudget(base_inputs(), true);
|
|
CHECK_EQ(b.researchMoney, 0);
|
|
CHECK_EQ(b.researchPoints, 0);
|
|
CHECK_EQ(b.net, 6400);
|
|
}
|
|
|
|
static void test_budget_debt() {
|
|
BudgetInputs in = base_inputs();
|
|
in.savings = -1000;
|
|
Budget b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.savingsInterest, 0);
|
|
CHECK_EQ(b.debtInterest, 150);
|
|
// 8000 + 1000 - 200 - 2000 - 150 = 6650
|
|
CHECK_EQ(b.available, 6650);
|
|
CHECK_EQ(b.construction, 500);
|
|
// (6650 - 500) x 0.5 = 3075
|
|
CHECK_EQ(b.researchMoney, 3075);
|
|
CHECK_EQ(b.net, 6650 - 500 - 3075);
|
|
}
|
|
|
|
static void test_budget_aid_and_bonus() {
|
|
BudgetInputs in = base_inputs();
|
|
in.aidResearchPercent = 50;
|
|
in.aidSavings = 100;
|
|
in.tra = 4;
|
|
in.trp = 5;
|
|
Budget b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.researchMoney, 3200);
|
|
CHECK_EQ(b.researchMoneyGiven, 1600);
|
|
CHECK_EQ(b.researchMoneyKept, 1600);
|
|
// 31 + 4 + 5 = 40; given 20; kept 20
|
|
CHECK_EQ(b.researchPointsGiven, 20);
|
|
CHECK_EQ(b.totalResearchPoints, 20);
|
|
CHECK_EQ(b.savingsGiven, 100);
|
|
// 6900 - 500 - 1600 - 1600 - 100
|
|
CHECK_EQ(b.net, 3100);
|
|
|
|
in.aidResearchPercent = 250; // clamps to 100
|
|
in.aidSavings = 0;
|
|
b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.researchMoneyGiven, 3200);
|
|
CHECK_EQ(b.totalResearchPoints, 0);
|
|
|
|
in = base_inputs();
|
|
in.techIncomeMult = 1.1;
|
|
b = ComputeBudget(in, false);
|
|
// remaining before bonus = 3200 -> ftol(0.1 x 3200) = 320
|
|
CHECK_EQ(b.bonusIncome, 320);
|
|
CHECK_EQ(b.net, 3520);
|
|
}
|
|
|
|
static void test_budget_edges() {
|
|
BudgetInputs in = base_inputs();
|
|
in.isAI = true;
|
|
Budget b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.construction, 0); // AI path spends construction elsewhere
|
|
CHECK_EQ(b.researchMoney, 3450); // 6900 x 0.5
|
|
|
|
in = base_inputs();
|
|
in.systemIncome = {};
|
|
in.tradeIncome = 0;
|
|
in.maintenance = 5000;
|
|
b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.available, 0); // floored at zero
|
|
CHECK_EQ(b.construction, 0);
|
|
CHECK_EQ(b.researchMoney, 0);
|
|
CHECK_EQ(b.net, 100 - 5000); // interest minus maintenance
|
|
|
|
in = base_inputs();
|
|
in.constructionDemand = 100000;
|
|
b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.construction, 6900); // capped at available
|
|
CHECK_EQ(b.researchMoney, 0);
|
|
|
|
in = base_inputs();
|
|
in.expenses = {{1000, 2000, 1500}};
|
|
b = ComputeBudget(in, false);
|
|
CHECK_EQ(b.expenses, 1500);
|
|
CHECK_EQ(b.available, 5400);
|
|
}
|
|
|
|
static void test_trade() {
|
|
TuningTable t;
|
|
t.TRADE_ROUTE_REQ_CIVPOPULATION = 1e6;
|
|
t.TRADE_ROUTE_REQ_IMPPOPULATION = 1e6;
|
|
CHECK_EQ(TradeRoutesSupported(2.5e6, 1e6, t), 4); // ceil(2.5) + 1
|
|
CHECK_EQ(TradeRoutesSupported(0, 0, t), 1); // minimum one
|
|
CHECK_EQ(TradeRoutesSupported(1, 0, t), 1);
|
|
TuningTable zero;
|
|
CHECK_EQ(TradeRoutesSupported(5e6, 5e6, zero), 1); // zero requirement guarded
|
|
|
|
t.TRADE_ROUTE_STARTUP_TURNS = 3;
|
|
t.TRADE_ROUTE_STARTUP_INCOME = 7;
|
|
t.TRADE_ROUTE_MIN_INCOME = 100;
|
|
t.TRADE_ROUTE_MAX_FREIGHTERS = 5;
|
|
t.TRADE_ROUTE_INCOME_PERFREIGHTER_CRQ = 30;
|
|
t.TRADE_ROUTE_INCOME_PERFREIGHTER_CR = 20;
|
|
t.TRADE_ROUTE_INCOME_PERFREIGHTER_DE = 10;
|
|
t.STATION_BONUS_TRADE_INCOME = 0.1;
|
|
t.ADDICTION_TRADE_MOD = 0.5;
|
|
t.TRADE_ROUTE_OWNERS_SHARE = 0.6;
|
|
|
|
TradeRouteState r;
|
|
r.ageTurns = 3;
|
|
r.freighters[0] = 2; // CRQ: 2 x 30 = 60, cap left 3
|
|
r.freighters[1] = 4; // CR: min(4,3) = 3 x 20 = 60, cap left 0
|
|
r.freighters[2] = 3; // DE: nothing left
|
|
CHECK_EQ(TradeRouteGrossIncome(r, t), 220);
|
|
r.tradeStationsAtSystem = 2;
|
|
CHECK_EQ(TradeRouteGrossIncome(r, t), 264); // x 1.2
|
|
r.partnerAddicted = true;
|
|
CHECK_EQ(TradeRouteGrossIncome(r, t), 132); // x 0.5
|
|
CHECK_EQ(TradeRouteIncome(r, true, 1.0, t), 79); // 132 x 0.6 = 79.2
|
|
CHECK_EQ(TradeRouteIncome(r, false, 1.0, t), 52); // 132 x 0.4 = 52.8
|
|
CHECK_EQ(TradeRouteIncome(r, true, 2.0, t), 158); // AI trade multiplier
|
|
r.ageTurns = 2;
|
|
CHECK_EQ(TradeRouteGrossIncome(r, t), 7); // startup income is flat
|
|
|
|
TradeRouteState empty;
|
|
empty.ageTurns = 10;
|
|
CHECK_EQ(TradeRouteGrossIncome(empty, t), 100); // MIN_INCOME with no freighters
|
|
t.TRADE_ROUTE_OWNERS_SHARE = 1.5; // clamps to 1
|
|
CHECK_EQ(TradeRouteIncome(empty, true, 1.0, t), 100);
|
|
CHECK_EQ(TradeRouteIncome(empty, false, 1.0, t), 0);
|
|
}
|
|
|
|
static void test_bankruptcy() {
|
|
TuningTable t;
|
|
t.BANKRUPTCY_PROTECTION_LIMIT_FACTOR = 3.3;
|
|
t.BANKRUPTCY_ELIMINATION_TURNS = 5;
|
|
BankruptcyLimits l = ComputeBankruptcyLimits(1000, t);
|
|
CHECK_EQ(l.eliminationFloor, -3300);
|
|
CHECK_EQ(l.protectionLimit, -1000);
|
|
CHECK_EQ(BankruptcyLevel(-3301, l), 2);
|
|
CHECK_EQ(BankruptcyLevel(-3300, l), 1);
|
|
CHECK_EQ(BankruptcyLevel(-1500, l), 1);
|
|
CHECK_EQ(BankruptcyLevel(-1000, l), 0);
|
|
CHECK_EQ(BankruptcyLevel(0, l), 0);
|
|
|
|
BankruptcyLimits none = ComputeBankruptcyLimits(0, t);
|
|
CHECK_EQ(none.eliminationFloor, 0);
|
|
CHECK_EQ(BankruptcyLevel(-1, none), 2); // no income at all: any debt is terminal
|
|
|
|
BankruptcyState s;
|
|
CHECK(!BankruptcyStep(s, 1, 10, t));
|
|
CHECK_EQ(s.warningLevel, 1);
|
|
CHECK_EQ(s.startTurn, 10);
|
|
CHECK(!BankruptcyStep(s, 2, 12, t)); // level changed: clock restarts at 12
|
|
CHECK_EQ(s.startTurn, 12);
|
|
CHECK(!BankruptcyStep(s, 2, 16, t)); // 4 turns < 5
|
|
CHECK(BankruptcyStep(s, 2, 17, t)); // 5 turns -> eliminated
|
|
CHECK(!BankruptcyStep(s, 0, 18, t)); // recovered
|
|
CHECK_EQ(s.warningLevel, 0);
|
|
}
|
|
|
|
int main() {
|
|
test_interest();
|
|
test_research_points();
|
|
test_expenses();
|
|
test_budget_hand_case();
|
|
test_budget_projected();
|
|
test_budget_debt();
|
|
test_budget_aid_and_bonus();
|
|
test_budget_edges();
|
|
test_trade();
|
|
test_bankruptcy();
|
|
return simtest::finish("test_economy");
|
|
}
|