g_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 "g_local.h"

edict_t *G_GetFloorItemsFromPos (const pos3_t pos)
{
    return G_GetEdictFromPos(pos, ET_ITEM);
}

edict_t *G_GetFloorItems (edict_t * ent)
{
    edict_t *floor = G_GetFloorItemsFromPos(ent->pos);
    /* found items */
    if (floor) {
        FLOOR(ent) = FLOOR(floor);
        return floor;
    }

    /* no items on ground found */
    FLOOR(ent) = NULL;
    return NULL;
}

qboolean G_InventoryRemoveItemByID (const char *itemID, edict_t *ent, containerIndex_t container)
{
    invList_t *ic = CONTAINER(ent, container);
    while (ic) {
        objDef_t *item = ic->item.t;
        if (item != NULL && !strcmp(item->id, itemID)) {
            /* remove the virtual item to update the inventory lists */
            if (!game.i.RemoveFromInventory(&game.i, &ent->chr.i, INVDEF(container), ic))
                gi.Error("Could not remove item '%s' from inventory %i",
                        ic->item.t->id, container);
            G_EventInventoryDelete(ent, G_VisToPM(ent->visflags), INVDEF(container), ic->x, ic->y);
            return qtrue;
        }
        ic = ic->next;
    }

    return qfalse;
}

static qboolean G_InventoryDropToFloorCheck (edict_t* ent, containerIndex_t container)
{
    invList_t* ic = CONTAINER(ent, container);

    if (container == gi.csi->idArmour)
        return qfalse;

    if (ic) {
        qboolean check = qfalse;
        while (ic) {
            assert(ic->item.t);
            if (ic->item.t->isVirtual) {
                invList_t *next = ic->next;
                /* remove the virtual item to update the inventory lists */
                if (!game.i.RemoveFromInventory(&game.i, &ent->chr.i, INVDEF(container), ic))
                    gi.Error("Could not remove virtual item '%s' from inventory %i",
                            ic->item.t->id, container);
                ic = next;
            } else {
                /* there are none virtual items left that should be send to the client */
                check = qtrue;
                ic = ic->next;
            }
        }
        return check;
    }

    return qfalse;
}

qboolean G_AddItemToFloor (const pos3_t pos, const char *itemID)
{
    edict_t *floor;
    item_t item = {NONE_AMMO, NULL, NULL, 0, 0};
    objDef_t *od = INVSH_GetItemByIDSilent(itemID);
    if (!od) {
        gi.DPrintf("Could not find item '%s'\n", itemID);
        return qfalse;
    }

    /* Also sets FLOOR(ent) to correct value. */
    floor = G_GetFloorItemsFromPos(pos);
    /* nothing on the ground yet? */
    if (!floor)
        floor = G_SpawnFloor(pos);

    item.t = od;
    return game.i.TryAddToInventory(&game.i, &floor->chr.i, item, INVDEF(gi.csi->idFloor));
}

/* #define ADJACENT */

#ifdef ADJACENT
static qboolean G_InventoryPlaceItemAdjacent (edict_t *ent)
{
    vec2_t oldPos; /* if we have to place it to adjacent  */
    edict_t *floorAdjacent;
    int i;

    Vector2Copy(ent->pos, oldPos);
    floorAdjacent = NULL;

    for (i = 0; i < DIRECTIONS; i++) {
        /* extend pos with the direction vectors */
        Vector2Set(ent->pos, ent->pos[0] + dvecs[i][0], ent->pos[0] + dvecs[i][1]);
        /* now try to get a floor entity for that new location */
        floorAdjacent = G_GetFloorItems(ent);
        if (!floorAdjacent) {
            floorAdjacent = G_SpawnFloor(ent->pos);
        } else {
            /* destroy this edict (send this event to all clients that see the edict) */
            G_EventPerish(floorAdjacent);
            floorAdjacent->visflags = 0;
        }

        INVSH_FindSpace(&floorAdjacent->i, &ic->item, INVDEF(gi.csi->idFloor), &x, &y, ic);
        if (x != NONE) {
            ic->x = x;
            ic->y = y;
            ic->next = FLOOR(floorAdjacent);
            FLOOR(floorAdjacent) = ic;
            break;
        }
        /* restore original pos */
        Vector2Copy(oldPos, ent->pos);
    }

    /* added to adjacent pos? */
    if (i < DIRECTIONS) {
        /* restore original pos - if no free space, this was done
         * already in the for loop */
        Vector2Copy(oldPos, ent->pos);
        return qfalse;
    }

    if (floorAdjacent)
        G_CheckVis(floorAdjacent, qtrue);

    return qtrue;
}
#endif

