cp_nation.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2022 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "../../DateTime.h"
#include "../../cl_shared.h"
#include "../../../shared/parse.h"
#include "../../../shared/shared.h"
#include "cp_campaign.h"
#include "cp_geoscape.h"
#include "cp_ufo.h"
#include "cp_time.h"
#include "save/save_nation.h"
#include "../../ui/node/ui_node_linechart.h" /* lineStrip_t */
#include "cp_missions.h"

/* nation happiness constants */
#define HAPPINESS_ALIEN_MISSION_LOSS        -0.02
#define HAPPINESS_MAX_MISSION_IMPACT        0.07

nation_t* NAT_GetRandom (void)
{
    const int nationIndex = rand() % ccs.numNations;
    int i = 0;
    NAT_Foreach(nation) {
        if (i == nationIndex)
            return nation;
        i++;
    }

    return nullptr;
}

nation_t* NAT_GetNationByID (const char* nationID)
{
    if (nationID == nullptr) {
        cgi->Com_Printf("NAT_GetNationByID: nullptr nationID\n");
        return nullptr;
    }
    NAT_Foreach(nation) {
        if (Q_streq(nation->id, nationID))
            return nation;
    }

    cgi->Com_Printf("NAT_GetNationByID: Could not find nation '%s'\n", nationID);
    return nullptr;
}

void NAT_UpdateHappinessForAllNations (const float minhappiness)
{
    MIS_Foreach(mission) {
        nation_t* nation = GEO_GetNation(mission->pos);
        /* Difficulty modifier range is [0, 0.02f] */

        /* Some non-water location have no nation */
        if (!nation)
            continue;

        float happinessFactor;
        const nationInfo_t* stats = NAT_GetCurrentMonthInfo(nation);
        switch (mission->stage) {
        case STAGE_TERROR_MISSION:
        case STAGE_SUBVERT_GOV:
        case STAGE_RECON_GROUND:
        case STAGE_SPREAD_XVI:
        case STAGE_HARVEST:
            happinessFactor = HAPPINESS_ALIEN_MISSION_LOSS;
            break;
        default:
            /* mission is not active on earth or does not have any influence
             * on the nation happiness, skip this mission */
            continue;
        }

        NAT_SetHappiness(minhappiness, nation, stats->happiness + happinessFactor);
        cgi->Com_DPrintf(DEBUG_CLIENT, "Happiness of nation %s decreased: %.02f\n", nation->name, stats->happiness);
    }
}

int NAT_GetFunding (const nation_t* const nation, int month)
{
    assert(month >= 0);
    assert(month < DateTime::MONTHS_PER_YEAR);
    return nation->maxFunding * nation->stats[month].happiness;
}

const nationInfo_t* NAT_GetCurrentMonthInfo (const nation_t* const nation)
{
    return &nation->stats[0];
}

const char* NAT_GetHappinessString (const float happiness)
{
    if (happiness < 0.015)
        return _("Giving up");
    else if (happiness < 0.025)
        return _("Furious");
    else if (happiness < 0.04)
        return _("Angry");
    else if (happiness < 0.06)
        return _("Mad");
    else if (happiness < 0.10)
        return _("Upset");
    else if (happiness < 0.20)
        return _("Tolerant");
    else if (happiness < 0.30)
        return _("Neutral");
    else if (happiness < 0.50)
        return _("Content");
    else if (happiness < 0.70)
        return _("Pleased");
    else if (happiness < 0.95)
        return _("Happy");
    else
        return _("Exuberant");

}

const char* NAT_GetCurrentHappinessString (const nation_t* nation)
{
    const nationInfo_t* stats = NAT_GetCurrentMonthInfo(nation);
    return NAT_GetHappinessString(stats->happiness);
}

