Container.cpp

Go to the documentation of this file.

/*
Copyright (C) 2003-2006 The Pentagram team

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 "pent_include.h"

#include "Container.h"

#include "ObjectManager.h"
#include "UCMachine.h"
#include "UCList.h"
#include "IDataSource.h"
#include "ODataSource.h"
#include "ItemFactory.h"
#include "MainActor.h"
#include "getObject.h"
#include "CoreApp.h"

#include "ShapeInfo.h"

// p_dynamic_cast stuff
DEFINE_RUNTIME_CLASSTYPE_CODE(Container,Item);

Container::Container()
{

}


Container::~Container()
{
        // TODO: handle container's contents.
        // Either destroy the contents, or move them up to this container's parent?



        // if we don't have an objid, we _must_ delete children
        if (objid == 0xFFFF) {
                std::list<Item*>::iterator iter;
                for (iter = contents.begin(); iter != contents.end(); ++iter) {
                        delete (*iter);
                }
        }
}


ObjId Container::assignObjId()
{
        ObjId id = Item::assignObjId();

        std::list<Item*>::iterator iter;
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                (*iter)->assignObjId();
                (*iter)->setParent(id);
        }

        return id;
}

void Container::clearObjId()
{
        Item::clearObjId();

        std::list<Item*>::iterator iter;
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                (*iter)->clearObjId();
        }
}


bool Container::CanAddItem(Item* item, bool checkwghtvol)
{
        if (!item) return false;
        if (item->getParent() == this->getObjId()) return true; // already in here

        Container *c = p_dynamic_cast<Container*>(item);
        if (c) {
                // To quote Exult: "Watch for snake eating itself."
                Container* p = this;
                do {
                        if (p == c)
                                return false;
                } while ((p = p->getParentAsContainer()) != 0);
        }

        if (checkwghtvol) {

                uint32 volume = getContentVolume();
                uint32 capacity = getCapacity();

                // Because Avatar should be able to remove backpack and haul a barrel
                // or chest on his back instead, artificially increase backpack volume
                // for chests or barrels.
                uint32 shapeid = item->getShape();
                if(GAME_IS_U8 && (shapeid == 115 /*Barrel*/
                   || shapeid == 78 || shapeid == 117 /*Chests*/))
                {
                        // TODO: make this off by default, but can enable it through
                        // pentagram.ini
                        MainActor* avatar = getMainActor();
                        ObjId bp = avatar->getEquip(7); // !! constant
                        Container* avatarbackpack = getContainer(bp);
                        if(avatarbackpack == this)
                        {
                                capacity = 500;
                        }
                }

                // FIXME: this check isn't entirely correct. (combining items,...?)
                if (volume + item->getVolume() > capacity)
                        return false;

                Item *p = getTopItem();
                Item *current = item->getTopItem();

                // From outside to inside Avatar's inventory?
                if (p->getObjId() == 1 && current->getObjId() != 1) {
                        MainActor* av = getMainActor();
                        unsigned int str = av->getStr();
                        // FIXME: this check isn't entirely correct. (combining items,...?)
                        //CONSTANT!
                        if (p->getTotalWeight() + item->getTotalWeight() > 40 * str)
                                return false;
                }
        }

        return true;
}

bool Container::addItem(Item* item, bool checkwghtvol)
{
        if (!CanAddItem(item, checkwghtvol)) return false;
        if (item->getParent() == objid) return true; // already in here

        contents.push_back(item);
        return true;
}


bool Container::removeItem(Item* item)
{
        std::list<Item*>::iterator iter;

        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                if (*iter == item) {
                        contents.erase(iter);
                        return true;
                }
        }
        return false;
}

bool Container::moveItemToEnd(Item* item)
{
        std::list<Item*>::iterator iter;

        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                if (*iter == item) {
                        // found; move to end
                        contents.erase(iter);
                        contents.push_back(item);
                        return true;
                }
        }

        // not found

        return false;
}

