Item.cpp

Go to the documentation of this file.

/*
Copyright (C) 2003-2007 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 "Item.h"
#include "GUIApp.h"
#include "Usecode.h"
#include "GameData.h"
#include "UCMachine.h"
#include "UCList.h"
#include "World.h"
#include "DelayProcess.h"
#include "Container.h"
#include "Actor.h"
#include "Kernel.h"
#include "getObject.h"
#include "MainShapeArchive.h"
#include "GumpShapeArchive.h"
#include "Shape.h"
#include "ShapeInfo.h"
#include "ItemFactory.h"
#include "CurrentMap.h"
#include "UCStack.h"
#include "Direction.h"
#include "BarkGump.h"
#include "AskGump.h"
#include "GumpNotifyProcess.h"
#include "ActorBarkNotifyProcess.h"
#include "ContainerGump.h"
#include "PaperdollGump.h"
#include "GameMapGump.h"
#include "WorldPoint.h"
#include "GravityProcess.h"
#include "LoopScript.h"
#include "IDataSource.h"
#include "ODataSource.h"
#include "CameraProcess.h"
#include "SpriteProcess.h"
#include "SliderGump.h"
#include "UCProcess.h"
#include "DestroyItemProcess.h"
#include "AudioProcess.h"
#include "GameInfo.h"
#include "MainActor.h"
#include "MissileTracker.h"

#include <cstdlib>

// p_dynamic_cast stuff
DEFINE_RUNTIME_CLASSTYPE_CODE(Item,Object);

Item::Item()
        : shape(0), frame(0), x(0), y(0), z(0),
          flags(0), quality(0), npcnum(0), mapnum(0),
          extendedflags(0), parent(0), 
          cachedShape(0), cachedShapeInfo(0), gump(0), gravitypid(0),
          last_setup(0)
{

}


Item::~Item()
{

}

void Item::dumpInfo()
{
        pout << "Item " << getObjId() << " (class "
                 << GetClassType().class_name << ", shape "
                 << getShape() << ", " << getFrame() << ", (";

        if (parent) {
                sint32 gx, gy;
                getGumpLocation(gx, gy);
                pout << gx << "," << gy;
        } else {
                pout << x << "," << y << "," << z;
        }

        pout << ") q:" << getQuality()
                 << ", m:" << getMapNum() << ", n:" << getNpcNum()
                 << ", f:" << std::hex << getFlags() << ", ef:"
                 << getExtFlags() << ")" << std::dec << std::endl;
}

Container *Item::getParentAsContainer() const
{
        // No parent, no container
        if (!parent) return 0;

        Container *p = getContainer(parent);

        if (!p) {
                perr << "Item " << getObjId() << " parent (" << parent << ") is an invalid Container ObjID" << std::endl;
                CANT_HAPPEN();
        }

        return p;
}

Item* Item::getTopItem()
{
        Container *parent = getParentAsContainer();

        if (!parent) return this;

        while (parent->getParentAsContainer()) {
                parent = parent->getParentAsContainer();
        }

        return parent;
}

void Item::setLocation(sint32 X, sint32 Y, sint32 Z)
{
        x = X;
        y = Y;
        z = Z;
}

void Item::move(sint32 X, sint32 Y, sint32 Z)
{
        bool no_lerping = false;
        CurrentMap * map = World::get_instance()->getCurrentMap();
        int mapChunkSize = map->getChunkSize();

        if (getObjId() == 1 && Z < 0) {
                perr.printf("Warning: moving avatar below Z=0. (%d,%d,%d)\n", X, Y, Z);
        }

        // It's currently in the ethereal void, remove it from there
        if (flags & FLG_ETHEREAL) {

                // Remove us from the ethereal void
                World::get_instance()->etherealRemove(objid);
        }

        // Remove from container (if contained or equiped)
        if (flags & (FLG_CONTAINED|FLG_EQUIPPED))
        {
                if (parent) {
                        // If we are flagged as Ethereal, we are already removed 
                        if (!(flags & FLG_ETHEREAL)) {
                                Container *p = getParentAsContainer();
                                if (p) p->removeItem(this);
                        }
                }
                else
                        perr << "Item " << getObjId() << " FLG_CONTAINED or FLG_EQUIPPED set but item has no parent" << std::endl;

                // Clear our owner. 
                parent = 0;

                // No lerping when going from a container to somewhere else
                no_lerping = true;
        }
        // Item needs to be removed if it in the map, and it is moving to a 
        // different chunk
        else if ((extendedflags & EXT_INCURMAP) && 
                        ((x / mapChunkSize != X / mapChunkSize) || 
                        (y / mapChunkSize != Y / mapChunkSize))) {

                // Remove us from the map
                map->removeItem(this);
        }

        // Unset all the various flags that no longer apply
        flags &= ~(FLG_CONTAINED|FLG_EQUIPPED|FLG_ETHEREAL);

        // Set the location
        x = X;
        y = Y;
        z = Z;

        // Add it to the map if needed
        if (!(extendedflags & EXT_INCURMAP))
        {
                // Disposable fast only items get put at the end
                // While normal items get put at start
                if (flags & (FLG_DISPOSABLE|FLG_FAST_ONLY))
                        map->addItemToEnd(this);
                else
                        map->addItem(this);
        }

        // Call just moved
        callUsecodeEvent_justMoved();

        // Are we moving somewhere fast
        bool dest_fast = map->isChunkFast(X/mapChunkSize, Y/mapChunkSize);

        // No lerping for this move
        if (no_lerping) extendedflags |= EXT_LERP_NOPREV;

        // If the destination is not in the fast area, and we are in
        // the fast area, we need to call leaveFastArea, as long as we aren't
        // being followed by the camera. We also disable lerping in such a case
        if (!dest_fast && (flags & Item::FLG_FASTAREA)) {
                extendedflags |= EXT_LERP_NOPREV;
                if (extendedflags & EXT_CAMERA) 
                        CameraProcess::GetCameraProcess()->ItemMoved();
                else
                        leaveFastArea();

                return; //we are done
        }
        // Or if the dest is fast, and we are not, we need to call enterFastArea
        else if (dest_fast && !(flags & Item::FLG_FASTAREA)) {
                extendedflags |= EXT_LERP_NOPREV;
                enterFastArea();
        }

        // If we are being followed, notify the camera that we moved
        // Note that we don't need to 
        if (extendedflags & EXT_CAMERA)
                CameraProcess::GetCameraProcess()->ItemMoved();
}

bool Item::moveToContainer(Container *container, bool checkwghtvol)
{
        // Null container, report an error message
        if (!container) {
                perr << "NULL container passed to Item::moveToContainer" << std::endl;
                return false;
        }

        // Already there, do nothing, but only if not ethereal
        bool ethereal_same = false;
        if ( container->getObjId() == parent ) {
                // If we are ethereal we'd like to know if we are just being moved back
                if (flags & FLG_ETHEREAL) ethereal_same = true;
                else return true;
        }

        // Eh, can't do it
        if (!container->CanAddItem(this,checkwghtvol)) return false;

        // It's currently in the ethereal void
        if (flags & FLG_ETHEREAL) {

                // Remove us from the ethereal void
                World::get_instance()->etherealRemove(objid);
        }

        // Remove from container (if contained or equiped)
        if (flags & (FLG_CONTAINED|FLG_EQUIPPED))
        {
                if (parent) {
                        // If we are flagged as Ethereal, we are already removed 
                        if (!(flags & FLG_ETHEREAL)) {
                                Container *p = getParentAsContainer();
                                if (p) p->removeItem(this);
                        }
                }
                else
                        perr << "Item " << getObjId() << " FLG_CONTAINED or FLG_EQUIPPED set but item has no parent" << std::endl;

                // Clear our owner. 
                parent = 0;
        }
        // Item needs to be removed if it in the map
        else if (extendedflags & EXT_INCURMAP) {

                // Remove us from the map
                World::get_instance()->getCurrentMap()->removeItem(this);
        }

        // Unset all the various flags that no longer apply
        flags &= ~(FLG_CONTAINED|FLG_EQUIPPED|FLG_ETHEREAL);

        // Set location to 0,0,0 if we aren't an ethereal item moving back
        if (!ethereal_same) x = y = 0;
        z = 0;

        // Add the item, don't bother with checking weight or vol since we already
        // know if it will fit or not
        container->addItem(this, false);
        
        // Set our owner. 
        parent = container->getObjId();

        // Set us contained
        flags |= FLG_CONTAINED;

        // If moving to avatar, mark as OWNED
        Item *p = this;
        while (p->getParentAsContainer())
                p = p->getParentAsContainer();
        // In Avatar's inventory?
        if (p->getObjId() == 1)
                setFlagRecursively(FLG_OWNED);
        
        // No lerping when moving to a container
        extendedflags |= EXT_LERP_NOPREV;

        // Call just moved
        callUsecodeEvent_justMoved();

        // For a container, it's fast if it's got a gump open
        bool dest_fast = (container->flags & FLG_GUMP_OPEN)!=0;

        // If the destination is not in the fast area, and we are in
        // the fast area, we need to call leaveFastArea
        if (!dest_fast && (flags & Item::FLG_FASTAREA))
                leaveFastArea();
        // Or if the dest is fast, and we are not, we need to call enterFastArea
        else if (dest_fast && !(flags & Item::FLG_FASTAREA))
                enterFastArea();

        // Done
        return true;
}

void Item::moveToEtherealVoid()
{
        // It's already Ethereal
        if (flags & FLG_ETHEREAL) return;

        // Add it to the ethereal void
        World::get_instance()->etherealPush(objid);

        // It's owned by something removed it from the something, but keep flags
        if (flags & (FLG_CONTAINED|FLG_EQUIPPED)) {

                if (parent)
                {
                        Container *p = getParentAsContainer();
                        if (p) p->removeItem(this);
                }
                else
                        perr << "Item " << getObjId() << " FLG_CONTAINED or FLG_EQUIPPED set but item has no parent" << std::endl;
        }
        else if (extendedflags & EXT_INCURMAP) {
                World::get_instance()->getCurrentMap()->removeItem(this);
        }

        // Set the ETHEREAL Flag
        flags |=  FLG_ETHEREAL;
}

void Item::returnFromEtherealVoid()
{
        // It's not Ethereal
        if (!(flags & FLG_ETHEREAL)) return;

        // Ok, we can do 2 things here
        // If an item has the contained or Equipped flags set, we return it to it's owner
        if (flags & (FLG_CONTAINED|FLG_EQUIPPED)) {
                Container *p = getParentAsContainer();
                if (!p) {
                        perr << "Item " << getObjId() << " FLG_CONTAINED or FLG_EQUIPPED set but item has no valid parent" << std::endl;
                        CANT_HAPPEN();
                }
                moveToContainer(p);
        }
        // or we return it to the world
        else {
                move(x,y,z);
        }

}

void Item::movedByPlayer()
{
        // owned-by-avatar items can't be stolen
        if (flags & FLG_OWNED) return;

        // Otherwise, player is stealing.
        // See if anybody is around to notice.
        Item* avatar = getItem(1);
        UCList itemlist(2);
        LOOPSCRIPT(script, LS_TOKEN_TRUE);
        CurrentMap* currentmap = World::get_instance()->getCurrentMap();
        currentmap->areaSearch(&itemlist, script, sizeof(script),
                                                   avatar, 640, false);
        
        for (unsigned int i = 0; i < itemlist.getSize(); ++i) {
                Actor *actor = getActor(itemlist.getuint16(i));
                if (actor && !actor->isDead())
                        actor->callUsecodeEvent_AvatarStoleSomething(getObjId());
        }
}

sint32 Item::getZ() const
{
        return z;
}

void Item::getLocationAbsolute(sint32& X, sint32& Y, sint32& Z) const
{
        if (parent) {
                Item *p = getParentAsContainer();

                if (p) {
                        p->getLocationAbsolute(X,Y,Z);
                        return;
                }
        }

        X = x;
        Y = y;
        Z = z;
}

void Item::getGumpLocation(sint32& X, sint32& Y) const
{
        if (!parent) return;

        X = y & 0xFF;
        Y = (y >> 8) & 0xFF;
}

void Item::setGumpLocation(sint32 X, sint32 Y)
{
        if (!parent) return;

        y = (X & 0xFF) + ((Y & 0xFF) << 8);
}

void Item::randomGumpLocation()
{
        if (!parent) return;

        // This sets the coordinates to (255,255) and lets the ContainerGump
        // randomize the position when it is next opened.
        y = 0xFFFF;
}

void Item::getCentre(sint32& X, sint32& Y, sint32& Z) const
{
        // constants!
        ShapeInfo *shapeinfo = getShapeInfo();
        if (flags & FLG_FLIPPED)
        {
                X = x - shapeinfo->y * 16;
                Y = y - shapeinfo->x * 16;
        }
        else
        {
                X = x - shapeinfo->x * 16;
                Y = y - shapeinfo->y * 16;
        }

        Z = z + shapeinfo->z * 4;
}

Pentagram::Box Item::getWorldBox() const
{
        sint32 xd,yd,zd;
        getFootpadWorld(xd,yd,zd);
        return Pentagram::Box(x,y,z,xd,yd,zd);
}

bool Item::overlaps(Item& item2) const
{
        sint32 x1a,y1a,z1a,x1b,y1b,z1b;
        sint32 x2a,y2a,z2a,x2b,y2b,z2b;
        getLocation(x1b,y1b,z1a);
        item2.getLocation(x2b,y2b,z2a);

        sint32 xd,yd,zd;
        getFootpadWorld(xd,yd,zd);
        x1a = x1b - xd;
        y1a = y1b - yd;
        z1b = z1a + zd;

        item2.getFootpadWorld(xd,yd,zd);
        x2a = x2b - xd;
        y2a = y2b - yd;
        z2b = z2a + zd;

        if (x1b <= x2a || x2b <= x1a) return false;
        if (y1b <= y2a || y2b <= y1a) return false;
        if (z1b <= z2a || z2b <= z1a) return false;
        return true;
}

bool Item::overlapsxy(Item& item2) const
{
        sint32 x1a,y1a,z1a,x1b,y1b;
        sint32 x2a,y2a,z2a,x2b,y2b;
        getLocation(x1b,y1b,z1a);
        item2.getLocation(x2b,y2b,z2a);

        sint32 xd,yd,zd;
        getFootpadWorld(xd,yd,zd);
        x1a = x1b - xd;
        y1a = y1b - yd;

        item2.getFootpadWorld(xd,yd,zd);
        x2a = x2b - xd;
        y2a = y2b - yd;

        if (x1b <= x2a || x2b <= x1a) return false;
        if (y1b <= y2a || y2b <= y1a) return false;
        return true;
}

bool Item::isOn(Item& item2) const
{
        sint32 x1a,y1a,z1a,x1b,y1b;
        sint32 x2a,y2a,z2a,x2b,y2b,z2b;
        getLocation(x1b,y1b,z1a);
        item2.getLocation(x2b,y2b,z2a);

        sint32 xd,yd,zd;
        getFootpadWorld(xd,yd,zd);
        x1a = x1b - xd;
        y1a = y1b - yd;

        item2.getFootpadWorld(xd,yd,zd);
        x2a = x2b - xd;
        y2a = y2b - yd;
        z2b = z2a + zd;

        if (x1b <= x2a || x2b <= x1a) return false;
        if (y1b <= y2a || y2b <= y1a) return false;
        if (z2b == z1a) return true;
        return false;
}

bool Item::canExistAt(sint32 x, sint32 y, sint32 z, bool needsupport) const
{
        CurrentMap* cm = World::get_instance()->getCurrentMap();
        Item* support;
        bool valid = cm->isValidPosition(x, y, z, getShape(), getObjId(),
                                                                         &support, 0);
        return valid && (!needsupport || support);
}

int Item::getDirToItemCentre(Item& item2) const
{
        sint32 ix,iy,iz;
        getCentre(ix,iy,iz);

        sint32 i2x,i2y,i2z;
        item2.getCentre(i2x,i2y,i2z);

        return Get_WorldDirection(i2y - iy, i2x - ix);
}

int Item::getRange(Item& item2, bool checkz) const
{
        sint32 thisX, thisY, thisZ;
        sint32 otherX, otherY, otherZ;
        sint32 thisXd, thisYd, thisZd;
        sint32 otherXd, otherYd, otherZd;
        sint32 thisXmin, thisYmin, thisZmax;
        sint32 otherXmin, otherYmin, otherZmax;

        getLocationAbsolute(thisX, thisY, thisZ);
        item2.getLocationAbsolute(otherX, otherY, otherZ);
        getFootpadWorld(thisXd, thisYd, thisZd);
        item2.getFootpadWorld(otherXd, otherYd, otherZd);

        thisXmin = thisX - thisXd;
        thisYmin = thisY - thisYd;
        thisZmax = thisZ + thisZd;

        otherXmin = otherX - otherXd;
        otherYmin = otherY - otherYd;
        otherZmax = otherZ + otherZd;

        sint32 range = 0;

        if (thisXmin - otherX > range)
                range = thisYmin - otherY;
        if (otherXmin - thisX > range)
                range = thisXmin - otherX;
        if (thisYmin - otherY > range)
                range = otherXmin - thisX;
        if (otherYmin - thisY > range)
                range = otherYmin - thisY;
        if (checkz && thisZ - otherZmax > range)
                range = thisZ - otherZmax;
        if (checkz && otherZ - thisZmax > range)
                range = otherZ - thisZmax;

        return range;
}

ShapeInfo* Item::getShapeInfoFromGameInstance() const
{
        return GameData::get_instance()->getMainShapes()->getShapeInfo(shape);
}

Shape* Item::getShapeObject() const
{
        if (!cachedShape) cachedShape = GameData::get_instance()->getMainShapes()->getShape(shape);
        return cachedShape;
}

uint16 Item::getFamily()
{
        return static_cast<uint16>(getShapeInfo()->family);
}

uint32 Item::getWeight()
{
        uint32 weight = getShapeInfo()->weight;

        switch (getShapeInfo()->family) {
        case ShapeInfo::SF_QUANTITY:
                return ((getQuality()*weight)+9)/10;
        case ShapeInfo::SF_REAGENT:
                return getQuality()*weight;
        default:
                return weight*10;
        }
}

uint32 Item::getTotalWeight()
{
        return getWeight();
}

uint32 Item::getVolume()
{
        // invisible items (trap markers and such) don't take up volume
        if (getFlags() & FLG_INVISIBLE) return 0;


        uint32 volume = getShapeInfo()->volume;

        switch (getShapeInfo()->family) {
        case ShapeInfo::SF_QUANTITY:
                return ((getQuality()*volume)+99)/100;
        case ShapeInfo::SF_REAGENT:
                return ((getQuality()*volume)+9)/10;
        case ShapeInfo::SF_CONTAINER:
                return (volume == 0) ? 1 : volume;
        default:
                return volume;
        }
}

bool Item::checkLoopScript(const uint8* script, uint32 scriptsize)
{
        // if really necessary this could be made static to prevent news/deletes
        DynamicUCStack stack(0x40); // 64bytes should be plenty of room

        unsigned int i = 0;

        uint16 ui16a, ui16b;

        stack.push2(1); // default to true if script is empty

        while (i < scriptsize) {
                switch(script[i]) {
                case LS_TOKEN_FALSE: // false
                        stack.push2(0); break;

                case LS_TOKEN_TRUE: // true
                        stack.push2(1); break;

                case LS_TOKEN_END: // end
                        ui16a = stack.pop2();
                        return (ui16a != 0);

                case LS_TOKEN_INT: // int
                        ui16a = script[i+1] + (script[i+2]<<8);
                        stack.push2(ui16a);
                        i += 2;
                        break;

                case LS_TOKEN_AND: // and
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16a != 0 && ui16b != 0)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_OR: // or
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16a != 0 || ui16b != 0)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;                  

                case LS_TOKEN_NOT: // not
                        ui16a = stack.pop2();
                        if (ui16a != 0)
                                stack.push2(0);
                        else
                                stack.push2(1);
                        break;

                case LS_TOKEN_STATUS: // item status
                        stack.push2(getFlags());
                        break;

                case LS_TOKEN_Q: // item quality
                        stack.push2(getQuality());
                        break;

                case LS_TOKEN_NPCNUM: // npc num
                        stack.push2(getNpcNum());
                        break;

                case LS_TOKEN_EQUAL: // equal
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16a == ui16b)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_GREATER: // greater than
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16b > ui16a)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_LESS: // less than
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16b < ui16a)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_GEQUAL: // greater or equal
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16b >= ui16a)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_LEQUAL: // smaller or equal
                        ui16a = stack.pop2();
                        ui16b = stack.pop2();
                        if (ui16b <= ui16a)
                                stack.push2(1);
                        else
                                stack.push2(0);
                        break;

                case LS_TOKEN_FAMILY: // item family
                        stack.push2(getFamily());
                        break;

                case LS_TOKEN_SHAPE: // item shape
                        stack.push2(static_cast<uint16>(getShape()));
                        break;

                case 'A': case 'B': case 'C': case 'D': case 'E':
                case 'F': case 'G': case 'H': case 'I': case 'J':
                case 'K': case 'L': case 'M': case 'N': case 'O':
                case 'P': case 'Q': case 'R': case 'S': case 'T':
                case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
                {
                        bool match = false;
                        int count = script[i] - '@';
                        for (int j = 0; j < count; j++) {
                                if (getShape() == static_cast<uint32>(script[i+1] + (script[i+2]<<8)))
                                        match = true;
                                i += 2;
                        }
                        if (match)
                                stack.push2(1);
                        else
                                stack.push2(0);
                }
                break;

                case LS_TOKEN_FRAME: // item frame
                        stack.push2(static_cast<uint16>(getFrame()));
                        break;

                case 'a': case 'b': case 'c': case 'd': case 'e':
                case 'f': case 'g': case 'h': case 'i': case 'j':
                case 'k': case 'l': case 'm': case 'n': case 'o':
                case 'p': case 'q': case 'r': case 's': case 't':
                case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
                {
                        bool match = false;
                        int count = script[i] - '`';
                        for (int j = 0; j < count; j++) {
                                if (getFrame() == static_cast<uint32>(script[i+1] + (script[i+2]<<8)))
                                        match = true;
                                i += 2;
                        }
                        if (match)
                                stack.push2(1);
                        else
                                stack.push2(0);
                }
                break;

                default:
                        perr.printf("Unknown loopscript opcode %02X\n", script[i]);
                }

                i++;
        }
        perr.printf("Didn't encounter $ in loopscript\n");
        return false;
}


sint32 Item::collideMove(sint32 dx, sint32 dy, sint32 dz, bool teleport, bool force, ObjId* hititem)
{
        GUIApp *guiapp = GUIApp::get_instance();
        World *world = World::get_instance();
        CurrentMap *map = world->getCurrentMap();

        if (hititem) *hititem = 0;

        sint32 end[3] = { dx, dy, dz };

        sint32 start[3];
        if (parent)
        {
                // If we are moving from a container, only check the destination
                start[0] = end[0];
                start[1] = end[1];
                start[2] = end[2];
        }
        else
        {
                // Otherwise check from where we are to where we want to go
                getLocation(start[0], start[1], start[2]);
        }

        sint32 dims[3];
        getFootpadWorld(dims[0], dims[1], dims[2]);

        // Do the sweep test
        std::list<CurrentMap::SweepItem> collisions;
        std::list<CurrentMap::SweepItem>::iterator it;
        map->sweepTest(start, end, dims, getShapeInfo()->flags, objid,
                                   false, &collisions);

        // Ok, now to work out what to do


        // the force of the hit, used for the gotHit/hit usecode calls
        int deltax = abs(start[0] - end[0])/4;
        int deltay = abs(start[1] - end[1])/4;
        int deltaz = abs(start[2] - end[2]);
        int maxdirdelta = deltay;
        if (deltay > maxdirdelta) maxdirdelta = deltay;
        if (deltaz > maxdirdelta) maxdirdelta = deltaz;
        int hitforce = (deltax+deltay+deltaz+maxdirdelta)/2;

        // if we are contained, we always teleport
        if (teleport || parent)
        {
                // If teleporting and not force, work out if we can reach the end
                if (!force) 
                {
                        for (it = collisions.begin(); it != collisions.end(); it++)
                        {
                                // Uh oh, we hit something, can't move
                                if (it->end_time == 0x4000 && !it->touching && it->blocking) {
                                        if (hititem) *hititem = it->item;
                                        return 0;
                                }
                        }
                }

                // Trigger all the required events
                bool we_were_released = false;
                for (it = collisions.begin(); it != collisions.end(); it++)
                {
                        Item *item = getItem(it->item);

                        // Hitting us at the start and end, don't do anything
                        if (!parent && it->hit_time == 0x0000 && 
                                        it->end_time == 0x4000)
                        {
                                continue;
                        }
                        // Hitting us at the end (call hit on us, got hit on them)
                        else if (it->end_time == 0x4000)
                        {
                                if (objid == 1 && guiapp->isShowTouchingItems())
                                        item->setExtFlag(Item::EXT_HIGHLIGHT);

                                item->callUsecodeEvent_gotHit(objid, hitforce);
                                callUsecodeEvent_hit(item->getObjId(), hitforce);
                        }
                        // Hitting us at the start (call release on us and them)
                        else if (!parent && it->hit_time == 0x0000)
                        {
                                if (objid == 1) item->clearExtFlag(Item::EXT_HIGHLIGHT);
                                we_were_released = true;
                                item->callUsecodeEvent_release();
                        }
                }

                // Call release on us
                if (we_were_released) callUsecodeEvent_release();

                // Move US!
                move(end[0], end[1], end[2]);

                // We reached the end
                return 0x4000;
        }
        else
        {
                sint32 hit = 0x4000;

                // If not force, work out if we can reach the end
                // if not, need to do 'stuff'
                // We don't care about items hitting us at the start
                if (!force) 
                {
                        for (it = collisions.begin(); it != collisions.end(); it++)
                        {
                                if (it->blocking && !it->touching) {
                                        if (hititem) *hititem = it->item;
                                        hit = it->hit_time;
                                        break;
                                }
                        }
                        if (hit < 0) hit = 0;

                        if (hit != 0x4000)
                        {
#if 0
                                pout << " Hit time: " << hit << std::endl;
                                pout << "    Start: " << start[0] << ", "<< start[1] << ", " << start[2] << std::endl;
                                pout << "      End: " << end[0] << ", "<< end[1] << ", " << end[2] << std::endl;
#endif
                                it->GetInterpolatedCoords(end,start,end);
#if 0
                                pout << "Collision: " << end[0] << ", "<< end[1] << ", " << end[2] << std::endl;
#endif
                        }
                }

                // Trigger all the required events
                bool we_were_released = false;
                for (it = collisions.begin(); it != collisions.end(); it++)
                {
                        Item *item = getItem(it->item);
                        if (!item) continue;

                        // Did we go past the endpoint of the move?
                        if (it->hit_time > hit) break;

                        uint16 proc_gothit = 0, proc_rel = 0;

                        // If hitting at start, we should have already 
                        // called gotHit and hit.
                        if ((!it->touching || it->touching_floor) && it->hit_time >= 0)
                        {
                                if (objid == 1 && guiapp->isShowTouchingItems())
                                        item->setExtFlag(Item::EXT_HIGHLIGHT);

                                proc_gothit = item->callUsecodeEvent_gotHit(objid, hitforce);
                                callUsecodeEvent_hit(item->getObjId(), hitforce);
                        }

                        // If not hitting at end, we will need to call release
                        if (it->end_time < hit)
                        {
                                if (objid == 1) item->clearExtFlag(Item::EXT_HIGHLIGHT);
                                we_were_released = true;
                                proc_rel = item->callUsecodeEvent_release();
                        }

                        // We want to make sure that release is called AFTER gotHit.
                        if (proc_rel && proc_gothit)
                        {
                                Process *p = Kernel::get_instance()->getProcess(proc_rel);
                                p->waitFor(proc_gothit);
                        }
                }

                // Call release on us
                if (we_were_released) callUsecodeEvent_release();

                // Move US!
                move(end[0], end[1], end[2]);

                return hit;
        }

        return 0;
}

unsigned int Item::countNearby(uint32 shape, uint16 range)
{
        CurrentMap* currentmap = World::get_instance()->getCurrentMap();
        UCList itemlist(2);
        LOOPSCRIPT(script, LS_SHAPE_EQUAL(shape));
        currentmap->areaSearch(&itemlist, script, sizeof(script),
                                                   this, range, false);
        return itemlist.getSize();
}