cp_employee.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 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 "../../cl_shared.h"
#include "../cl_game.h" /* GAME_GetTeamDef */
#include "../cl_game_team.h" /* character xml loading */
#include "cp_campaign.h"
#include "cp_employee_callbacks.h"
#include "cp_rank.h"
#include "cp_popup.h"
#include "save/save_employee.h"

int E_CountByType (employeeType_t type)
{
    return cgi->LIST_Count(ccs.employees[type]);
}

Employee* E_GetUnhired (employeeType_t type)
{
    E_Foreach(type, employee) {
        if (!employee->isHired())
            return employee;
    }
 
    return nullptr;
}

int Employee::salary() const
{
    const campaign_t* campaign = ccs.curCampaign;
    const salary_t* salary = &campaign->salaries;
    const rank_t* rank = CL_GetRankByIdx(this->chr.score.rank);
    return salary->base[getType()] + rank->level * salary->rankBonus[getType()];
}

bool Employee::isAwayFromBase () const
{
    /* Check that employee is hired */
    if (!isHired())
        return false;
 
    /* Check if employee is currently transferred. */
    if (transfer)
        return true;
 
    /* for now only soldiers, ugvs and pilots can be assigned to an aircraft */
    if (!isSoldier() && !isRobot() && !isPilot())
        return false;
 
    /* Crashed aircraft no longer belongs to any base but poor pilot/soldiers assigned
     * to it are definitely away from the base so we need to iterate through all aircraft */
    AIR_Foreach(aircraft) {
        if (aircraft->homebase != baseHired)
            continue;
        if (!AIR_IsAircraftInBase(aircraft) && AIR_IsEmployeeInAircraft(this, aircraft))
            return true;
    }
    return false;
}

void E_HireForBuilding (base_t* base, building_t* building, int num)
{
    if (num < 0)
        num = building->maxEmployees;
 
    if (num) {
        employeeType_t employeeType;
        switch (building->buildingType) {
        case B_WORKSHOP:
            employeeType = EMPL_WORKER;
            break;
        case B_LAB:
            employeeType = EMPL_SCIENTIST;
            break;
        case B_HANGAR: /* the Dropship Hangar */
            employeeType = EMPL_SOLDIER;
            break;
        case B_MISC:
            cgi->Com_DPrintf(DEBUG_CLIENT, "E_HireForBuilding: Misc building type: %i with employees: %i.\n", building->buildingType, num);
            return;
        default:
            cgi->Com_DPrintf(DEBUG_CLIENT, "E_HireForBuilding: Unknown building type: %i.\n", building->buildingType);
            return;
        }
        /* don't try to hire more that available - see E_CreateEmployee */
        num = std::min(num, E_CountByType(employeeType));
        for (;num--;) {
            assert(base);
            if (!E_HireEmployeeByType(base, employeeType)) {
                cgi->Com_DPrintf(DEBUG_CLIENT, "E_HireForBuilding: Hiring %i employee(s) of type %i failed.\n", num, employeeType);
                return;
            }
        }
    }
}

bool E_MoveIntoNewBase (Employee* employee, base_t* newBase)
{
    if (employee) {
        base_t* oldBase = employee->baseHired;
        employee->baseHired = newBase;
        /* Remove employee from corresponding capacity */
        switch (employee->getType()) {
        case EMPL_WORKER:
            if (oldBase != nullptr)
                PR_UpdateProductionCap(oldBase, 0);
            /* fall through */
        case EMPL_PILOT:
        case EMPL_SCIENTIST:
        case EMPL_SOLDIER:
            if (oldBase != nullptr)
                CAP_AddCurrent(oldBase, CAP_EMPLOYEES, -1);
            CAP_AddCurrent(newBase, CAP_EMPLOYEES, 1);
            break;
        case EMPL_ROBOT:
            if (oldBase != nullptr)
                CAP_AddCurrent(oldBase, CAP_ITEMS, -UGV_SIZE);
            CAP_AddCurrent(newBase, CAP_ITEMS, UGV_SIZE);
            break;
        case MAX_EMPL:
            break;
        }
        return true;
    }
 
    return false;
}

const char* E_GetEmployeeString (employeeType_t type, int n)
{
    switch (type) {
    case EMPL_SOLDIER:
        return ngettext("Soldier", "Soldiers", n);
    case EMPL_SCIENTIST:
        return ngettext("Scientist", "Scientists", n);
    case EMPL_WORKER:
        return ngettext("Worker", "Workers", n);
    case EMPL_PILOT:
        return ngettext("Pilot", "Pilots", n);
    case EMPL_ROBOT:
        return ngettext("UGV", "UGVs", n);
    default:
        cgi->Com_Error(ERR_DROP, "Unknown employee type '%i'\n", type);
    }
}

