itemcargo.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 "itemcargo.h"
 
#define SAVE_ITEMCARGO_ITEM "item"
#define SAVE_ITEMCARGO_ITEMID "itemid"
#define SAVE_ITEMCARGO_AMOUNT "amount"
#define SAVE_ITEMCARGO_LOOSEAMOUNT "looseamount"

bool ItemCargo::add(const objDef_t* od, int amount, int looseAmount = 0)
{
    if (!od)
        return false;
    if (amount == 0 && looseAmount == 0)
        return true;
 
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        if (item->objDef != od)
            continue;
 
        if (amount + item->amount < 0)
            return false;
        if (looseAmount + item->looseAmount < 0)
            return false;
 
        item->amount += amount;
        item->looseAmount += looseAmount;
        if (od->ammo > 0 && item->looseAmount >= od->ammo) {
            const int magazine = item->looseAmount / od->ammo;
            this->add(od, magazine, -magazine * od->ammo);
        }
 
        if (item->amount == 0 && item->looseAmount == 0)
            cgi->LIST_Remove(&this->cargo, (void*)item);
 
        return true;
    }
 
    if (amount < 0 || looseAmount < 0)
        return false;
 
    itemCargo_t cargoItem = { od, amount, looseAmount };
 
    if (cgi->LIST_Add(&this->cargo, (const void*)&cargoItem, sizeof(cargoItem))) {
        return true;
    }
 
    return false;
}

bool ItemCargo::add(const char* objDefId, int amount, int looseAmount = 0)
{
    if (!objDefId)
        return false;
    const objDef_t* od = INVSH_GetItemByIDSilent(objDefId);
    if (!od)
        return false;
    return this->add(od, amount, looseAmount);
}

void ItemCargo::empty (void)
{
    cgi->LIST_Delete(&(this->cargo));
}

bool ItemCargo::isEmpty (void) const
{
    return (this->cargo == nullptr);
}

itemCargo_t* ItemCargo::get(const objDef_t* od) const
{
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        if (item->objDef == od)
            return item;
    }
    return nullptr;
}

int ItemCargo::getAmount(const objDef_t* od) const
{
    const itemCargo_t* const item = this->get(od);
    if (item == nullptr)
        return 0;
    return item->amount;
}

int ItemCargo::getLooseAmount(const objDef_t* od) const
{
    const itemCargo_t* const item = this->get(od);
    if (item == nullptr)
        return 0;
    return item->looseAmount;
}

linkedList_t* ItemCargo::list(void) const
{
    linkedList_t* listing = nullptr;
 
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        if (!cgi->LIST_Add(&listing, (void*)item, sizeof(*item))) {
            cgi->LIST_Delete(&listing);
            return nullptr;
        }
    }
    return listing;
}

int ItemCargo::count(void) const
{
    int count = 0;
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        count += item->amount;
    }
    return count;
}

int ItemCargo::size(void) const
{
    int size = 0;
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        size += item->amount * item->objDef->size;
    }
    return size;
}

bool ItemCargo::load(xmlNode_t* root)
{
    if (!root)
        return false;
 
    for (xmlNode_t* itemNode = cgi->XML_GetNode(root, SAVE_ITEMCARGO_ITEM); itemNode;
        itemNode = cgi->XML_GetNextNode(itemNode, root, SAVE_ITEMCARGO_ITEM))
    {
        const char* objDefId = cgi->XML_GetString(itemNode, SAVE_ITEMCARGO_ITEMID);
        const int amount = cgi->XML_GetInt(itemNode, SAVE_ITEMCARGO_AMOUNT, 0);
        const int looseAmount = cgi->XML_GetInt(itemNode, SAVE_ITEMCARGO_LOOSEAMOUNT, 0);
        if (!add(objDefId, amount, looseAmount))
            cgi->Com_Printf("ItemCargo::load: Could add items to cargo: %s, %d, %d\n", objDefId, amount, looseAmount);
    }
    return true;
}

bool ItemCargo::save(xmlNode_t* root) const
{
    if (!root)
        return false;
    LIST_Foreach(this->cargo, itemCargo_t, item) {
        xmlNode_t* itemNode = cgi->XML_AddNode(root, SAVE_ITEMCARGO_ITEM);
        if (!itemNode)
            return false;
        cgi->XML_AddString(itemNode, SAVE_ITEMCARGO_ITEMID, item->objDef->id);
        cgi->XML_AddIntValue(itemNode, SAVE_ITEMCARGO_AMOUNT, item->amount);
        cgi->XML_AddIntValue(itemNode, SAVE_ITEMCARGO_LOOSEAMOUNT, item->looseAmount);
    }
    return true;
}

ItemCargo::ItemCargo(void) : cargo (nullptr)
{
}

ItemCargo::ItemCargo(ItemCargo& itemCargo) : cargo (nullptr)
{
    linkedList_t* list = itemCargo.list();
 
    LIST_Foreach(list, itemCargo_t, cargoItem) {
        cgi->LIST_Add(&this->cargo, (void*)cargoItem, sizeof(*cargoItem));
    }
    cgi->LIST_Delete(&list);
}

ItemCargo::~ItemCargo(void)
{
    cgi->LIST_Delete(&this->cargo);
}