void Container::removeContents()
{
        // CHECKME: ethereal items?

        Container* parent = getParentAsContainer();
        if (parent) {
                // move contents to parent
                while (contents.begin() != contents.end()) {
                        Item *item = *(contents.begin());
                        item->moveToContainer(parent);
                }
        } else {
                // move contents to our coordinates
                while (contents.begin() != contents.end()) {
                        Item *item = *(contents.begin());
                        item->move(x,y,z);
                }
        }
}


void Container::destroyContents()
{
        while (contents.begin() != contents.end()) {
                Item *item = *(contents.begin());
                Container *cont = p_dynamic_cast<Container*>(item);
                if (cont) cont->destroyContents();
                item->destroy(true); // we destroy the item immediately
        }
}

void Container::setFlagRecursively(uint32 mask)
{
        setFlag(mask);

        std::list<Item*>::iterator iter;
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                (*iter)->setFlag(mask);
                Container *cont = p_dynamic_cast<Container*>(*iter);
                if (cont) cont->setFlagRecursively(mask);
        }
}

void Container::destroy(bool delnow)
{

        removeContents();

        Item::destroy(delnow);
}

uint32 Container::getTotalWeight()
{
        uint32 weight = Item::getTotalWeight();

        // CONSTANT!
        if (GAME_IS_U8 && getShape() == 79) {
                // contents of keyring don't weigh anything
                return weight;
        }

        // CONSTANT!
        if (GAME_IS_U8 && getShape() == 115) {
                // barrel weight is unreasonably heavy
                weight = 300;
        }

        std::list<Item*>::iterator iter;
        
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                weight += (*iter)->getTotalWeight();
        }

        return weight;
}

uint32 Container::getCapacity()
{
        uint32 volume = getShapeInfo()->volume;

        return (volume == 0) ? 32 : volume;
}

uint32 Container::getContentVolume()
{
        uint32 volume = 0;

        std::list<Item*>::iterator iter;
        
        for (iter = contents.begin(); iter != contents.end(); ++iter) { 
                volume += (*iter)->getVolume();
        }

        return volume;  
}

void Container::containerSearch(UCList* itemlist, const uint8* loopscript,
                                                                uint32 scriptsize, bool recurse)
{
        std::list<Item*>::iterator iter;
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                // check item against loopscript
                if ((*iter)->checkLoopScript(loopscript, scriptsize)) {
                        uint16 objid = (*iter)->getObjId();
                        uint8 buf[2];
                        buf[0] = static_cast<uint8>(objid);
                        buf[1] = static_cast<uint8>(objid >> 8);
                        itemlist->append(buf);
                }

                if (recurse) {
                        // recurse into child-containers
                        Container *container = p_dynamic_cast<Container*>(*iter);
                        if (container)
                                container->containerSearch(itemlist, loopscript,
                                                                                   scriptsize, recurse);
                }
        }       
}

void Container::dumpInfo()
{
        Item::dumpInfo();

        pout << "Volume: " << getContentVolume() << "/" << getCapacity()
                 << ", total weight: " << getTotalWeight() << std::endl;
}

void Container::saveData(ODataSource* ods)
{
        Item::saveData(ods);
        ods->write4(contents.size());
        std::list<Item*>::iterator iter;
        for (iter = contents.begin(); iter != contents.end(); ++iter) {
                (*iter)->save(ods);
        }
}

bool Container::loadData(IDataSource* ids, uint32 version)
{
        if (!Item::loadData(ids, version)) return false;

        uint32 contentcount = ids->read4();

        // read contents
        for (unsigned int i = 0; i < contentcount; ++i)
        {
                Object* obj = ObjectManager::get_instance()->loadObject(ids, version);
                Item* item = p_dynamic_cast<Item*>(obj);
                if (!item) return false;

                addItem(item);
                item->setParent(objid);
        }

        return true;
}


uint32 Container::I_removeContents(const uint8* args, unsigned int /*argsize*/)
{
        ARG_CONTAINER_FROM_PTR(container);
        if (!container) return 0;

        container->removeContents();
        return 0;
}

uint32 Container::I_destroyContents(const uint8* args,unsigned int /*argsize*/)
{
        ARG_CONTAINER_FROM_PTR(container);
        if (!container) return 0;

        container->destroyContents();
        return 0;
}

---