employeeType_t E_GetEmployeeType (const char* type)
{
    if (!type)
        return MAX_EMPL;
 
    /* employee types as string */
    if (Q_streq(type, "EMPL_SCIENTIST"))
        return EMPL_SCIENTIST;
    else if (Q_streq(type, "EMPL_SOLDIER"))
        return EMPL_SOLDIER;
    else if (Q_streq(type, "EMPL_WORKER"))
        return EMPL_WORKER;
    else if (Q_streq(type, "EMPL_PILOT"))
        return EMPL_PILOT;
    else if (Q_streq(type, "EMPL_ROBOT"))
        return EMPL_ROBOT;
 
    /* human readable employee type strings */
    if (Q_streq(type, "scientist"))
        return EMPL_SCIENTIST;
    else if (Q_streq(type, "soldier"))
        return EMPL_SOLDIER;
    else if (Q_streq(type, "worker"))
        return EMPL_WORKER;
    else if (Q_streq(type, "pilot"))
        return EMPL_PILOT;
    else if (Q_streq(type, "robot"))
        return EMPL_ROBOT;
    else if (Q_streq(type, "ugv"))
        return EMPL_ROBOT;
 
    return MAX_EMPL;
}

Employee* E_GetUnhiredRobot (const ugv_t* ugvType)
{
    E_Foreach(EMPL_ROBOT, employee) {
        if (!employee->isHired()) {
            /* If no type was given we return the first ugv we find. */
            if (!ugvType || employee->getUGV() == ugvType)
                return employee;
        }
    }
 
    return nullptr;
}

int E_GetHiredEmployees (const base_t* const base, employeeType_t type, linkedList_t** hiredEmployees)
{
    if (type >= MAX_EMPL) {
        cgi->Com_Printf("E_GetHiredEmployees: Unknown EmployeeType: %i\n", type);
        *hiredEmployees = nullptr;
        return -1;
    }
 
    cgi->LIST_Delete(hiredEmployees);
 
    E_Foreach(type, employee) {
        if (!employee->isHired())
            continue;
        if (!employee->transfer && (!base || employee->isHiredInBase(base))) {
            cgi->LIST_AddPointer(hiredEmployees, employee);
        }
    }
 
    return cgi->LIST_Count(*hiredEmployees);
}

Employee* E_GetHiredRobot (const base_t* const base, const ugv_t* ugvType)
{
    linkedList_t* hiredEmployees = nullptr;
    Employee* employee;
 
    E_GetHiredEmployees(base, EMPL_ROBOT, &hiredEmployees);
 
    employee = nullptr;
    LIST_Foreach(hiredEmployees, Employee, e) {
        if ((e->getUGV() == ugvType || !ugvType)    /* If no type was given we return the first ugv we find. */
         && e->isHiredInBase(base)) {       /* It has to be in the defined base. */
            assert(e->isHired());
            employee = e;
            break;
        }
    }
 
    cgi->LIST_Delete(&hiredEmployees);
 
    if (!employee)
        cgi->Com_DPrintf(DEBUG_CLIENT, "Could not get unhired ugv/robot.\n");
 
    return employee;
}

Employee* E_GetAssignedEmployee (const base_t* const base, const employeeType_t type)
{
    E_Foreach(type, employee) {
        if (!employee->isHiredInBase(base))
            continue;
        if (employee->isAssigned())
            return employee;
    }
    return nullptr;
}

Employee* E_GetUnassignedEmployee (const base_t* const base, const employeeType_t type)
{
    E_Foreach(type, employee) {
        if (!employee->isHiredInBase(base))
            continue;
        if (employee->transfer)
            continue;
        if (!employee->isAssigned())
            return employee;
    }
    return nullptr;
}

