inv_shared.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 "q_shared.h"

static csi_t *CSI;

void INVSH_InitCSI (csi_t * import)
{
    CSI = import;
}

qboolean INV_IsFloorDef (const invDef_t* invDef)
{
    return invDef->id == CSI->idFloor;
}

qboolean INV_IsRightDef (const invDef_t* invDef)
{
    return invDef->id == CSI->idRight;
}

qboolean INV_IsLeftDef (const invDef_t* invDef)
{
    return invDef->id == CSI->idLeft;
}

qboolean INV_IsEquipDef (const invDef_t* invDef)
{
    return invDef->id == CSI->idEquip;
}

qboolean INV_IsArmourDef (const invDef_t* invDef)
{
    return invDef->id == CSI->idArmour;
}

invList_t* INVSH_HasArmour (const inventory_t *inv)
{
    return inv->c[CSI->idArmour];
}

static int cacheCheckToInventory = INV_DOES_NOT_FIT;

static qboolean INVSH_CheckShapeCollision (const uint32_t *shape, const uint32_t itemShape, const int x, const int y)
{
    int i;

    /* Negative positions not allowed (all items are supposed to have at least one bit set in the first row and column) */
    if (x < 0 || y < 0) {
        Com_DPrintf(DEBUG_SHARED, "INVSH_CheckShapeCollision: x or y value negative: x=%i y=%i!\n", x, y);
        return qtrue;
    }

    for (i = 0; i < SHAPE_SMALL_MAX_HEIGHT; i++) {
        /* 0xFF is the length of one row in a "small shape" i.e. SHAPE_SMALL_MAX_WIDTH */
        const int itemRow = (itemShape >> (i * SHAPE_SMALL_MAX_WIDTH)) & 0xFF;
        /* Result has to be limited to 32bit (SHAPE_BIG_MAX_WIDTH) */
        const uint32_t itemRowShifted = itemRow << x;

        /* Check x maximum. */
        if (itemRowShifted >> x != itemRow)
            /* Out of bounds (32bit; a few bits of this row in itemShape were truncated) */
            return qtrue;

        /* Check y maximum. */
        if (y + i >= SHAPE_BIG_MAX_HEIGHT && itemRow)
            /* This row (row "i" in itemShape) is outside of the max. bound and has bits in it. */
            return qtrue;

        /* Check for collisions of the item with the big mask. */
        if (itemRowShifted & shape[y + i])
            return qtrue;
    }

    return qfalse;
}

static qboolean INVSH_CheckToInventory_shape (const inventory_t * const i, const invDef_t * container, const uint32_t itemShape, const int x, const int y, const invList_t *ignoredItem)
{
    invList_t *ic;
    static uint32_t mask[SHAPE_BIG_MAX_HEIGHT];

    assert(container);

    if (container->scroll)
        Sys_Error("INVSH_CheckToInventory_shape: No scrollable container will ever use this. This type does not support grid-packing!");

    /* check bounds */
    if (x < 0 || y < 0 || x >= SHAPE_BIG_MAX_WIDTH || y >= SHAPE_BIG_MAX_HEIGHT)
        return qfalse;

    if (!cacheCheckToInventory) {
        int j;
        /* extract shape info */
        for (j = 0; j < SHAPE_BIG_MAX_HEIGHT; j++)
            mask[j] = ~container->shape[j];

        /* Add other items to mask. (i.e. merge their shapes at their location into the generated mask) */
        for (ic = i->c[container->id]; ic; ic = ic->next) {
            if (ignoredItem == ic)
                continue;

            if (ic->item.rotated)
                INVSH_MergeShapes(mask, INVSH_ShapeRotate(ic->item.t->shape), ic->x, ic->y);
            else
                INVSH_MergeShapes(mask, ic->item.t->shape, ic->x, ic->y);
        }
    }

    /* Test for collisions with newly generated mask. */
    if (INVSH_CheckShapeCollision(mask, itemShape, x, y))
        return qfalse;

    /* Everything ok. */
    return qtrue;
}

