cl_inventory.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 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 "client.h"
#include "cl_inventory.h"
#include "cl_inventory_callbacks.h"
#include "../shared/parse.h"

const equipDef_t *INV_GetEquipmentDefinitionByID (const char *name)
{
    int i;

    for (i = 0, csi.eds; i < csi.numEDs; i++)
        if (!strcmp(name, csi.eds[i].name))
            return &csi.eds[i];

    Com_Error(ERR_DROP, "Could not find equipment %s", name);
}

qboolean INV_MoveItem (inventory_t* inv, const invDef_t * toContainer, int px, int py,
    const invDef_t * fromContainer, invList_t *fItem)
{
    int moved;

    if (px >= SHAPE_BIG_MAX_WIDTH || py >= SHAPE_BIG_MAX_HEIGHT)
        return qfalse;

    if (!fItem)
        return qfalse;

    /* move the item */
    moved = cls.i.MoveInInventory(&cls.i, inv, fromContainer, fItem, toContainer, px, py, NULL, NULL);

    switch (moved) {
    case IA_MOVE:
    case IA_ARMOUR:
        return qtrue;
    default:
        return qfalse;
    }
}

void INV_LoadWeapon (invList_t *weapon, inventory_t *inv, const invDef_t *srcContainer, const invDef_t *destContainer)
{
    int equipType;
    invList_t *ic = NULL;
    int i = 0;

    assert(weapon);

    equipType = INV_GetFilterFromItem(weapon->item.t);
    /* search an ammo */
    while (i < weapon->item.t->numAmmos && !ic) {
        ic = INVSH_SearchInInventoryWithFilter(inv, srcContainer, NONE, NONE, weapon->item.t->ammos[i], equipType);
        i++;
    }
    if (ic)
        INV_MoveItem(inv, destContainer, weapon->x, weapon->y, srcContainer, ic);
}

qboolean INV_UnloadWeapon (invList_t *weapon, inventory_t *inv, const invDef_t *container)
{
    assert(weapon);
    if (container && inv) {
        const item_t item = {NONE_AMMO, NULL, weapon->item.m, 0, 0};
        if (cls.i.AddToInventory(&cls.i, inv, item, container, NONE, NONE, 1) != NULL) {
            weapon->item.m = NULL;
            weapon->item.a = 0;
            return qtrue;
        }
    }
    return qfalse;
}

#ifdef DEBUG

static void INV_InventoryList_f (void)
{
    int i;

    for (i = 0; i < csi.numODs; i++) {
        objDef_t *od = INVSH_GetItemByIDX(i);
        Com_Printf("Item: %s\n", od->id);
        Com_Printf("... name          -> %s\n", od->name);
        Com_Printf("... type          -> %s\n", od->type);
        Com_Printf("... category      -> %i\n", od->animationIndex);
        Com_Printf("... weapon        -> %i\n", od->weapon);
        Com_Printf("... holdtwohanded -> %i\n", od->holdTwoHanded);
        Com_Printf("... firetwohanded -> %i\n", od->fireTwoHanded);
        Com_Printf("... thrown        -> %i\n", od->thrown);
        Com_Printf("... usable for weapon (if type is ammo):\n");
        for (i = 0; i < od->numWeapons; i++) {
            if (od->weapons[i])
                Com_Printf("    ... %s\n", od->weapons[i]->name);
        }
        Com_Printf("\n");
    }
}
#endif

static qboolean INV_EquipmentDefSanityCheck (void)
{
    int i, j;
    int sum;
    qboolean result = qtrue;

    for (i = 0; i < csi.numEDs; i++) {
        const equipDef_t const *ed = &csi.eds[i];
        /* only check definitions used for generating teams */
        if (strncmp(ed->name, "alien", 5) && strncmp(ed->name, "phalanx", 7))
            continue;

        /* Check primary */
        sum = 0;
        for (j = 0; j < csi.numODs; j++) {
            const objDef_t const *obj = INVSH_GetItemByIDX(j);
            if (obj->weapon && obj->fireTwoHanded
             && (INV_ItemMatchesFilter(obj, FILTER_S_PRIMARY) || INV_ItemMatchesFilter(obj, FILTER_S_HEAVY)))
                sum += ed->numItems[j];
        }
        if (sum > 100) {
            Com_Printf("INV_EquipmentDefSanityCheck: Equipment Def '%s' has a total probability for primary weapons greater than 100\n", ed->name);
            result = qfalse;
        }

        /* Check secondary */
        sum = 0;
        for (j = 0; j < csi.numODs; j++) {
            const objDef_t const *obj = INVSH_GetItemByIDX(j);
            if (obj->weapon && obj->reload && !obj->deplete && INV_ItemMatchesFilter(obj, FILTER_S_SECONDARY))
                sum += ed->numItems[j];
        }
        if (sum > 100) {
            Com_Printf("INV_EquipmentDefSanityCheck: Equipment Def '%s' has a total probability for secondary weapons greater than 100\n", ed->name);
            result = qfalse;
        }

        /* Check armour */
        sum = 0;
        for (j = 0; j < csi.numODs; j++) {
            const objDef_t const *obj = INVSH_GetItemByIDX(j);
            if (INV_ItemMatchesFilter(obj, FILTER_S_ARMOUR))
                sum += ed->numItems[j];
        }
        if (sum > 100) {
            Com_Printf("INV_EquipmentDefSanityCheck: Equipment Def '%s' has a total probability for armours greater than 100\n", ed->name);
            result = qfalse;
        }

        /* Don't check misc: the total probability can be greater than 100 */
    }

    return result;
}