bool E_HireEmployee (base_t* base, Employee* employee)
{
    if (CAP_GetFreeCapacity(base, CAP_EMPLOYEES) <= 0) {
        CP_Popup(_("Not enough quarters"), _("You don't have enough quarters for your employees.\nBuild more quarters."));
        return false;
    }
 
    if (employee) {
        /* Now uses quarter space. */
        employee->baseHired = base;
        /* Update other capacities */
        switch (employee->getType()) {
        case EMPL_WORKER:
            CAP_AddCurrent(base, CAP_EMPLOYEES, 1);
            PR_UpdateProductionCap(base);
            break;
        case EMPL_PILOT:
            AIR_AutoAddPilotToAircraft(base, employee);
            /* fall through */
        case EMPL_SCIENTIST:
        case EMPL_SOLDIER:
            CAP_AddCurrent(base, CAP_EMPLOYEES, 1);
            break;
        case EMPL_ROBOT:
            CAP_AddCurrent(base, CAP_ITEMS, UGV_SIZE);
            break;
        case MAX_EMPL:
            break;
        }
        return true;
    }
    return false;
}

bool E_HireEmployeeByType (base_t* base, employeeType_t type)
{
    Employee* employee = E_GetUnhired(type);
    return employee ? E_HireEmployee(base, employee) : false;
}

bool E_HireRobot (base_t* base, const ugv_t* ugvType)
{
    Employee* employee = E_GetUnhiredRobot(ugvType);
    return employee ? E_HireEmployee(base, employee) : false;
}

bool Employee::unassign ()
{
    if (!baseHired)
        return false;
 
    /* Remove employee from building/tech/production/aircraft). */
    switch (_type) {
    case EMPL_SCIENTIST:
        if (isAssigned())
            RS_RemoveFiredScientist(baseHired, this);
        break;
    case EMPL_ROBOT:
    case EMPL_SOLDIER:
        /* Remove soldier from aircraft/team if he was assigned to one. */
        if (AIR_IsEmployeeInAircraft(this, nullptr))
            AIR_RemoveEmployee(this, nullptr);
        break;
    case EMPL_PILOT:
        AIR_RemovePilotFromAssignedAircraft(baseHired, this);
        break;
    case EMPL_WORKER:
    default:
        break;
    }
 
    return true;
}

void Employee::unequip ()
{
    /* Destroy the inventory of the employee (carried items will remain in base->storage) */
    cgi->INV_DestroyInventory(&chr.inv);
}

bool Employee::unhire ()
{
    if (!isHired() || transfer) {
        cgi->Com_DPrintf(DEBUG_CLIENT, "Could not fire employee\n");
        return false;
    }
 
    unassign();
    unequip();
 
    /* Remove employee from corresponding capacity */
    switch (_type) {
    case EMPL_WORKER:
        PR_UpdateProductionCap(baseHired, -1);
        /* fall through */
    case EMPL_PILOT:
    case EMPL_SCIENTIST:
    case EMPL_SOLDIER:
        CAP_AddCurrent(baseHired, CAP_EMPLOYEES, -1);
        break;
    case EMPL_ROBOT:
        CAP_AddCurrent(baseHired, CAP_ITEMS, -UGV_SIZE);
        break;
    case MAX_EMPL:
        break;
    }
 
    /* Set all employee-tags to 'unhired'. */
    baseHired = nullptr;
 
    return true;
}

void E_UnhireAllEmployees (base_t* base, employeeType_t type)
{
    if (!base)
        return;
 
    assert(type < MAX_EMPL);
 
    E_Foreach(type, employee) {
        if (!employee->isHiredInBase(base))
            continue;
        employee->unhire();
    }
}

Employee* E_CreateEmployee (employeeType_t type, const nation_t* nation, const ugv_t* ugvType)
{
    const char* teamID;
    char teamDefName[MAX_VAR];
    const char* rank;
 
    if (type >= MAX_EMPL)
        return nullptr;
 
    Employee employee(type, nation, ugvType);
 
    teamID = GAME_CP_GetTeamDef();
 
    /* Generate character stats, models & names. */
    switch (type) {
    case EMPL_SOLDIER:
        rank = "rifleman";
        Q_strncpyz(teamDefName, teamID, sizeof(teamDefName));
        break;
    case EMPL_SCIENTIST:
        rank = "scientist";
        Com_sprintf(teamDefName, sizeof(teamDefName), "%s_scientist", teamID);
        break;
    case EMPL_PILOT:
        rank = "pilot";
        Com_sprintf(teamDefName, sizeof(teamDefName), "%s_pilot", teamID);
        break;
    case EMPL_WORKER:
        rank = "worker";
        Com_sprintf(teamDefName, sizeof(teamDefName), "%s_worker", teamID);
        break;
    case EMPL_ROBOT:
        if (ugvType == nullptr)
            cgi->Com_Error(ERR_DROP, "E_CreateEmployee: no type given for generation of EMPL_ROBOT employee.");
 
        rank = "ugv";
 
        Com_sprintf(teamDefName, sizeof(teamDefName), "%s%s", teamID, ugvType->actors);
        break;
    default:
        cgi->Com_Error(ERR_DROP, "E_CreateEmployee: Unknown employee type\n");
    }
 
    cgi->CL_GenerateCharacter(&employee.chr, teamDefName);
    employee.chr.score.rank = CL_GetRankIdx(rank);
 
    cgi->Com_DPrintf(DEBUG_CLIENT, "Generate character for type: %i\n", type);
 
    return &LIST_Add(&ccs.employees[type], employee);
}