void NAT_SetHappiness (const float minhappiness, nation_t* nation, const float happiness)
{
    const char* oldString = NAT_GetCurrentHappinessString(nation);
    const char* newString;
    nationInfo_t* stats = &nation->stats[0];
    const float oldHappiness = stats->happiness;
    const float middleHappiness = (minhappiness + 1.0) / 2;
    notify_t notifyType = NT_NUM_NOTIFYTYPE;

    stats->happiness = happiness;
    if (stats->happiness < 0.0f)
        stats->happiness = 0.0f;
    else if (stats->happiness > 1.0f)
        stats->happiness = 1.0f;

    newString = NAT_GetCurrentHappinessString(nation);

    if (oldString != newString) {
        Com_sprintf(cp_messageBuffer, sizeof(cp_messageBuffer),
            _("Nation %s changed happiness from %s to %s"), _(nation->name), oldString, newString);
        notifyType = NT_HAPPINESS_CHANGED;
    } else if (oldHappiness > middleHappiness && happiness < middleHappiness) {
        Com_sprintf(cp_messageBuffer, sizeof(cp_messageBuffer),
            _("Nation %s changed happiness to %s"), _(nation->name), newString);
        notifyType = NT_HAPPINESS_PLEASED;
    } else if (happiness < minhappiness && oldHappiness > minhappiness) {
        Com_sprintf(cp_messageBuffer, sizeof(cp_messageBuffer), 
            _("Happiness of nation %s is %s and less than minimal happiness allowed to the campaign"), _(nation->name), newString);
        notifyType = NT_HAPPINESS_MIN;
    } else {
        return;
    }

    MSO_CheckAddNewMessage(notifyType, _("Nation changed happiness"), cp_messageBuffer);
}

bool NAT_SaveXML (xmlNode_t* p)
{
    xmlNode_t* n = cgi->XML_AddNode(p, SAVE_NATION_NATIONS);

    NAT_Foreach(nation) {
        xmlNode_t* s = cgi->XML_AddNode(n, SAVE_NATION_NATION);
        cgi->XML_AddString(s, SAVE_NATION_ID, nation->id);
        for (int j = 0; j < DateTime::MONTHS_PER_YEAR; j++) {
            const nationInfo_t* stats = &nation->stats[j];

            if (!stats->inuse)
                continue;

            xmlNode_t* ss = cgi->XML_AddNode(s, SAVE_NATION_MONTH);
            cgi->XML_AddInt(ss, SAVE_NATION_MONTH_IDX, j);
            cgi->XML_AddFloat(ss, SAVE_NATION_HAPPINESS, stats->happiness);
            cgi->XML_AddInt(ss, SAVE_NATION_XVI, stats->xviInfection);
        }
    }
    return true;
}

void CP_HandleNationData (float minHappiness, mission_t* mis, const nation_t* affectedNation, const missionResults_t* results, bool won)
{
    const float civilianSum = (float) (results->civiliansSurvived + results->civiliansKilled + results->civiliansKilledFriendlyFire);
    const float alienSum = (float) (results->aliensSurvived + results->aliensKilled + results->aliensStunned);
    float performance;
    float performanceAlien;
    float performanceCivilian;
    float deltaHappiness = 0.0f;
    float happinessDivisor = 5.0f;
    float victoryBonusPerAlien = 0.1f;

    if (mis->mapDef->victoryBonusPerAlien) {
        victoryBonusPerAlien = mis->mapDef->victoryBonusPerAlien;
    }

    if (civilianSum <= 1) {
        performanceCivilian = 0.0f;
    } else {
        performanceCivilian = (2 * civilianSum - results->civiliansKilled - 2
            * results->civiliansKilledFriendlyFire) * 3 / (2 * civilianSum) - 2;
    }

    /* Calculate how well the mission went. */
    if (won) {
        performanceAlien = (results->aliensKilled + results->aliensStunned) * victoryBonusPerAlien;
    } else {
        performanceAlien = results->aliensKilled + results->aliensStunned - alienSum;
    }
    performance = performanceCivilian + performanceAlien;

    /* Calculate the actual happiness delta. The bigger the mission, the more potential influence. */
    deltaHappiness = 0.004 * civilianSum + 0.004 * alienSum;

    /* There is a maximum base happiness delta. */
    if (deltaHappiness > HAPPINESS_MAX_MISSION_IMPACT)
        deltaHappiness = HAPPINESS_MAX_MISSION_IMPACT;

    NAT_Foreach(nation) {
        const nationInfo_t* stats = NAT_GetCurrentMonthInfo(nation);
        float happinessFactor;

        /* update happiness. */
        if (nation == affectedNation)
            happinessFactor = deltaHappiness;
        else
            happinessFactor = deltaHappiness / happinessDivisor;

        NAT_SetHappiness(minHappiness, nation, stats->happiness + performance * happinessFactor);
    }
}