void G_InventoryToFloor (edict_t *ent)
{
    invList_t *ic, *next;
    containerIndex_t container;
    edict_t *floor;
    item_t item;

    /* check for items */
    for (container = 0; container < gi.csi->numIDs; container++) {
        /* ignore items linked from any temp container */
        if (INVDEF(container)->temp)
            continue;
        if (G_InventoryDropToFloorCheck(ent, container))
            break;
    }

    /* edict is not carrying any items */
    if (container >= gi.csi->numIDs)
        return;

    /* find the floor */
    floor = G_GetFloorItems(ent);
    if (!floor) {
        floor = G_SpawnFloor(ent->pos);
    } else {
        /* destroy this edict (send this event to all clients that see the edict) */
        G_EventPerish(floor);
        floor->visflags = 0;
    }

    /* drop items */
    /* cycle through all containers */
    for (container = 0; container < gi.csi->numIDs; container++) {
        /* skip floor - we want to drop to floor */
        if (container == gi.csi->idFloor)
            continue;

        /* skip csi->idArmour, we will collect armours using idArmour container,
         * not idFloor */
        if (container == gi.csi->idArmour)
            continue;

        /* now cycle through all items for the container of the character (or the entity) */
        for (ic = CONTAINER(ent, container); ic; ic = next) {
            /* Save the next inv-list before it gets overwritten below.
             * Do not put this in the "for" statement,
             * unless you want an endless loop. ;) */
            next = ic->next;
            item = ic->item;

            /* only floor can summarize, so everything on the actor must have amount=1 */
            assert(item.amount == 1);
            if (!game.i.RemoveFromInventory(&game.i, &ent->chr.i, INVDEF(container), ic))
                gi.Error("Could not remove item '%s' from inventory %i of entity %i",
                        ic->item.t->id, container, ent->number);
            if (game.i.AddToInventory(&game.i, &floor->chr.i, item, INVDEF(gi.csi->idFloor), NONE, NONE, 1) == NULL)
                gi.Error("Could not add item '%s' from inventory %i of entity %i to floor container",
                        ic->item.t->id, container, ent->number);
#ifdef ADJACENT
            G_InventoryPlaceItemAdjacent(ent);
#endif
        }
        /* destroy link */
        CONTAINER(ent, container) = NULL;
    }

    FLOOR(ent) = FLOOR(floor);

    /* send item info to the clients */
    G_CheckVis(floor, qtrue);
}

void G_ReadItem (item_t *item, invDef_t **container, int *x, int *y)
{
    int t, m;
    containerIndex_t containerID;

    gi.ReadFormat("sbsbbbbs", &t, &item->a, &m, &containerID, x, y, &item->rotated, &item->amount);

    if (t < 0 || t >= gi.csi->numODs)
        gi.Error("Item index out of bounds: %i", t);
    item->t = &gi.csi->ods[t];

    if (m != NONE) {
        if (m < 0 || m >= gi.csi->numODs)
            gi.Error("Ammo index out of bounds: %i", m);
        item->m = &gi.csi->ods[m];
    } else {
        item->m = NULL;
    }

    if (containerID >= 0 && containerID < gi.csi->numIDs)
        *container = INVDEF(containerID);
    else
        gi.Error("container id is out of bounds: %i", containerID);
}

void G_WriteItem (const item_t *item, const invDef_t *container, int x, int y)
{
    assert(item);
    assert(item->t);
    gi.WriteFormat("sbsbbbbs", item->t->idx, item->a, item->m ? item->m->idx : NONE, container->id, x, y, item->rotated, item->amount);
}

void G_SendInventory (unsigned int playerMask, const edict_t *ent)
{
    invList_t *ic;
    int nr = 0;
    containerIndex_t container;

    /* test for pointless player mask */
    if (!playerMask)
        return;

    for (container = 0; container < gi.csi->numIDs; container++) {
        for (ic = CONTAINER(ent, container); ic; ic = ic->next)
            nr++;
    }

    /* return if no inventory items to send */
    if (nr == 0)
        return;

    G_EventInventoryAdd(ent, playerMask, nr);
    for (container = 0; container < gi.csi->numIDs; container++) {
        for (ic = CONTAINER(ent, container); ic; ic = ic->next) {
            /* send a single item */
            assert(ic->item.t);
            G_WriteItem(&ic->item, INVDEF(container), ic->x, ic->y);
        }
    }
}