bool E_DeleteEmployee (Employee* employee)
{
    employeeType_t type;
 
    if (!employee)
        return false;
 
    type = employee->getType();
 
    /* Fire the employee. This will also:
     * 1) remove him from buildings&work
     * 2) remove his inventory */
 
    if (employee->baseHired) {
        /* make sure that this employee is really unhired */
        employee->transfer = false;
        employee->unhire();
    }
 
    /* Remove the employee from the global list. */
    return cgi->LIST_Remove(&ccs.employees[type], (void*) employee);
}

void E_DeleteAllEmployees (base_t* base)
{
    int i;
 
    for (i = EMPL_SOLDIER; i < MAX_EMPL; i++) {
        const employeeType_t type = (employeeType_t)i;
        E_Foreach(type, employee) {
            if (base == nullptr || employee->isHiredInBase(base))
                E_DeleteEmployee(employee);
        }
    }
}

int E_CountHired (const base_t* const base, employeeType_t type)
{
    int count = 0;
 
    E_Foreach(type, employee) {
        if (!employee->isHired())
            continue;
        if (!base || employee->isHiredInBase(base))
            count++;
    }
    return count;
}

int E_CountHiredRobotByType (const base_t* const base, const ugv_t* ugvType)
{
    int count = 0;
 
    E_Foreach(EMPL_ROBOT, employee) {
        if (!employee->isHired())
            continue;
        if (employee->getUGV() == ugvType && (!base || employee->isHiredInBase(base)))
            count++;
    }
    return count;
}
 

int E_CountAllHired (const base_t* const base, const bool peopleOnly)
{
    if (!base)
        return 0;
 
    int count = 0;
    for (int i = 0; i < MAX_EMPL; i++) {
        const employeeType_t type = (employeeType_t)i;
        if (peopleOnly && i == EMPL_ROBOT)
            continue;
        count += E_CountHired(base, type);
    }
 
    return count;
}

int E_CountUnhired (employeeType_t type)
{
    int count = 0;
 
    E_Foreach(type, employee) {
        if (!employee->isHired())
            count++;
    }
    return count;
}

int E_CountUnhiredRobotsByType (const ugv_t* ugvType)
{
    int count = 0;
 
    E_Foreach(EMPL_ROBOT, employee) {
        if (!employee->isHired() && employee->getUGV() == ugvType)
            count++;
    }
    return count;
}

int E_CountUnassigned (const base_t* const base, employeeType_t type)
{
    if (!base)
        return 0;
 
    int count = 0;
    E_Foreach(type, employee) {
        if (!employee->isHiredInBase(base))
            continue;
        if (!employee->isAssigned())
            count++;
    }
    return count;
}

void E_InitialEmployees (const campaign_t* campaign)
{
    int i;
 
    /* setup initial employee count */
    for (i = 0; i < campaign->soldiers; i++)
        E_CreateEmployee(EMPL_SOLDIER, NAT_GetRandom(), nullptr);
    for (i = 0; i < campaign->scientists; i++)
        E_CreateEmployee(EMPL_SCIENTIST, NAT_GetRandom(), nullptr);
    for (i = 0; i < campaign->workers; i++)
        E_CreateEmployee(EMPL_WORKER, NAT_GetRandom(), nullptr);
    for (i = 0; i < campaign->pilots; i++)
        E_CreateEmployee(EMPL_PILOT, NAT_GetRandom(), nullptr);
    for (i = 0; i < campaign->ugvs; i++) {
        if (frand() > 0.5)
            E_CreateEmployee(EMPL_ROBOT, NAT_GetRandom(), cgi->Com_GetUGVByID("ugv_ares_w"));
        else
            E_CreateEmployee(EMPL_ROBOT, NAT_GetRandom(), cgi->Com_GetUGVByID("ugv_phoenix"));
    }
}
 