bool NAT_LoadXML (xmlNode_t* p)
{
    xmlNode_t* n;
    xmlNode_t* s;

    n = cgi->XML_GetNode(p, SAVE_NATION_NATIONS);
    if (!n)
        return false;

    /* nations loop */
    for (s = cgi->XML_GetNode(n, SAVE_NATION_NATION); s; s = cgi->XML_GetNextNode(s, n, SAVE_NATION_NATION)) {
        xmlNode_t* ss;
        nation_t* nation = NAT_GetNationByID(cgi->XML_GetString(s, SAVE_NATION_ID));

        if (!nation)
            return false;

        /* month loop */
        for (ss = cgi->XML_GetNode(s, SAVE_NATION_MONTH); ss; ss = cgi->XML_GetNextNode(ss, s, SAVE_NATION_MONTH)) {
            int monthIDX = cgi->XML_GetInt(ss, SAVE_NATION_MONTH_IDX, DateTime::MONTHS_PER_YEAR);
            nationInfo_t* stats = &nation->stats[monthIDX];

            if (monthIDX < 0 || monthIDX >= DateTime::MONTHS_PER_YEAR)
                return false;

            stats->inuse = true;
            stats->happiness = cgi->XML_GetFloat(ss, SAVE_NATION_HAPPINESS, 0.0);
            stats->xviInfection = cgi->XML_GetInt(ss, SAVE_NATION_XVI, 0);
        }
    }
    return true;
}

/*==========================================
Parsing
==========================================*/

static const value_t nation_vals[] = {
    {"name", V_TRANSLATION_STRING, offsetof(nation_t, name), 0},
    {"pos", V_POS, offsetof(nation_t, pos), MEMBER_SIZEOF(nation_t, pos)},
    {"color", V_COLOR, offsetof(nation_t, color), MEMBER_SIZEOF(nation_t, color)},
    {"funding", V_INT, offsetof(nation_t, maxFunding), MEMBER_SIZEOF(nation_t, maxFunding)},
    {"happiness", V_FLOAT, offsetof(nation_t, stats[0].happiness), MEMBER_SIZEOF(nation_t, stats[0].happiness)},
    {"soldiers", V_INT, offsetof(nation_t, maxSoldiers), MEMBER_SIZEOF(nation_t, maxSoldiers)},
    {"scientists", V_INT, offsetof(nation_t, maxScientists), MEMBER_SIZEOF(nation_t, maxScientists)},
    {"workers", V_INT, offsetof(nation_t, maxWorkers), MEMBER_SIZEOF(nation_t, maxWorkers)},
    {"pilots", V_INT, offsetof(nation_t, maxPilots), MEMBER_SIZEOF(nation_t, maxPilots)},

    {nullptr, V_NULL, 0, 0}
};

void CL_ParseNations (const char* name, const char** text)
{
    /* search for nations with same name */
    NAT_Foreach(n) {
        if (Q_streq(name, n->id)) {
            cgi->Com_Printf("CL_ParseNations: nation def \"%s\" with same name found, second ignored\n", name);
            return;
        }
    }

    /* initialize the nation */
    nation_t nation;
    OBJZERO(nation);
    nation.idx = ccs.numNations;
    nation.stats[0].inuse = true;

    if (cgi->Com_ParseBlock(name, text, &nation, nation_vals, cp_campaignPool)) {
        ccs.numNations++;

        cgi->Com_DPrintf(DEBUG_CLIENT, "...found nation %s\n", name);
        nation.id = cgi->PoolStrDup(name, cp_campaignPool, 0);
        LIST_Add(&ccs.nations, nation);
    }
}