int INVSH_CheckToInventory (const inventory_t * const i, const objDef_t *od, const invDef_t * container, const int x, const int y, const invList_t *ignoredItem)
{
    int fits;
    assert(i);
    assert(container);
    assert(od);

    /* armour vs item */
    if (INV_IsArmour(od)) {
        if (!container->armour && !container->all) {
            return INV_DOES_NOT_FIT;
        }
    } else if (!od->extension && container->extension) {
        return INV_DOES_NOT_FIT;
    } else if (!od->headgear && container->headgear) {
        return INV_DOES_NOT_FIT;
    } else if (container->armour) {
        return INV_DOES_NOT_FIT;
    }

    /* twohanded item */
    if (od->holdTwoHanded) {
        if ((INV_IsRightDef(container) && i->c[CSI->idLeft]) || INV_IsLeftDef(container))
            return INV_DOES_NOT_FIT;
    }

    /* left hand is busy if right wields twohanded */
    if (INV_IsLeftDef(container)) {
        if (i->c[CSI->idRight] && i->c[CSI->idRight]->item.t->holdTwoHanded)
            return INV_DOES_NOT_FIT;

        /* can't put an item that is 'fireTwoHanded' into the left hand */
        if (od->fireTwoHanded)
            return INV_DOES_NOT_FIT;
    }

    /* Single item containers, e.g. hands, extension or headgear. */
    if (container->single) {
        if (i->c[container->id]) {
            /* There is already an item. */
            return INV_DOES_NOT_FIT;
        } else {
            fits = INV_DOES_NOT_FIT; /* equals 0 */

            if (INVSH_CheckToInventory_shape(i, container, od->shape, x, y, ignoredItem))
                fits |= INV_FITS;
            if (INVSH_CheckToInventory_shape(i, container, INVSH_ShapeRotate(od->shape), x, y, ignoredItem))
                fits |= INV_FITS_ONLY_ROTATED;

            if (fits != INV_DOES_NOT_FIT)
                return fits;    
            Com_DPrintf(DEBUG_SHARED, "INVSH_CheckToInventory: INFO: Moving to 'single' container but item would not fit normally.\n");
            return INV_FITS; 
        }
    }

    /* Scrolling container have endless room, the item always fits. */
    if (container->scroll)
        return INV_FITS;

    /* Check 'grid' containers. */
    fits = INV_DOES_NOT_FIT; /* equals 0 */
    if (INVSH_CheckToInventory_shape(i, container, od->shape, x, y, ignoredItem))
        fits |= INV_FITS;
    if (!INV_IsEquipDef(container) && !INV_IsFloorDef(container)
    && INVSH_CheckToInventory_shape(i, container, INVSH_ShapeRotate(od->shape), x, y, ignoredItem))
        fits |= INV_FITS_ONLY_ROTATED;

    return fits;    
}

qboolean INVSH_CompareItem (item_t *item1, item_t *item2)
{
    if (item1->t == item2->t && item1->m == item2->m && item1->a == item2->a)
        return qtrue;

    return qfalse;
}

static qboolean INVSH_ShapeCheckPosition (const invList_t *ic, const int x, const int y)
{
    assert(ic);

    /* Check if the position is inside the shape (depending on rotation value) of the item. */
    if (ic->item.rotated) {
        if (((INVSH_ShapeRotate(ic->item.t->shape) >> (x - ic->x) >> (y - ic->y) * SHAPE_SMALL_MAX_WIDTH)) & 1)
            return qtrue;
    } else {
        if (((ic->item.t->shape >> (x - ic->x) >> (y - ic->y) * SHAPE_SMALL_MAX_WIDTH)) & 1)
            return qtrue;
    }

    /* Position is out of bounds or position not inside item-shape. */
    return qfalse;
}

void INVSH_GetFirstShapePosition (const invList_t *ic, int* const x, int* const y)
{
    int tempX, tempY;

    assert(ic);

    for (tempX = 0; tempX < SHAPE_SMALL_MAX_HEIGHT; tempX++)
        for (tempY = 0; tempY < SHAPE_SMALL_MAX_HEIGHT; tempY++)
            if (INVSH_ShapeCheckPosition(ic, ic->x + tempX, ic->y + tempY)) {
                *x = tempX;
                *y = tempY;
                return;
            }

    *x = *y = NONE;
}

qboolean INVSH_ExistsInInventory (const inventory_t* const inv, const invDef_t * container, item_t item)
{
    invList_t *ic;

    for (ic = inv->c[container->id]; ic; ic = ic->next)
        if (INVSH_CompareItem(&ic->item, &item)) {
            return qtrue;
        }

    return qfalse;
}

qboolean INV_IsCraftItem (const objDef_t *obj)
{
    return obj->craftitem.type != MAX_ACITEMS && !obj->isDummy;
}

qboolean INV_IsBaseDefenceItem (const objDef_t *obj)
{
    return obj->craftitem.type != MAX_ACITEMS && obj->isDummy;
}