#ifdef DEBUG
static void E_ListHired_f (void)
{
    int i;
 
    for (i = 0; i < MAX_EMPL; i++) {
        const employeeType_t emplType = (employeeType_t)i;
        E_Foreach(emplType, employee) {
            cgi->Com_Printf("Employee: %s (ucn: %i) %s at %s\n", E_GetEmployeeString(employee->getType(), 1), employee->chr.ucn,
                employee->chr.name, employee->baseHired->name);
            if (employee->getType() != emplType)
                cgi->Com_Printf("Warning: EmployeeType mismatch: %i != %i\n", emplType, employee->getType());
        }
    }
}

static void CL_DebugNewEmployees_f (void)
{
    nation_t* nation = NAT_GetRandom();
 
    int j;
    for (j = 0; j < 5; j++)
        /* Create a scientist */
        E_CreateEmployee(EMPL_SCIENTIST, nation, nullptr);
 
    for (j = 0; j < 5; j++)
        /* Create a pilot. */
        E_CreateEmployee(EMPL_PILOT, nation, nullptr);
 
    for (j = 0; j < 5; j++)
        /* Create a soldier. */
        E_CreateEmployee(EMPL_SOLDIER, nation, nullptr);
 
    for (j = 0; j < 5; j++)
        /* Create a worker. */
        E_CreateEmployee(EMPL_WORKER, nation, nullptr);
}
#endif

Employee* E_GetEmployeeByTypeFromChrUCN (employeeType_t type, int uniqueCharacterNumber)
{
    E_Foreach(type, employee) {
        if (employee->chr.ucn == uniqueCharacterNumber)
            return employee;
    }
 
    return nullptr;
}

Employee* E_GetEmployeeFromChrUCN (int uniqueCharacterNumber)
{
    int i;
 
    for (i = EMPL_SOLDIER; i < MAX_EMPL; i++) {
        const employeeType_t emplType = (employeeType_t)i;
        Employee* employee = E_GetEmployeeByTypeFromChrUCN(emplType, uniqueCharacterNumber);
        if (employee)
            return employee;
    }
 
    return nullptr;
}
 

bool E_SaveXML (xmlNode_t* p)
{
    int i;
 
    cgi->Com_RegisterConstList(saveEmployeeConstants);
    for (i = 0; i < MAX_EMPL; i++) {
        const employeeType_t emplType = (employeeType_t)i;
        xmlNode_t* snode = cgi->XML_AddNode(p, SAVE_EMPLOYEE_EMPLOYEES);
 
        cgi->XML_AddString(snode, SAVE_EMPLOYEE_TYPE, cgi->Com_GetConstVariable(SAVE_EMPLOYEETYPE_NAMESPACE, emplType));
        E_Foreach(emplType, employee) {
            xmlNode_t* chrNode;
            xmlNode_t* ssnode = cgi->XML_AddNode(snode, SAVE_EMPLOYEE_EMPLOYEE);

            if (employee->baseHired)
                cgi->XML_AddInt(ssnode, SAVE_EMPLOYEE_BASEHIRED, employee->baseHired->idx);
            if (employee->isAssigned())
                cgi->XML_AddBool(ssnode, SAVE_EMPLOYEE_ASSIGNED, employee->isAssigned());
            /* Store the nations identifier string. */
            assert(employee->getNation());
            cgi->XML_AddString(ssnode, SAVE_EMPLOYEE_NATION, employee->getNation()->id);
            /* Store the ugv-type identifier string. (Only exists for EMPL_ROBOT). */
            if (employee->getUGV())
                cgi->XML_AddString(ssnode, SAVE_EMPLOYEE_UGV, employee->getUGV()->id);
            /* Character Data */
            chrNode = cgi->XML_AddNode(ssnode, SAVE_EMPLOYEE_CHR);
            cgi->GAME_SaveCharacter(chrNode, &employee->chr);
        }
    }
    cgi->Com_UnregisterConstList(saveEmployeeConstants);
 
    return true;
}