city_t* CITY_GetById (const char* cityId)
{
    LIST_Foreach(ccs.cities, city_t, city) {
        if (Q_streq(cityId, city->id))
            return city;
    }
    return nullptr;
}

city_t* CITY_GetByPos (vec2_t pos)
{
    LIST_Foreach(ccs.cities, city_t, city) {
        if (Vector2Equal(pos, city->pos))
            return city;
    }
    return nullptr;
}

static const value_t city_vals[] = {
    {"name", V_TRANSLATION_STRING, offsetof(city_t, name), 0},
    {"pos", V_POS, offsetof(city_t, pos), MEMBER_SIZEOF(city_t, pos)},

    {nullptr, V_NULL, 0, 0}
};

void CITY_Parse (const char* name, const char** text)
{
    city_t newCity;

    /* search for cities with same name */
    if (CITY_GetById(name)) {
        cgi->Com_Printf("CITY_Parse: city def \"%s\" with same name found, second ignored\n", name);
        return;
    }

    OBJZERO(newCity);

    if (cgi->Com_ParseBlock(name, text, &newCity, city_vals, cp_campaignPool)) {
        ccs.numCities++;
        newCity.id = cgi->PoolStrDup(name, cp_campaignPool, 0);
        /* Add city to the list */
        LIST_Add(&ccs.cities, newCity);
    }
}

bool NAT_ScriptSanityCheck (void)
{
    int error = 0;

    /* Check if there is at least one map fitting city parameter for terror mission */
    LIST_Foreach(ccs.cities, city_t, city) {
        bool cityCanBeUsed = false;
        bool parametersFit = false;
        ufoType_t ufoTypes[UFO_MAX];
        int numTypes;
        const mapDef_t* md;

        if (!city->name) {
            error++;
            cgi->Com_Printf("...... city '%s' has no name\n", city->id);
        }

        if (MapIsWater(GEO_GetColor(city->pos, MAPTYPE_TERRAIN, nullptr))) {
            error++;
            cgi->Com_Printf("...... city '%s' has a position in the water\n", city->id);
        }

        numTypes = UFO_GetAvailableUFOsForMission(INTERESTCATEGORY_TERROR_ATTACK, ufoTypes, false);

        MapDef_ForeachSingleplayerCampaign(md) {
            if (md->storyRelated)
                continue;

            if (GEO_PositionFitsTCPNTypes(city->pos, md->terrains, md->cultures, md->populations, nullptr)) {
                /* this map fits city parameter, check if we have some terror mission UFOs available for this map */
                parametersFit = true;

                /* no UFO on this map (LIST_ContainsString doesn't like empty string) */
                if (!md->ufos) {
                    continue;
                }

                /* loop must be backward, as we remove items */
                for (int i = numTypes - 1 ; i >= 0; i--) {
                    if (cgi->LIST_ContainsString(md->ufos, cgi->Com_UFOTypeToShortName(ufoTypes[i]))) {
                        REMOVE_ELEM(ufoTypes, i, numTypes);
                    }
                }
            }
            if (numTypes == 0) {
                cityCanBeUsed = true;
                break;
            }
        }

        if (!cityCanBeUsed) {
            error++;
            cgi->Com_Printf("...... city '%s' can't be used in game: it has no map fitting parameters\n", city->id);
            if (parametersFit) {
                cgi->Com_Printf("      (No map fitting");
                for (int i = 0 ; i < numTypes; i++)
                    cgi->Com_Printf(" %s", cgi->Com_UFOTypeToShortName(ufoTypes[i]));
                cgi->Com_Printf(")\n");
            }
            GEO_PrintParameterStringByPos(city->pos);
        }
    }

    return !error;
}

