cp_aliencont.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 "cp_campaign.h"
#include "cp_capacity.h"
#include "cp_aliencont_callbacks.h"
#include "save/save_aliencont.h"
#include "aliencargo.h"
#include "aliencontainment.h"


bool AL_AddAlienTypeToAircraftCargo (aircraft_t* aircraft, const teamDef_t* teamDef, int amount, bool dead)
{
    if (aircraft->alienCargo == nullptr)
        aircraft->alienCargo = new AlienCargo();
    if (aircraft->alienCargo == nullptr)
        return false;
 
    if (dead)
        return aircraft->alienCargo->add(teamDef, 0, amount);
    return aircraft->alienCargo->add(teamDef, amount, 0);
}


void AL_AddAliens (aircraft_t* aircraft)
{
    if (!aircraft)
        return;
    if (!aircraft->alienCargo)
        return;
    if (!aircraft->homebase) {
        cgi->Com_Printf("AL_AddAliens: Aircraft %s (idx: %d) has no base, alienCargo destroyed\n", aircraft->name, aircraft->idx);
        delete aircraft->alienCargo;
        aircraft->alienCargo = nullptr;
        return;
    }
 
    if (aircraft->homebase->alienContainment == nullptr)
        aircraft->homebase->alienContainment = new AlienContainment(CAP_Get(aircraft->homebase, CAP_ALIENS), nullptr);
 
    AlienContainment* cont = aircraft->homebase->alienContainment;
    if (!cont)
        return;
 
    bool messageSent = false;
    linkedList_t* cargo = aircraft->alienCargo->list();
    LIST_Foreach(cargo, alienCargo_t, item) {
        const bool lifeSupported = AlienContainment::isLifeSupported(item->teamDef);
 
        if (!lifeSupported) {
            cont->add(item->teamDef, 0, item->alive + item->dead);
            aircraft->alienCargo->add(item->teamDef, -item->alive, -item->dead);
 
            ccs.campaignStats.killedAliens += item->dead + item->alive;
            if (item->alive > 0) {
                CP_TriggerEvent(CAPTURED_ALIENS_DIED, nullptr);
                /* only once */
                if (!messageSent) {
                    MS_AddNewMessage(_("Notice"), _("You can't hold live aliens yet. Aliens died."), MSG_DEATH);
                    messageSent = true;
                }
            }
        } else {
            cont->add(item->teamDef, item->alive, item->dead);
            aircraft->alienCargo->add(item->teamDef, -item->alive, -item->dead);
 
            ccs.campaignStats.killedAliens += item->dead;
            ccs.campaignStats.capturedAliens += item->alive;
            if (item->alive > 0) {
                CP_TriggerEvent(CAPTURED_ALIENS, nullptr);
                if (!messageSent) {
                    MS_AddNewMessage(_("Notice"), _("You've captured new aliens."));
                    messageSent = true;
                }
            }
        }
    }
    cgi->LIST_Delete(&cargo);
}

int AL_CountAll (void)
{
    int amount = 0;
    base_t* base = nullptr;
 
    while ((base = B_GetNext(base)) != nullptr) {
        if (base->alienContainment)
            amount += base->alienContainment->getAlive();
    }
    return amount;
}
 
#ifdef DEBUG
static void AC_AddOne_f (void)
{
    if (cgi->Cmd_Argc() < 3) {
        cgi->Com_Printf("Usage: %s <baseIDX> <alientype> [dead:true|false]\n", cgi->Cmd_Argv(0));
        return;
    }
    base_t* base = B_GetFoundedBaseByIDX(atoi(cgi->Cmd_Argv(1)));
    if (!base) {
        cgi->Com_Printf("%s: Invalid base idx: %s\n", cgi->Cmd_Argv(0), cgi->Cmd_Argv(1));
        return;
    }
    if (!base->alienContainment) {
        cgi->Com_Printf("%s: B base %d has no alien containment\n", cgi->Cmd_Argv(0), base->idx);
        return;
    }
    const char* alienName = cgi->Cmd_Argv(2);
    if (!alienName)
        return;
 
    bool updateAlive = true;
    if (cgi->Cmd_Argc() == 4)
        updateAlive = cgi->Com_ParseBoolean(cgi->Cmd_Argv(3));
 
    if (updateAlive)
        base->alienContainment->add(alienName, 1, 0);
    else
        base->alienContainment->add(alienName, 0, 1);
}
#endif

void AC_InitStartup (void)
{
    /* add commands */
#ifdef DEBUG
    cgi->Cmd_AddCommand("debug_addalientocont", AC_AddOne_f, "Add one alien of a given type");
#endif
    AC_InitCallbacks();
}

bool AC_LoadXML (xmlNode_t* parent)
{
    xmlNode_t* aliencont = cgi->XML_GetNode(parent, SAVE_ALIENCONT_ALIENCONT);
    if (!aliencont)
        return true;
    FOREACH_XMLNODE(contNode, aliencont, SAVE_ALIENCONT_CONT) {
        const int baseIdx = cgi->XML_GetInt(contNode, SAVE_ALIENCONT_BASEIDX, MAX_BASES);
        base_t* base = B_GetFoundedBaseByIDX(baseIdx);
        if (!base) {
            cgi->Com_Printf("AC_LoadXML: Invalid base idx '%i'\n", baseIdx);
            continue;
        }
 
        FOREACH_XMLNODE(alienNode, contNode, SAVE_ALIENCONT_ALIEN) {
            const char* teamId = cgi->XML_GetString(alienNode, SAVE_ALIENCONT_TEAMID);
            const int alive = cgi->XML_GetInt(alienNode, SAVE_ALIENCONT_AMOUNTALIVE, 0);
            const int dead = cgi->XML_GetInt(alienNode, SAVE_ALIENCONT_AMOUNTDEAD, 0);
 
            if (alive == 0 && dead == 0)
                continue;
 
            if (!base->alienContainment)
                base->alienContainment = new AlienContainment(CAP_Get(base, CAP_ALIENS), nullptr);
 
            base->alienContainment->add(teamId, alive, dead);
        }
    }
 
    return true;
}

bool AC_ContainmentAllowed (const base_t* base)
{
    return base->alienContainment != nullptr;
}