invList_t *INVSH_SearchInInventory (const inventory_t* const i, const invDef_t * container, const int x, const int y)
{
    invList_t *ic;

    assert(container);

    /* Only a single item. */
    if (container->single)
        return i->c[container->id];

    if (container->scroll)
        Sys_Error("INVSH_SearchInInventory: Scrollable containers (%i:%s) are not supported by this function.\nUse INV_SearchInScrollableContainer instead!",
                container->id, container->name);

    /* More than one item - search for the item that is located at location x/y in this container. */
    for (ic = i->c[container->id]; ic; ic = ic->next)
        if (INVSH_ShapeCheckPosition(ic, x, y))
            return ic;

    /* Found nothing. */
    return NULL;
}

void INVSH_FindSpace (const inventory_t* const inv, const item_t *item, const invDef_t * container, int* const px, int* const py, const invList_t *ignoredItem)
{
    int x, y;

    assert(inv);
    assert(container);
    assert(!cacheCheckToInventory);

    /* Scrollable container always have room. We return a dummy location. */
    if (container->scroll) {
        *px = *py = 0;
        return;
    }

    for (y = 0; y < SHAPE_BIG_MAX_HEIGHT; y++) {
        for (x = 0; x < SHAPE_BIG_MAX_WIDTH; x++) {
            const int checkedTo = INVSH_CheckToInventory(inv, item->t, container, x, y, ignoredItem);
            if (checkedTo) {
                cacheCheckToInventory = INV_DOES_NOT_FIT;
                *px = x;
                *py = y;
                return;
            } else {
                cacheCheckToInventory = INV_FITS;
            }
        }
    }
    cacheCheckToInventory = INV_DOES_NOT_FIT;

#ifdef PARANOID
    Com_DPrintf(DEBUG_SHARED, "INVSH_FindSpace: no space for %s: %s in %s\n",
        item->t->type, item->t->id, container->name);
#endif
    *px = *py = NONE;
}

objDef_t *INVSH_GetItemByIDSilent (const char *id)
{
    int i;

    if (!id)
        return NULL;
    for (i = 0; i < CSI->numODs; i++) { /* i = item index */
        objDef_t *item = &CSI->ods[i];
        if (!strcmp(id, item->id)) {
            return item;
        }
    }
    return NULL;
}

objDef_t *INVSH_GetItemByIDX (int index)
{
    if (index == NONE)
        return NULL;

    if (index < 0 || index >= CSI->numODs)
        Sys_Error("Invalid object index given: %i", index);

    return &CSI->ods[index];
}

objDef_t *INVSH_GetItemByID (const char *id)
{
    objDef_t *od = INVSH_GetItemByIDSilent(id);
    if (!od)
        Com_Printf("INVSH_GetItemByID: Item \"%s\" not found.\n", id);

    return od;
}

invDef_t *INVSH_GetInventoryDefinitionByID (const char *id)
{
    containerIndex_t i;
    invDef_t *container;

    for (i = 0, container = CSI->ids; i < CSI->numIDs; container++, i++)
        if (!strcmp(id, container->name))
            return container;

    return NULL;
}

qboolean INVSH_LoadableInWeapon (const objDef_t *od, const objDef_t *weapon)
{
    int i;
    qboolean usable = qfalse;

#ifdef DEBUG
    if (!od) {
        Com_DPrintf(DEBUG_SHARED, "INVSH_LoadableInWeapon: No pointer given for 'od'.\n");
        return qfalse;
    }
    if (!weapon) {
        Com_DPrintf(DEBUG_SHARED, "INVSH_LoadableInWeapon: No weapon pointer given.\n");
        return qfalse;
    }
#endif

    if (od && od->numWeapons == 1 && od->weapons[0] && od->weapons[0] == od) {
        /* The weapon is only linked to itself. */
        return qfalse;
    }

    for (i = 0; i < od->numWeapons; i++) {
#ifdef DEBUG
        if (!od->weapons[i]) {
            Com_DPrintf(DEBUG_SHARED, "INVSH_LoadableInWeapon: No weapon pointer set for the %i. entry found in item '%s'.\n", i, od->id);
            break;
        }
#endif
        if (weapon == od->weapons[i]) {
            usable = qtrue;
            break;
        }
    }

    return usable;
}

/*
===============================
FIREMODE MANAGEMENT FUNCTIONS
===============================
*/