/*=====================================
Menu functions
=====================================*/

static void NAT_ListStats_f (void)
{
    const int argCount = cgi->Cmd_Argc();
    if (argCount < 2) {
        cgi->Com_Printf("Usage: %s <confunc> [nationID] [monthIDX]\n", cgi->Cmd_Argv(0));
        return;
    }
    char callback[MAX_VAR];
    Q_strncpyz(callback, cgi->Cmd_Argv(1), sizeof(callback));

    NAT_Foreach(nation) {
        if (argCount >= 3 && !Q_streq(nation->id, cgi->Cmd_Argv(1)))
            continue;

        for (int monthIDX = 0; monthIDX < DateTime::MONTHS_PER_YEAR; monthIDX++) {
            if (!nation->stats[monthIDX].inuse)
                break;

            if (argCount >= 4 && monthIDX != -1 * atoi(cgi->Cmd_Argv(3)))
                continue;

            cgi->UI_ExecuteConfunc("%s %s \"%s\" %d %.4f \"%s\" %d \"%f, %f, %f, %f\"",
                callback,
                nation->id,
                _(nation->name),
                monthIDX,
                nation->stats[monthIDX].happiness,
                NAT_GetHappinessString(nation->stats[monthIDX].happiness),
                NAT_GetFunding(nation, monthIDX),
                nation->color[0],
                nation->color[1],
                nation->color[2],
                nation->color[3]
            );
        }
    }
}

static void NAT_DrawCharts_f (void)
{
    const int argCount = cgi->Cmd_Argc();
    if (argCount < 5) {
        cgi->Com_Printf("Usage: %s <stat_type> <chartnode> <width> <height>\n", cgi->Cmd_Argv(0));
        return;
    }

    char type[MAX_VAR];
    Q_strncpyz(type, cgi->Cmd_Argv(1), MAX_VAR);
    char nodePath[255];
    Q_strncpyz(nodePath, cgi->Cmd_Argv(2), 255);
    const int width = atoi(cgi->Cmd_Argv(3));
    const int height = atoi(cgi->Cmd_Argv(4));
    if (width <= 0 || height <= 0)
        return;

    const int dx = (int)(width / DateTime::MONTHS_PER_YEAR);

    /* Calculate chart bounds (maximums) */
    int maxFunding;
    float maxXVI;
    int nationIdx = 0;
    NAT_Foreach(nation) {
        for (int monthIdx = 0; monthIdx < DateTime::MONTHS_PER_YEAR; monthIdx++) {
            if (!nation->stats[monthIdx].inuse)
                break;

            if (nationIdx == 0 && monthIdx == 0) {
                maxFunding = NAT_GetFunding(nation, monthIdx);
                maxXVI = nation->stats[monthIdx].xviInfection;
            } else {
                if (maxFunding < NAT_GetFunding(nation, monthIdx))
                    maxFunding = NAT_GetFunding(nation, monthIdx);
                if (maxXVI < nation->stats[monthIdx].xviInfection)
                    maxXVI = nation->stats[monthIdx].xviInfection;
            }
        }
        nationIdx++;
    }

    const float dyFunding = (0 != maxFunding) ? (float) height / maxFunding : 1;
    const float dyXvi = (0 != maxXVI) ? (float) height / maxXVI : 1;

    uiNode_t* chart = cgi->UI_GetNodeByPath(nodePath);
    if (chart == nullptr) {
        cgi->Com_Printf("chart node not found\n");
        return;
    }
    /* Fill the points */
    NAT_Foreach(nation) {
        cgi->UI_ExecuteConfunc("ui_nation_graph_add_line %s %s %f %f %f %f %s %d",
            nation->id,
            "true",
            nation->color[0],
            nation->color[1],
            nation->color[2],
            nation->color[3],
            "true",
            12
        );

        int monthIdx;
        for (monthIdx = 0; monthIdx < DateTime::MONTHS_PER_YEAR; monthIdx++) {
            if (!nation->stats[monthIdx].inuse)
                break;

            if (Q_streq("funding", type)) {
                const int funding = NAT_GetFunding(nation, monthIdx);
                cgi->UI_ExecuteConfunc("ui_nation_graph_add_point %s %d %f",
                    nation->id, (monthIdx * dx), height - dyFunding * funding);
            } else if (Q_streq("happiness", type)) {
                cgi->UI_ExecuteConfunc("ui_nation_graph_add_point %s %d %f",
                    nation->id, (monthIdx * dx), height - (height * nation->stats[monthIdx].happiness));
            } else if (Q_streq("xvi", type)) {
                const int xviInfection= nation->stats[monthIdx].xviInfection;
                cgi->UI_ExecuteConfunc("ui_nation_graph_add_point %s %d %f",
                    nation->id, (monthIdx * dx), height - dyXvi * xviInfection);
            }
        }
        nationIdx++;
    }
}