itemFilterTypes_t INV_GetFilterFromItem (const objDef_t *obj)
{
    assert(obj);

    /* heavy weapons may be primary too. check heavy first */
    if (obj->isHeavy)
        return FILTER_S_HEAVY;
    else if (obj->isPrimary)
        return FILTER_S_PRIMARY;
    else if (obj->isSecondary)
        return FILTER_S_SECONDARY;
    else if (obj->isMisc)
        return FILTER_S_MISC;
    else if (INV_IsArmour(obj))
        return FILTER_S_ARMOUR;

    Sys_Error("INV_GetFilterFromItem: unknown filter category for item '%s'", obj->id);
}

qboolean INV_ItemMatchesFilter (const objDef_t *obj, const itemFilterTypes_t filterType)
{
    int i;

    if (!obj)
        return qfalse;

    switch (filterType) {
    case FILTER_S_PRIMARY:
        if (obj->isPrimary && !obj->isHeavy)
            return qtrue;

        /* Check if one of the items that uses this ammo matches this filter type. */
        for (i = 0; i < obj->numWeapons; i++) {
            if (obj->weapons[i] && obj->weapons[i] != obj && INV_ItemMatchesFilter(obj->weapons[i], filterType))
                return qtrue;
        }
        break;

    case FILTER_S_SECONDARY:
        if (obj->isSecondary && !obj->isHeavy)
            return qtrue;

        /* Check if one of the items that uses this ammo matches this filter type. */
        for (i = 0; i < obj->numWeapons; i++) {
            if (obj->weapons[i] && obj->weapons[i] != obj && INV_ItemMatchesFilter(obj->weapons[i], filterType))
                return qtrue;
        }
        break;

    case FILTER_S_HEAVY:
        if (obj->isHeavy)
            return qtrue;

        /* Check if one of the items that uses this ammo matches this filter type. */
        for (i = 0; i < obj->numWeapons; i++) {
            if (obj->weapons[i] && obj->weapons[i] != obj && INV_ItemMatchesFilter(obj->weapons[i], filterType))
                return qtrue;
        }
        break;

    case FILTER_S_ARMOUR:
        return INV_IsArmour(obj);

    case FILTER_S_MISC:
        return obj->isMisc;

    case FILTER_CRAFTITEM:
        return INV_IsCraftItem(obj);

    case FILTER_UGVITEM:
        return obj->isUGVitem;

    case FILTER_DUMMY:
        return obj->isDummy;

    case FILTER_AIRCRAFT:
        return !strcmp(obj->type, "aircraft");

    case FILTER_DISASSEMBLY:
        break;

    case MAX_SOLDIER_FILTERTYPES:
    case MAX_FILTERTYPES:
    case FILTER_ENSURE_32BIT:
        Com_Printf("INV_ItemMatchesFilter: Unknown filter type for items: %i\n", filterType);
        break;
    }

    /* The given filter type is unknown. */
    return qfalse;
}

invList_t *INVSH_SearchInInventoryWithFilter (const inventory_t* const i, const invDef_t * container, int x, int y, objDef_t *item,  const itemFilterTypes_t filterType)
{
    invList_t *ic;

    if (item == NULL)
        return NULL;

    for (ic = i->c[container->id]; ic; ic = ic->next) {
        /* Search only in the items that could get displayed. */
        if (ic && ic->item.t && (INV_ItemMatchesFilter(ic->item.t, filterType) || filterType == MAX_FILTERTYPES)) {
            /* We search _everything_, no matter what location it is (i.e. x/y are ignored). */
            if (item == ic->item.t)
                return ic;
        }
    }

    /* No item with these coordinates (or matching item) found. */
    return NULL;
}

static const char *filterTypeNames[MAX_FILTERTYPES] = {
    "primary",      
    "secondary",    
    "heavy",        
    "misc",         
    "armour",       
    "",             
    "craftitem",    
    "ugvitem",      
    "aircraft",     
    "dummy",        
    "disassembly"   
};
CASSERT(lengthof(filterTypeNames) == MAX_FILTERTYPES);

itemFilterTypes_t INV_GetFilterTypeID (const char * filterTypeID)
{
    itemFilterTypes_t i;

    if (!filterTypeID)
        return MAX_FILTERTYPES;

    /* default filter type is primary */
    if (filterTypeID[0] == '\0')
        return FILTER_S_PRIMARY;

    for (i = 0; i < MAX_FILTERTYPES; i++) {
        if (filterTypeNames[i] && !strcmp(filterTypeNames[i], filterTypeID))
            return i;
    }

    /* No matching filter type found, returning max value. */
    return MAX_FILTERTYPES;
}

const char *INV_GetFilterType (const int id)
{
    assert(id >= 0);
    assert(id < MAX_FILTERTYPES);
    return filterTypeNames[id];
}

void INV_InitStartup (void)
{
#ifdef DEBUG
    Cmd_AddCommand("debug_listinventory", INV_InventoryList_f, "Print the current inventory to the game console");
#endif
    INV_InitCallbacks();

    INV_EquipmentDefSanityCheck();
}