const fireDef_t* FIRESH_GetFiredef (const objDef_t *obj, const weaponFireDefIndex_t weapFdsIdx, const fireDefIndex_t fdIdx)
{
    if (weapFdsIdx < 0 || weapFdsIdx >= MAX_WEAPONS_PER_OBJDEF)
        Sys_Error("FIRESH_GetFiredef: weapFdsIdx out of bounds [%i] for item '%s'", weapFdsIdx, obj->id);
    if (fdIdx < 0 || fdIdx >= MAX_FIREDEFS_PER_WEAPON)
        Sys_Error("FIRESH_GetFiredef: fdIdx out of bounds [%i] for item '%s'", fdIdx, obj->id);
    return &obj->fd[weapFdsIdx & (MAX_WEAPONS_PER_OBJDEF - 1)][fdIdx & (MAX_FIREDEFS_PER_WEAPON - 1)];
}

const fireDef_t *FIRESH_FiredefForWeapon (const item_t *item)
{
    int i;
    const objDef_t *ammo = item->m;
    const objDef_t *weapon = item->t;

    /* this weapon does not use ammo, check for
     * existing firedefs in the weapon. */
    if (weapon->numWeapons > 0)
        ammo = item->t;

    if (!ammo)
        return NULL;

    for (i = 0; i < ammo->numWeapons; i++) {
        if (weapon == ammo->weapons[i])
            return &ammo->fd[i][0];
    }

    return NULL;
}

const objDef_t* INVSH_HasReactionFireEnabledWeapon (const invList_t *invList)
{
    if (!invList)
        return NULL;

    while (invList) {
        if (invList->item.t) {
            const fireDef_t *fd = FIRESH_FiredefForWeapon(&invList->item);
            if (fd && fd->reaction)
                return invList->item.t;
        }
        invList = invList->next;
    }

    return NULL;
}

void INVSH_MergeShapes (uint32_t *shape, const uint32_t itemShape, const int x, const int y)
{
    int i;

    for (i = 0; (i < SHAPE_SMALL_MAX_HEIGHT) && (y + i < SHAPE_BIG_MAX_HEIGHT); i++)
        shape[y + i] |= ((itemShape >> i * SHAPE_SMALL_MAX_WIDTH) & 0xFF) << x;
}

qboolean INVSH_CheckShape (const uint32_t *shape, const int x, const int y)
{
    const uint32_t row = shape[y];
    int position = pow(2, x);

    if (y >= SHAPE_BIG_MAX_HEIGHT || x >= SHAPE_BIG_MAX_WIDTH || x < 0 || y < 0) {
        Com_Printf("INVSH_CheckShape: Bad x or y value: (x=%i, y=%i)\n", x, y);
        return qfalse;
    }

    if ((row & position) == 0)
        return qfalse;
    else
        return qtrue;
}

static qboolean INVSH_CheckShapeSmall (const uint32_t shape, const int x, const int y)
{
    if (y >= SHAPE_BIG_MAX_HEIGHT || x >= SHAPE_BIG_MAX_WIDTH || x < 0 || y < 0) {
        Com_Printf("INVSH_CheckShapeSmall: Bad x or y value: (x=%i, y=%i)\n", x, y);
        return qfalse;
    }

    return shape & (0x01 << (y * SHAPE_SMALL_MAX_WIDTH + x));
}

int INVSH_ShapeSize (const uint32_t shape)
{
    int bitCounter = 0;
    int i;

    for (i = 0; i < SHAPE_SMALL_MAX_HEIGHT * SHAPE_SMALL_MAX_WIDTH; i++)
        if (shape & (1 << i))
            bitCounter++;

    return bitCounter;
}

static uint32_t INVSH_ShapeSetBit (uint32_t shape, const int x, const int y)
{
    if (x >= SHAPE_SMALL_MAX_WIDTH || y >= SHAPE_SMALL_MAX_HEIGHT || x < 0 || y < 0) {
        Com_Printf("INVSH_ShapeSetBit: Bad x or y value: (x=%i, y=%i)\n", x,y);
        return shape;
    }

    shape |= 0x01 << (y * SHAPE_SMALL_MAX_WIDTH + x);
    return shape;
}


uint32_t INVSH_ShapeRotate (const uint32_t shape)
{
    int h, w;
    uint32_t shapeNew = 0;
    int maxWidth = -1;

    for (w = SHAPE_SMALL_MAX_WIDTH - 1; w >= 0; w--) {
        for (h = 0; h < SHAPE_SMALL_MAX_HEIGHT; h++) {
            if (INVSH_CheckShapeSmall(shape, w, h)) {
                if (w >= SHAPE_SMALL_MAX_HEIGHT) {
                    /* Object can't be rotated (code-wise), it is longer than SHAPE_SMALL_MAX_HEIGHT allows. */
                    return shape;
                }

                if (maxWidth < 0)
                    maxWidth = w;

                shapeNew = INVSH_ShapeSetBit(shapeNew, h, maxWidth - w);
            }
        }
    }

    return shapeNew;
}