#ifdef DEBUG

static void NAT_ListCities_f (void)
{
    LIST_Foreach(ccs.cities, city_t, city) {
        cgi->Com_Printf("City '%s' -- position (%0.1f, %0.1f)\n", city->id, city->pos[0], city->pos[1]);
        GEO_PrintParameterStringByPos(city->pos);
    }
}

static void NAT_NationList_f (void)
{
    NAT_Foreach(nation) {
        cgi->Com_Printf("Nation ID: %s\n", nation->id);
        cgi->Com_Printf("...max-funding %i c\n", nation->maxFunding);
        cgi->Com_Printf("...happiness %0.2f\n", nation->stats[0].happiness);
        cgi->Com_Printf("...xviInfection %i\n", nation->stats[0].xviInfection);
        cgi->Com_Printf("...max-soldiers %i\n", nation->maxSoldiers);
        cgi->Com_Printf("...max-scientists %i\n", nation->maxScientists);
        cgi->Com_Printf("...max-workers %i\n", nation->maxWorkers);
        cgi->Com_Printf("...max-pilots %i\n", nation->maxPilots);
        cgi->Com_Printf("...color r:%.2f g:%.2f b:%.2f a:%.2f\n", nation->color[0], nation->color[1], nation->color[2], nation->color[3]);
        cgi->Com_Printf("...pos x:%.0f y:%.0f\n", nation->pos[0], nation->pos[1]);
    }
}
#endif