bool E_LoadXML (xmlNode_t* p)
{
    xmlNode_t* snode;
    bool success = true;
    linkedList_t* lastEmployee[MAX_EMPL];
 
    OBJZERO(lastEmployee);
    cgi->Com_RegisterConstList(saveEmployeeConstants);
    for (snode = cgi->XML_GetNode(p, SAVE_EMPLOYEE_EMPLOYEES); snode;
            snode = cgi->XML_GetNextNode(snode, p, SAVE_EMPLOYEE_EMPLOYEES)) {
        xmlNode_t* ssnode;
        employeeType_t emplType;
        const char* type = cgi->XML_GetString(snode, SAVE_EMPLOYEE_TYPE);
 
        if (!cgi->Com_GetConstIntFromNamespace(SAVE_EMPLOYEETYPE_NAMESPACE, type, (int*) &emplType)) {
            cgi->Com_Printf("Invalid employee type '%s'\n", type);
            success = false;
            break;
        }
 
        for (ssnode = cgi->XML_GetNode(snode, SAVE_EMPLOYEE_EMPLOYEE); ssnode;
                ssnode = cgi->XML_GetNextNode(ssnode, snode, SAVE_EMPLOYEE_EMPLOYEE)) {
            int baseIDX;
            xmlNode_t* chrNode;
 
            /* nation */
            const nation_t* nation = NAT_GetNationByID(cgi->XML_GetString(ssnode, SAVE_EMPLOYEE_NATION));
            if (!nation) {
                cgi->Com_Printf("No nation defined for employee\n");
                success = false;
                break;
            }
            /* UGV-Type */
            const ugv_t* ugv = cgi->Com_GetUGVByIDSilent(cgi->XML_GetString(ssnode, SAVE_EMPLOYEE_UGV));
            Employee e(emplType, nation, ugv);
            /* base */
            assert(B_AtLeastOneExists());   /* Just in case the order is ever changed. */
            baseIDX = cgi->XML_GetInt(ssnode, SAVE_EMPLOYEE_BASEHIRED, -1);
            e.baseHired = B_GetBaseByIDX(baseIDX);
            /* assigned to a building? */
            e.setAssigned(cgi->XML_GetBool(ssnode, SAVE_EMPLOYEE_ASSIGNED, false));
            /* Character Data */
            chrNode = cgi->XML_GetNode(ssnode, SAVE_EMPLOYEE_CHR);
            if (!chrNode) {
                cgi->Com_Printf("No character definition found for employee\n");
                success = false;
                break;
            }
            if (!cgi->GAME_LoadCharacter(chrNode, &e.chr)) {
                cgi->Com_Printf("Error loading character definition for employee\n");
                success = false;
                break;
            }
            if (lastEmployee[emplType] == nullptr)
                lastEmployee[emplType] = LIST_Add(&ccs.employees[emplType], (void*) &e, sizeof(e));
            else
                lastEmployee[emplType] = LIST_Add(&lastEmployee[emplType], (void*) &e, sizeof(e));
            if (lastEmployee[emplType] == nullptr) {
                cgi->Com_Printf("Could not add employee to the game\n");
                success = false;
                break;
            }
        }
        if (!success)
            break;
    }
    cgi->Com_UnregisterConstList(saveEmployeeConstants);
 
    return success;
}

bool E_HireAllowed (const base_t* base)
{
    if (!B_IsUnderAttack(base) && B_GetBuildingStatus(base, B_QUARTERS))
        return true;
    return false;
}

void E_RemoveInventoryFromStorage (Employee* employee)
{
    const character_t* chr = &employee->chr;
 
    assert(employee->baseHired);
 
    const Container* cont = nullptr;
    while ((cont = chr->inv.getNextCont(cont))) {
        Item* item = nullptr;
        while ((item = cont->getNextItem(item))) {
            /* Remove ammo */
            if (item->ammoDef() && item->ammoDef() != item->def())
                B_AddToStorage(employee->baseHired, item->ammoDef(), -1);
            /* Remove Item */
            if (item->def())
                B_AddToStorage(employee->baseHired, item->def(), -1);
        }
    }
}
 
static const cmdList_t debugEmployeeCmds[] = {
#ifdef DEBUG
    {"debug_listhired", E_ListHired_f, "Debug command to list all hired employee"},
    {"debug_addemployees", CL_DebugNewEmployees_f, "Debug function to add 5 new unhired employees of each type"},
#endif
    {nullptr, nullptr, nullptr}
};

void E_InitStartup (void)
{
    E_InitCallbacks();
    cgi->Cmd_TableAddList(debugEmployeeCmds);
}

void E_Shutdown (void)
{
    for (int i = EMPL_SOLDIER; i < MAX_EMPL; i++) {
        const employeeType_t emplType = (employeeType_t)i;
        cgi->LIST_Delete(&ccs.employees[emplType]);
    }
 
    E_ShutdownCallbacks();
    cgi->Cmd_TableRemoveList(debugEmployeeCmds);
}