void NAT_HandleBudget (const campaign_t* campaign)
{
    char message[1024];
    int cost;
    int totalIncome = 0;
    int totalExpenditure = 0;
    int initialCredits = ccs.credits;
    const salary_t* salary = &campaign->salaries;

    NAT_Foreach(nation) {
        const nationInfo_t* stats = NAT_GetCurrentMonthInfo(nation);
        const int funding = NAT_GetFunding(nation, 0);
        int newScientists = 0, newSoldiers = 0, newPilots = 0, newWorkers = 0;

        totalIncome += funding;

        for (int j = 0; 0.25 + j < (float) nation->maxScientists * stats->happiness * ccs.curCampaign->employeeRate; j++) {
            /* Create a scientist, but don't auto-hire her. */
            E_CreateEmployee(EMPL_SCIENTIST, nation, nullptr);
            newScientists++;
        }

        if (stats->happiness > 0) {
            for (int j = 0; 0.25 + j < (float) nation->maxSoldiers * stats->happiness * ccs.curCampaign->employeeRate; j++) {
                /* Create a soldier. */
                E_CreateEmployee(EMPL_SOLDIER, nation, nullptr);
                newSoldiers++;
            }
        }
        /* pilots */
        if (stats->happiness > 0) {
            for (int j = 0; 0.25 + j < (float) nation->maxPilots * stats->happiness * ccs.curCampaign->employeeRate; j++) {
                /* Create a pilot. */
                E_CreateEmployee(EMPL_PILOT, nation, nullptr);
                newPilots++;
            }
        }

        for (int j = 0; 0.25 + j * 2 < (float) nation->maxWorkers * stats->happiness * ccs.curCampaign->employeeRate; j++) {
            /* Create a worker. */
            E_CreateEmployee(EMPL_WORKER, nation, nullptr);
            newWorkers++;
        }

        Com_sprintf(message, sizeof(message), _("Gained %i %s, %i %s, %i %s, %i %s, and %i %s from nation %s (%s)"),
            funding, ngettext("credit", "credits", funding),
            newScientists, ngettext("scientist", "scientists", newScientists),
            newSoldiers, ngettext("soldier", "soldiers", newSoldiers),
            newPilots, ngettext("pilot", "pilots", newPilots),
            newWorkers, ngettext("worker", "workers", newWorkers),
            _(nation->name), NAT_GetCurrentHappinessString(nation));
        MS_AddNewMessage(_("Notice"), message);
    }

    for (int i = 0; i < MAX_EMPL; i++) {
        int count = 0;
        cost = 0;
        E_Foreach(i, employee) {
            if (!employee->isHired())
                continue;
            cost += employee->salary();
            count++;
        }
        totalExpenditure += cost;

        if (cost == 0)
            continue;

        Com_sprintf(message, sizeof(message), _("Paid %i credits to: %s"), cost, E_GetEmployeeString((employeeType_t)i, count));
        MS_AddNewMessage(_("Notice"), message);
    }

    cost = 0;
    AIR_Foreach(aircraft) {
        if (aircraft->status == AIR_CRASHED)
            continue;
        cost += aircraft->price * salary->aircraftFactor / salary->aircraftDivisor;
    }
    totalExpenditure += cost;

    if (cost != 0) {
        Com_sprintf(message, sizeof(message), _("Paid %i credits for aircraft"), cost);
        MS_AddNewMessage(_("Notice"), message);
    }

    base_t* base = nullptr;
    while ((base = B_GetNext(base)) != nullptr) {
        cost = CP_GetSalaryUpKeepBase(salary, base);
        totalExpenditure += cost;

        Com_sprintf(message, sizeof(message), _("Paid %i credits for upkeep of %s"), cost, base->name);
        MS_AddNewMessage(_("Notice"), message);
    }

    if (initialCredits < 0) {
        const float interest = initialCredits * campaign->salaries.debtInterest;

        cost = (int)ceil(interest);
        Com_sprintf(message, sizeof(message), _("Paid %i credits in interest on your debt."), cost);
        totalExpenditure += cost;
        MS_AddNewMessage(_("Notice"), message);
    }
    CP_UpdateCredits(ccs.credits - totalExpenditure + totalIncome);
    CP_GameTimeStop();
}

void NAT_BackupMonthlyData (void)
{
    NAT_Foreach(nation) {
        for (int i = DateTime::MONTHS_PER_YEAR - 1; i > 0; i--) {   /* Reverse copy to not overwrite with wrong data */
            nation->stats[i] = nation->stats[i - 1];
        }
    }
}

static const cmdList_t nationCmds[] = {
    {"nation_getstats", NAT_ListStats_f, "Returns nation happiness and funding stats through a UI callback."},
    {"nation_drawcharts", NAT_DrawCharts_f, "Draws nation happiness and funding charts."},
#ifdef DEBUG
    {"debug_listcities", NAT_ListCities_f, "Debug function to list all cities in game."},
    {"debug_listnations", NAT_NationList_f, "List all nations on the game console"},
#endif
    {nullptr, nullptr, nullptr}
};

void NAT_InitStartup (void)
{
    cgi->Cmd_TableAddList(nationCmds);
}

void NAT_Shutdown (void)
{
    cgi->LIST_Delete(&ccs.cities);
    cgi->LIST_Delete(&ccs.nations);

    cgi->Cmd_TableRemoveList(nationCmds);
}