objproto.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_OBJPROTO_H
#define SAGA2_OBJPROTO_H

#include "saga2/idtypes.h"
#include "saga2/sprite.h"
#include "saga2/spells.h"
#include "saga2/effects.h"
#include "saga2/tcoords.h"

namespace Saga2 {

class Actor;
class gameObject;

/* ===================================================================== *
   Exports
 * ===================================================================== */

extern const int16 objectCount;  //  Number of elements in the object list
extern int16 worldCount;         //  Number of elements in the world list

#define Permanent ((uint8)255)

/* ===================================================================== *
   Object ID's
 * ===================================================================== */

//  Various inline tests for object type

inline bool isObject(ObjectID id) {
    return (id < objectCount);
}

inline bool isActor(ObjectID id) {
    return (id >= ActorBaseID && id < ActorBaseID + kActorCount);
}

inline bool isWorld(ObjectID id) {
    return (id >= WorldBaseID && id < WorldBaseID + worldCount);
}

inline bool isActorOrWorld(ObjectID id) {
    return (id >= ActorBaseID);
}

//  Same as above but use object addresses instead of ID's

class GameObject;
class IntangibleContainerWindow;
class ContainerWindow;
class ActiveItem;
class ObjectTarget;
class Sector;
class TimerList;
class Timer;
struct GameEvent;
struct SenseInfo;
class SensorList;
class Sensor;
struct ObjectSoundFXs;

bool isObject(GameObject *);
bool isActor(GameObject *);
bool isWorld(GameObject *);

/* ===================================================================== *
   Location: Describes location of object within world or container
 * ===================================================================== */

struct StaticLocation {
    StaticTilePoint tile;
    ObjectID context;

    void set(TilePoint t, ObjectID con) {
        tile.set(t.u, t.v, t.z);
        context = con;
    }
};

class Location : public TilePoint {
public:
    //  context = the ObjectID of containing context
    //  (either a container or a world).
    ObjectID        _context;

    /*
            //  Member functions to translate world coords into
            //  screen coords.
        void screenPos( Point16 &screenCoords );
        int16 screenDepth( void );

            //  returns true if it is within the view area of the current
            //  map.
        bool visible( void );
    */
    // assign a position to a location without changing context
    Location &operator=(TilePoint pos) {
        u = pos.u;
        v = pos.v;
        z = pos.z;
        return *this;
    }

    Location() : _context(0) {}

    Location(int16 nu, int16 nv, int16 nz, ObjectID con) {
        u = nu;
        v = nv;
        z = nz;
        _context = con;
    }

    Location(TilePoint p, ObjectID con = 0) {
        u = p.u;
        v = p.v;
        z = p.z;
        _context = con;
    }

    Location(StaticLocation l) {
        u = l.tile.u;
        v = l.tile.v;
        z = l.tile.z;
        _context = l.context;
    }

};

/* ===================================================================== *
   8-way facing directions
 * ===================================================================== */

inline bool isFlipped(Direction d) {
    return (d > kDirDown);
}

/* ===================================================================== *
   ProtoObj: Base class for all object prototypes.
 * ===================================================================== */

struct scriptCallFrame;

//  Since we want to be able to load prototypes from disk, but
//  still use virtual functions, we are going to divide the
//  prototype structure into two parts, one which has the data
//  and then a subclass which has all the functions.

struct ResourceObjectPrototype {

    //  General behavior properties

    int16           classType;              // which C++ class to use.
    uint16          script;                 // script to handle all objs of this type

    //  Appearance propertie

    int16           nameIndex;              // type name of object
    uint16          iconSprite,             // sprite # in inventory
                    groundSprite;           // sprite # when on ground

    uint8           colorMap[4];          // indirect color map

    //  Physical properties

    uint8           mass,                   // how heavy it is
                    bulk,                   // how bulky it is
                    crossSection,           // cross section width,
                    height,                 // height it extends above terrain
                    toughness,              // how easily broken,
                    breakType;              // what it breaks into

    //  Container properties

    uint16          maxCapacity;            // total space available
    uint8           lockType;               // type of key that opens
    uint8           acceptableItems;        // type of items that fit within

    //  Combat Properties (offensive)

    uint8           weaponDamage,
                    weaponFireRate,
                    maximumRange,
                    missileType;

    //  Combat Properties (defensive)

    uint8           whereWearable;
    int8            damageAbsorbtion,
                    damageDivider,
                    defenseBonus;

    //  Magical / Energy properties

    uint8           maxCharges,             // max number of charges, or 0=infinity
                    chargeType;             // charge type that can be used

    //  Packed flags

    int16           flags;

    //  Flag definitions

    enum protoFlags {
        kObjPropMergeable    = (1 << 0),     // merge with similar objects
        kObjPropRound        = (1 << 1),     // rolls easily down stairs
        kObjPropFlammable    = (1 << 2),     // object can burn
        kObjPropWeapon       = (1 << 3),     // can be wielded as weapon
        kObjPropThrownWpn    = (1 << 4),     // it's a throwable weapon
        kObjPropMissileWpn   = (1 << 5),     // it's a missile weapon
        kObjPropCharges      = (1 << 6),     // it's a missile weapon
        kObjPropEdible       = (1 << 7),     // can be eaten
        kObjPropFlipped      = (1 << 8),     // flipped left/right on ground
        kObjPropVisOpen      = (1 << 9),     // Object has separate "visible" sprite
        kObjPropHidden       = (1 << 10),    // "How not to be seen".
        kObjPropGhosted      = (1 << 11),    // Object permanently ghosted
        kObjPropHardSurface  = (1 << 12),    // Object makes hard sound when struck
        kObjPropNoSurface    = (1 << 13)     // Object makes no sound when struck (may grunt however)
    };

    int16           price;                  // object's price

    union {
        int16       heldSpriteBase;         // sprite # when in hand
        int16       appearanceType;         // container appearance type
        int16       ideaType;               // idea stimulus type
    };

    int16           resistance;             // resistance bits (see EFFECTS.H)
    int16           immunity;               // immunity bits   (see EFFECTS.H)

    uint8           soundFXClass;           // index into sound effects table

    uint8           reserved[7];

    ResourceObjectPrototype() {
        classType = 0;
        script = 0;
        nameIndex = 0;
        iconSprite = 0;
        groundSprite = 0;

        for (int i = 0; i < 4; ++i)
            colorMap[i] = 0;

        mass = bulk = crossSection = height = toughness = breakType = 0;
        maxCapacity = 0;
        lockType = 0;
        acceptableItems = 0;
        weaponDamage = weaponFireRate = maximumRange = missileType = 0;
        whereWearable = 0;
        damageAbsorbtion = damageDivider = defenseBonus = 0;
        maxCharges = chargeType = 0;
        flags = 0;
        price = 0;
        heldSpriteBase = 0;
        resistance = 0;
        immunity = 0;
        soundFXClass = 0;

        for (int i = 0; i < 7; ++i)
            reserved[i] = 0;
    }

    //  Copy constructor
    ResourceObjectPrototype(ResourceObjectPrototype &proto) {
        classType = proto.classType;
        script = proto.script;
        nameIndex = proto.nameIndex;
        iconSprite = proto.iconSprite;
        groundSprite = proto.groundSprite;

        for (int i = 0; i < 4; ++i)
            colorMap[i] = proto.colorMap[i];

        mass = proto.mass;
        bulk = proto.bulk;
        crossSection = proto.crossSection;
        height = proto.height;
        toughness = proto.toughness;
        breakType = proto.breakType;
        maxCapacity = proto.maxCapacity;
        lockType = proto.lockType;
        acceptableItems = proto.acceptableItems;
        weaponDamage = proto.weaponDamage;
        weaponFireRate = proto.weaponFireRate;
        maximumRange = proto.maximumRange;
        missileType = proto.missileType;
        whereWearable = proto.whereWearable;
        damageAbsorbtion = proto.damageAbsorbtion;
        damageDivider = proto.damageDivider;
        defenseBonus = proto.defenseBonus;
        maxCharges = proto.maxCharges;
        chargeType = proto.chargeType;
        flags = proto.flags;
        price = proto.price;
        heldSpriteBase = proto.heldSpriteBase;
        resistance = proto.resistance;
        immunity = proto.immunity;
        soundFXClass = proto.soundFXClass;

        for (int i = 0; i < 7; ++i)
            reserved[i] = proto.reserved[i];
    }

    void load(Common::SeekableReadStream *stream) {
        classType = stream->readSint16LE();
        script = stream->readUint16LE();
        nameIndex = stream->readSint16LE();
        iconSprite = stream->readUint16LE();
        groundSprite = stream->readUint16LE();

        for (int i = 0; i < 4; ++i)
            colorMap[i] = stream->readByte();

        mass = stream->readByte();
        bulk = stream->readByte();
        crossSection = stream->readByte();
        height = stream->readByte();
        toughness = stream->readByte();
        breakType = stream->readByte();
        maxCapacity = stream->readUint16LE();
        lockType = stream->readByte();
        acceptableItems = stream->readByte();
        weaponDamage = stream->readByte();
        weaponFireRate = stream->readByte();
        maximumRange = stream->readByte();
        missileType = stream->readByte();
        whereWearable = stream->readByte();
        damageAbsorbtion = stream->readSByte();
        damageDivider = stream->readSByte();
        defenseBonus = stream->readSByte();
        maxCharges = stream->readByte();
        chargeType = stream->readByte();
        flags = stream->readSint16LE();
        price = stream->readSint16LE();
        heldSpriteBase = stream->readSint16LE(); // union
        resistance = stream->readSint16LE();
        immunity = stream->readSint16LE();
        soundFXClass = stream->readByte();

        for (int i = 0; i < 7; ++i)
            reserved[i] = stream->readByte();
    }
};

class ProtoObj : public ResourceObjectPrototype {

    static uint8    *_nextAvailObj;


    // container defines
    // getable through virtual functions
    // at appropriate subclasses
private:
    enum {
        kViewableRows    = 6,
        kViewableCols    = 4,
        kMaxRows         = 8,
        kMaxCols         = 4
    };

public:

    enum containmentType {
        kIsTangible    = (1 << 0),
        kIsContainer   = (1 << 1),
        kIsBottle      = (1 << 2),
        kIsFood        = (1 << 3),
        kIsWearable    = (1 << 4),
        kIsWeapon      = (1 << 5),
        kIsArmor       = (1 << 6),
        kIsDocument    = (1 << 7),
        kIsIntangible  = (1 << 8),
        kIsConcept     = (1 << 9),
        kIsPsych       = (1 << 10),
        kIsSpell       = (1 << 11),
        kIsSkill       = (1 << 12),
        kIsEnchantment = (1 << 13),
        kIsTargetable  = (1 << 14)
    };

//  kludge: define earlier, incorrectly spelled names to correct spelling
//  REM: Later, do a global search and replace...
#define isTangable      kIsTangible
#define isIntangable    kIsIntangible

    enum spriteTypes {
        kObjOnGround = 0,
        kObjInContainerView,
        kObjAsMousePtr
    };

    //  Memeber functions

    //  A constructor which takes the data loaded from the file
    //  and loads it into the various fields...
    ProtoObj(ResourceObjectPrototype &proto) : ResourceObjectPrototype(proto) {}
    virtual ~ProtoObj() {}

    // returns the containment type flags for this object
    virtual uint16 containmentSet();

    //  returns true if this object can contain another object
    virtual bool canContain(ObjectID dObj, ObjectID item);

    //  Determine if this object can contain another object at a specified
    //  slot
    virtual bool canContainAt(
        ObjectID dObj,
        ObjectID item,
        const TilePoint &where);

    //  Determine if this type of object is two handed
    virtual bool isTwoHanded(ObjectID actor);

    //  Determine if this type of object is a missile
    virtual bool isMissile();

    virtual ObjectID placeObject();

    //  call the object's script
    bool invokeScript(scriptCallFrame &);

    //  Handle object script in a standard fashion
    int16 stdActionScript(int               method,
                          ObjectID        dObj,
                          ObjectID        enactor,
                          ObjectID        indirectObj);

    int16 stdActionScript(int               method,
                          ObjectID        dObj,
                          ObjectID        enactor,
                          ObjectID        indirectObj,
                          int16           value);

    //  generic actions
    //  Use this object
    bool use(ObjectID dObj, ObjectID enactor);
    virtual bool setUseCursor(ObjectID dObj);
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    //  Use this object on another object
    bool useOn(ObjectID dObj, ObjectID enactor, ObjectID item);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID item);

    //  Use this object on a tile activity instance
    bool useOn(ObjectID dObj, ObjectID enactor, ActiveItem *item);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ActiveItem *item);

    //  Use the object on a location
    bool useOn(ObjectID dObj, ObjectID enactor, const Location &loc);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, const Location &loc);

    //  open this object
    bool open(ObjectID dObj, ObjectID enactor);
    virtual bool canOpen(ObjectID dObj, ObjectID enactor);
    virtual bool openAction(ObjectID dObj, ObjectID enactor);

    //  close this object
    bool close(ObjectID dObj, ObjectID enactor);
    virtual bool closeAction(ObjectID dObj, ObjectID enactor);

    //  take this object
    bool take(ObjectID dObj, ObjectID enactor, int16 num = 1);
    virtual bool takeAction(ObjectID dObj, ObjectID enactor);
    virtual bool takeAction(ObjectID dObj, ObjectID enactor, int16 num = 1);

    //  drop this object
    bool drop(ObjectID dObj, ObjectID enactor, const Location &loc, int16 num = 1);
    virtual bool canDropAt(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc);
    virtual bool dropAction(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc,
        int16           num = 1);

    //  drop this object onto another object and handle the result.
    bool dropOn(ObjectID dObj, ObjectID enactor, ObjectID target, int16 num = 1);
    virtual bool dropOnAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID target,
        int count);

    //  drop this object onto a TAG
    bool dropOn(
        ObjectID        dObj,
        ObjectID        enactor,
        ActiveItem      *target,
        const Location  &loc,
        int16           num = 1);
    virtual bool dropOnAction(
        ObjectID        dObj,
        ObjectID        enactor,
        ActiveItem      *target,
        const Location  &loc,
        int16           num = 1);

    //  Strike another object with this object
    bool strike(ObjectID dObj, ObjectID enactor, ObjectID item);
    virtual bool strikeAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item);

    //  Damage another object with this object
    bool damage(ObjectID dObj, ObjectID enactor, ObjectID target);
    virtual bool damageAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID target);

    //  Eat this object
    bool eat(ObjectID dObj, ObjectID enactor);
    virtual bool eatAction(ObjectID dObj, ObjectID enactor);

    //  Insert this object into another object
    bool insert(ObjectID dObj, ObjectID enactor, ObjectID item);
    virtual bool insertAction(ObjectID dObj, ObjectID enactor, ObjectID item);

    //  Remove this object from another object
    bool remove(ObjectID dObj, ObjectID enactor);
    virtual bool removeAction(ObjectID dObj, ObjectID enactor);

    //  Drop another object onto this one.
    bool acceptDrop(ObjectID dObj, ObjectID enactor, ObjectID droppedObj, int count);
    virtual bool acceptDropAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID droppedObj,
        int count);

    //  Cause damage to this object directly
    bool acceptDamage(
        ObjectID            dObj,
        ObjectID            enactor,
        int8                absDamage,
        effectDamageTypes   dType = kDamageOther,
        int8                dice = 0,
        uint8               sides = 1,
        int8                perDieMod = 0);
    virtual bool acceptDamageAction(
        ObjectID            dObj,
        ObjectID            enactor,
        int8                absDamage,
        effectDamageTypes   dType,
        int8                dice,
        uint8               sides,
        int8                perDieMod);

    bool acceptHealing(
        ObjectID    dObj,
        ObjectID    enactor,
        int8        absHealing,
        int8        dice = 0,
        uint8       sides = 1,
        int8        perDieMod = 0);
    virtual bool acceptHealingAction(
        ObjectID    dObj,
        ObjectID    enactor,
        int8        healing);

    //  Accept strike from another object (allows this object to cause
    //  damage to the striking object).
    bool acceptStrike(
        ObjectID            dObj,
        ObjectID            enactor,
        ObjectID            strikingObj,
        uint8               skillIndex);
    virtual bool acceptStrikeAction(
        ObjectID            dObj,
        ObjectID            enactor,
        ObjectID            strikingObj,
        uint8               skillIndex);

    //  Unlock or lock this object with a key.
    bool acceptLockToggle(ObjectID dObj, ObjectID enactor, uint8 keyCode);
    virtual bool canToggleLock(
        ObjectID dObj,
        ObjectID enactor,
        uint8 keyCode);
    virtual bool acceptLockToggleAction(ObjectID dObj, ObjectID enactor, uint8 keyCode);

    //  Mix this object with another.
    bool acceptMix(ObjectID dObj, ObjectID enactor, ObjectID mixObj);
    virtual bool acceptMixAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID mixObj);

    //  Insert another object into this object.
    bool acceptInsertion(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item,
        int16 count);
    virtual bool acceptInsertionAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item,
        int16 count);

    //  Insert another object into this object at a specified slot
    bool acceptInsertionAt(
        ObjectID        dObj,
        ObjectID        enactor,
        ObjectID        item,
        const TilePoint &where,
        int16           num = 1);

    virtual bool acceptInsertionAtAction(
        ObjectID        dObj,
        ObjectID        enactor,
        ObjectID        item,
        const TilePoint &where,
        int16           num = 1);

    //  Creates a color translation table for this object
    virtual void getColorTranslation(ColorTable map);

    //  return the sprite data of amount 'count'
    virtual ObjectSpriteInfo getSprite(GameObject *obj, spriteTypes spr, int16 count = -1);

    //  return the address of the sprite when held in hand
    virtual Sprite *getOrientedSprite(GameObject *obj, int16 offset);

    //  Initiate an attack using this type of object
    virtual void initiateAttack(ObjectID attacker, ObjectID target);

    //  Initiate a defense using this type of object
    virtual void initiateDefense(
        ObjectID defensiveObj,
        ObjectID defender,
        ObjectID attacker);

    //  Get a projectile from the missile weapon
    virtual GameObject *getProjectile(ObjectID weapon, ObjectID enactor);

    //  Get a spell from a magic weapon
    virtual GameObject *getSpell(ObjectID obj);

    //  Determine if this type of object can block an attack
    virtual bool canBlock();

    //  Return a mask of bits indicating the directions relative to the
    //  wielders facing in which this object can defend
    virtual uint8 defenseDirMask();

    //  Compute how much damage this defensive object will absorb
    virtual uint8 adjustDamage(uint8 damage);

    //  Return the fight stance approriate to this weapon
    virtual int16 fightStanceAction(ObjectID actor);

    //  Given an object sound effect record, which sound should be made
    //  when this object is damaged
    virtual uint8 getDamageSound(const ObjectSoundFXs &soundFXs);

    //  Do the background processing, if needed, for this object.
    //  This will be called approximately once every 10 seconds
    //  (or whatever the background refresh period is).
    virtual void doBackgroundUpdate(GameObject *obj);

    virtual bool resists(effectResistTypes r) {
        return resistance & (1 << r);
    }
    virtual bool isImmuneTo(effectImmuneTypes r) {
        return immunity & (1 << r);
    }

    virtual bool makeSavingThrow() {
        return false;
    }

    //  Returns true if object in continuous use.
    virtual bool isObjectBeingUsed(GameObject *obj);

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);

    //  Get the value of the user's skill which applies to this
    //  object
    virtual uint8 getSkillValue(ObjectID enactor);

    //  Cause the user's associated skill to grow
    virtual void applySkillGrowth(ObjectID enactor, uint8 points = 1);

    // this is to determine size of containers
public:
    virtual uint16 getViewableRows() {
        return kViewableRows;
    }
    virtual uint16 getViewableCols() {
        return kViewableCols;
    }
    virtual uint16 getMaxRows() {
        return kMaxRows;
    }
    virtual uint16 getMaxCols() {
        return kMaxCols;
    }

    // this returns the type of charge an item can have
    int16 getChargeType() {
        return chargeType;
    }

    virtual bool canFitBulkwise(GameObject *container, GameObject *obj);
    virtual bool canFitMasswise(GameObject *container, GameObject *obj);

    virtual uint16 massCapacity(GameObject *container);
    virtual uint16 bulkCapacity(GameObject *container);
};

/* ======================================================================== *
   InventoryProto:  base class for all tangible object prototypes
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto

class InventoryProto : public ProtoObj {
public:
    InventoryProto(ResourceObjectPrototype &proto) : ProtoObj(proto) {}
    virtual ~InventoryProto() {}

    virtual uint16 containmentSet();

    virtual bool takeAction(ObjectID dObj, ObjectID enactor, int16 num = 1);

    virtual bool canDropAt(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc);
    virtual bool dropAction(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc,
        int16           num = 1);

    virtual bool dropOnAction(
        ObjectID        dObj,
        ObjectID        enactor,
        ActiveItem      *target,
        const Location  &loc,
        int16           num = 1);

    virtual bool acceptDropAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID droppedObj,
        int count);

    virtual bool acceptStrikeAction(
        ObjectID            dObj,
        ObjectID            enactor,
        ObjectID            strikingObj,
        uint8               skillIndex);
};

/* ======================================================================== *
   PhysicalContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, PhysicalContainerProto

//  Prototype class for physical object container
class PhysicalContainerProto : public InventoryProto {
private:
    enum {
        kViewableRows    = 4,
        kViewableCols    = 4,
        kMaxRows         = 8,
        kMaxCols         = 4
    };

public:
    PhysicalContainerProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~PhysicalContainerProto() {}

    virtual uint16 containmentSet();

    virtual bool canContain(ObjectID dObj, ObjectID item);
    virtual bool canContainAt(
        ObjectID        dObj,
        ObjectID        item,
        const TilePoint &where);

    //  Call open() if closed, or call close() if open.
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    //  Open this object
    virtual bool canOpen(ObjectID dObj, ObjectID enactor);
    virtual bool openAction(ObjectID dObj, ObjectID enactor);

    //  Close this object
    virtual bool closeAction(ObjectID dObj, ObjectID enactor);

    //  Unlock or lock object if keyCode == lockType
    virtual bool canToggleLock(
        ObjectID dObj,
        ObjectID enactor,
        uint8 keyCode);
    virtual bool acceptLockToggleAction(ObjectID dObj, ObjectID enactor, uint8 keyCode);

    //  Insert another object into this object
    bool acceptInsertionAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item,
        int16 num);

    //  Insert another object into this object at the specified slot
    virtual bool acceptInsertionAtAction(
        ObjectID        dObj,
        ObjectID        enactor,
        ObjectID        item,
        const TilePoint &where,
        int16           num = 1);

public:
    virtual uint16 getViewableRows() {
        return kViewableRows;
    }
    virtual uint16 getViewableCols() {
        return kViewableCols;
    }
    virtual uint16 getMaxRows() {
        return kMaxRows;
    }
    virtual uint16 getMaxCols() {
        return kMaxCols;
    }

    virtual bool canFitBulkwise(GameObject *container, GameObject *obj);
    virtual bool canFitMasswise(GameObject *container, GameObject *obj);

    virtual uint16 massCapacity(GameObject *container);
    virtual uint16 bulkCapacity(GameObject *container);
};

/* ======================================================================== *
   KeyProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, KeyProto

//  Prototype class for key objects
class KeyProto : public InventoryProto {
public:
    KeyProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~KeyProto() {}

    //  Set up targeting cursor
    virtual bool setUseCursor(ObjectID dObj);

    //  Use key on lockable container
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID withObj);

    //  Use key on active terrain
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ActiveItem *withTAI);
};

/* ======================================================================== *
   BottleProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, BottleProto

class BottleProto : public InventoryProto {
public:
    BottleProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~BottleProto() {}

    virtual uint16 containmentSet();

    // Drink From Bottle
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

};

/* ======================================================================== *
   FoodProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, FoodProto

class FoodProto : public InventoryProto {
public:
    FoodProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~FoodProto() {}

    virtual uint16 containmentSet();

    // Eat it
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

};

/* ======================================================================== *
   WearableProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WearbleProto

class WearableProto : public InventoryProto {
public:
    WearableProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~WearableProto() {}

    virtual uint16 containmentSet();
};

/* ======================================================================== *
   WeaponProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto

class WeaponProto : public InventoryProto {

protected:
    enum {
        kInRangeRatingBonus = 4
    };

public:
    WeaponProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~WeaponProto() {}

    virtual uint16 containmentSet();

    //  return the address of the sprite when held in hand
    virtual Sprite *getOrientedSprite(GameObject *obj, int16 offset);
    weaponID getWeaponID();

    //  Returns true if object in continuous use.
    bool isObjectBeingUsed(GameObject *obj);

    //  Rate this weapon's goodness for a specified attack situation
    virtual uint8 weaponRating(
        ObjectID weaponID,
        ObjectID wielderID,
        ObjectID targetID) = 0;
};

/* ======================================================================== *
   MeleeWeaponProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, MeleeWeaponProto

class MeleeWeaponProto : public WeaponProto {
public:
    MeleeWeaponProto(ResourceObjectPrototype &proto) : WeaponProto(proto) {}
    virtual ~MeleeWeaponProto() {}

    virtual bool useAction(ObjectID dObj, ObjectID enactor);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID item);
    virtual bool strikeAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item);
    virtual bool damageAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID target);
    virtual bool acceptDamageAction(
        ObjectID            dObj,
        ObjectID            enactor,
        int8                absDamage,
        effectDamageTypes   dType,
        int8                dice,
        uint8               sides,
        int8                perDieMod);

    //  Determine if this type of weapon must be wielded with two hands
    //  for the specified actor
    virtual bool isTwoHanded(ObjectID actor);

    //  Initiate a melee weapon attack motion
    virtual void initiateAttack(ObjectID attacker, ObjectID target);
    //  Initiate a melee weapon parry motion
    virtual void initiateDefense(
        ObjectID defensiveObj,
        ObjectID defender,
        ObjectID attacker);
    //  Melee weapons can block attacks
    virtual bool canBlock();
    //  Return a mask of bits indicating the directions relative to the
    //  wielders facing in which this object can defend
    virtual uint8 defenseDirMask();

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);

    //  Rate this weapon's goodness for a specified attack situation
    virtual uint8 weaponRating(
        ObjectID weaponID,
        ObjectID wielderID,
        ObjectID targetID);

    //  Return the fight stance approriate to this weapon
    virtual int16 fightStanceAction(ObjectID actor);

    //  Given an object sound effect record, which sound should be made
    //  when this object is damaged
    virtual uint8 getDamageSound(const ObjectSoundFXs &soundFXs);
};

/* ======================================================================== *
   BludgeoningWeaponProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, MeleeWeaponProto,
//      BludgeoningWeaponProto

class BludgeoningWeaponProto : public MeleeWeaponProto {
public:
    BludgeoningWeaponProto(ResourceObjectPrototype &proto) : MeleeWeaponProto(proto) {}
    virtual ~BludgeoningWeaponProto() {}

    //  Get the value of the wielder's skill which applies to this
    //  weapon
    virtual uint8 getSkillValue(ObjectID enactor);

    //  Cause the user's associated skill to grow
    virtual void applySkillGrowth(ObjectID enactor, uint8 points = 1);
};

/* ======================================================================== *
   SlashingWeaponProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, MeleeWeaponProto,
//      SlashingWeaponProto

class SlashingWeaponProto : public MeleeWeaponProto {
public:
    SlashingWeaponProto(ResourceObjectPrototype &proto) : MeleeWeaponProto(proto) {}
    virtual ~SlashingWeaponProto() {}

    //  Get the value of the wielder's skill which applies to this
    //  weapon
    virtual uint8 getSkillValue(ObjectID enactor);

    //  Cause the user's associated skill to grow
    virtual void applySkillGrowth(ObjectID enactor, uint8 points = 1);
};

/* ======================================================================== *
   BowProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, BowProto

class BowProto : public WeaponProto {
public:
    BowProto(ResourceObjectPrototype &proto) : WeaponProto(proto) {}
    virtual ~BowProto() {}

    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    //  Bows are two handed
    virtual bool isTwoHanded(ObjectID actor);

    //  Initiate a bow firing motion
    virtual void initiateAttack(ObjectID attacker, ObjectID target);

    //  Grab and arrow from the actor's inventory
    virtual GameObject *getProjectile(ObjectID weapon, ObjectID enactor);

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);

    //  Rate this weapon's goodness for a specified attack situation
    virtual uint8 weaponRating(
        ObjectID weaponID,
        ObjectID wielderID,
        ObjectID targetID);

    //  Return the fight stance approriate to this weapon
    virtual int16 fightStanceAction(ObjectID actor);
};

/* ======================================================================== *
   WeaponWandProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, WeaponWandProto

class WeaponWandProto : public WeaponProto {
public:
    WeaponWandProto(ResourceObjectPrototype &proto) : WeaponProto(proto) {}
    virtual ~WeaponWandProto() {}

    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    //  Wands are two handed
    virtual bool isTwoHanded(ObjectID actor);

    //  Initiate a bow firing motion
    virtual void initiateAttack(ObjectID attacker, ObjectID target);

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);

    //  Rate this weapon's goodness for a specified attack situation
    virtual uint8 weaponRating(
        ObjectID weaponID,
        ObjectID wielderID,
        ObjectID targetID);

    //  Return the fight stance approriate to this weapon
    virtual int16 fightStanceAction(ObjectID actor);
};

/* ======================================================================== *
   ProjectileProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, ProjectileProto

class ProjectileProto : public WeaponProto {
public:
    ProjectileProto(ResourceObjectPrototype &proto) : WeaponProto(proto) {}
    virtual ~ProjectileProto() {}

    //  return the address of the sprite when held in hand
    virtual Sprite *getOrientedSprite(GameObject *obj, int16 offset);

    //  Returns true if object in continuous use.
    bool isObjectBeingUsed(GameObject *obj);

    //  Projectiles are missiles
    virtual bool isMissile();

    //  Rate this weapon's goodness for a specified attack situation
    virtual uint8 weaponRating(
        ObjectID weaponID,
        ObjectID wielderID,
        ObjectID targetID);
};

/* ======================================================================== *
   ArrowProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, WeaponProto, ProjectileProto, ArrowProto

class ArrowProto : public ProjectileProto {
public:
    ArrowProto(ResourceObjectPrototype &proto) : ProjectileProto(proto) {}
    virtual ~ArrowProto() {}

    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID item);
    virtual bool strikeAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID item);
    virtual bool damageAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID target);

    //  Cause the user's associated skill to grow
    virtual void applySkillGrowth(ObjectID enactor, uint8 points = 1);

};

/* ======================================================================== *
   ArmorProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, ArmorProto

class ArmorProto : public InventoryProto {
public:
    ArmorProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~ArmorProto() {}

    virtual uint16 containmentSet();

    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    //  Compute how much damage this defensive object will absorb
    virtual uint8 adjustDamage(uint8 damage);

    //  Returns true if object in continuous use.
    bool isObjectBeingUsed(GameObject *obj);

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);
};

/* ======================================================================== *
   ShieldProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, ShieldProto

class ShieldProto : public InventoryProto {
public:
    ShieldProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~ShieldProto() {}

    virtual uint16 containmentSet();

    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    virtual bool acceptDamageAction(
        ObjectID            dObj,
        ObjectID            enactor,
        int8                absDamage,
        effectDamageTypes   dType,
        int8                dice,
        uint8               sides,
        int8                perDieMod);

    //  return the address of the sprite when held in hand
    virtual Sprite *getOrientedSprite(GameObject *obj, int16 offset);

    virtual void initiateDefense(
        ObjectID defensiveObj,
        ObjectID defender,
        ObjectID attacker);
    virtual bool canBlock();
    //  Return a mask of bits indicating the directions relative to the
    //  wielders facing in which this object can defend
    virtual uint8 defenseDirMask();

    //  Returns true if object in continuous use.
    bool isObjectBeingUsed(GameObject *obj);

    //  Determine if the specified object's 'use' slot is available within
    //  the specified actor
    virtual bool useSlotAvailable(GameObject *obj, Actor *a);

    //  Get the value of the user's skill which applies to this
    //  object
    virtual uint8 getSkillValue(ObjectID enactor);

    //  Cause the user's associated skill to grow
    virtual void applySkillGrowth(ObjectID enactor, uint8 points = 1);

    //  Given an object sound effect record, which sound should be made
    //  when this object is damaged
    virtual uint8 getDamageSound(const ObjectSoundFXs &soundFXs);
};

/* ======================================================================== *
   ToolProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, ToolProto

class ToolProto : public InventoryProto {
public:
    ToolProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~ToolProto() {}

    //  Set up targeting cursor
    virtual bool setUseCursor(ObjectID dObj);

    //  Use tool on object
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID withObj);
};

/* ======================================================================== *
   DocumentProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, DocumentProto

class DocumentProto : public InventoryProto {
public:
    DocumentProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~DocumentProto() {}

    virtual uint16 containmentSet();

//BookDoc
//ScrollDoc

//  virtual bool use( ObjectID dObj, ObjectID enactor );
//  Close Floating Window Used For Both Book And Scroll
//  virtual bool close( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   BookProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, DocumentProto, BookProto

class BookProto : public DocumentProto {
public:
    BookProto(ResourceObjectPrototype &proto) : DocumentProto(proto) {}
    virtual ~BookProto() {}
    //Read It
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

};

/* ======================================================================== *
   ScrollProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, DocumentProto, ScrollProto

class ScrollProto : public DocumentProto {
public:
    ScrollProto(ResourceObjectPrototype &proto) : DocumentProto(proto) {}
    virtual ~ScrollProto() {}

    //Read It
    virtual bool useAction(ObjectID dObj, ObjectID enactor);

};

/* ======================================================================== *
   AutoMapProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, InventoryProto, AutoMapProto

class AutoMapProto : public InventoryProto {
public:
    AutoMapProto(ResourceObjectPrototype &proto) : InventoryProto(proto) {}
    virtual ~AutoMapProto() {}

    //Shows Auto Map Display
    virtual bool openAction(ObjectID dObj, ObjectID enactor);

};

/* ======================================================================== *
   IntagibleObjProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleObjProto

class IntangibleObjProto : public ProtoObj {
public:
    IntangibleObjProto(ResourceObjectPrototype &proto) : ProtoObj(proto) {}
    virtual ~IntangibleObjProto() {}

    virtual bool useAction(ObjectID dObj, ObjectID enactor);

    virtual bool takeAction(ObjectID dObj, ObjectID enactor, int16);

    virtual bool canDropAt(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc);
    virtual bool dropAction(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc,
        int16);

    virtual bool acceptDropAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID droppedObj,
        int count);

    virtual uint16 containmentSet();
    virtual ObjectID placeObject();

    //  Creates a color translation table for this object
    virtual void getColorTranslation(ColorTable map);

    //  return the sprite data
    virtual ObjectSpriteInfo getSprite(GameObject *obj, spriteTypes spr, int16);
};

/* ======================================================================== *
   IdeaProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleObjProto, IdeaProto

class IdeaProto : public IntangibleObjProto {
public:
    IdeaProto(ResourceObjectPrototype &proto) : IntangibleObjProto(proto) {}
    virtual ~IdeaProto() {}

    //Talk To A Person
    uint16 containmentSet();

};

/* ======================================================================== *
   MemoryProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleObjProto, MemoryProto

class MemoryProto : public IntangibleObjProto {
public:
    MemoryProto(ResourceObjectPrototype &proto) : IntangibleObjProto(proto) {}
    virtual ~MemoryProto() {}

    //Get Info On Person Your Talking To
    uint16 containmentSet();

};

/* ======================================================================== *
   PsychProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleObjProto, PsychProto

class PsychProto : public IntangibleObjProto {
public:
    PsychProto(ResourceObjectPrototype &proto) : IntangibleObjProto(proto) {}
    virtual ~PsychProto() {}

    //Get Explanation Of Icon
    uint16 containmentSet();

};

/* ======================================================================== *
   SkillProto
 * ======================================================================== */

//typedef uint8 SpellID;

//  hierarchy:
//      ProtoObj, IntagibleObjProto, SkillProto

class SkillProto : public IntangibleObjProto {
public:
    SkillProto(ResourceObjectPrototype &proto) : IntangibleObjProto(proto) {}
    virtual ~SkillProto() {}

    //Perform A Skill or Cast a spell
    virtual bool useAction(ObjectID dObj, ObjectID enactor);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ObjectID withObj);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, ActiveItem *item);
    virtual bool useOnAction(ObjectID dObj, ObjectID enactor, const Location &loc);

    virtual bool canDropAt(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc);
    virtual bool dropAction(
        ObjectID        dObj,
        ObjectID        enactor,
        const Location  &loc,
        int16           num = 1);
    virtual bool dropOnAction(
        ObjectID dObj,
        ObjectID enactor,
        ObjectID target,
        int count);
    virtual bool dropOnAction(
        ObjectID        dObj,
        ObjectID        enactor,
        ActiveItem      *target,
        const Location  &loc,
        int16           num = 1);

    virtual bool implementAction(SpellID dObj, ObjectID enactor, ObjectID withObj);
    virtual bool implementAction(SpellID dObj, ObjectID enactor, ActiveItem *item);
    virtual bool implementAction(SpellID dObj, ObjectID enactor, Location &loc);
    uint16 containmentSet();
    SpellID getSpellID() {
        return (SpellID) lockType;
    }

};

/* ======================================================================== *
   IntangibleContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto

class IntangibleContainerProto : public ProtoObj {
public:
    IntangibleContainerProto(ResourceObjectPrototype &proto) : ProtoObj(proto) {}
    virtual ~IntangibleContainerProto() {}

    virtual bool canContain(ObjectID dObj, ObjectID item);
    virtual bool useAction(ObjectID dObj, ObjectID enactor);
    virtual bool canOpen(ObjectID dObj, ObjectID enactor);
    virtual bool openAction(ObjectID dObj, ObjectID enactor);
    virtual bool closeAction(ObjectID dObj, ObjectID enactor);
//  virtual  bool acceptLockToggle( ObjectID dObj, ObjectID enactor, uint8 keyCode );

//  virtual  ContainerWindow *makeWindow( GameObject *Obj );
    virtual uint16 containmentSet();
};

/* ======================================================================== *
   IdeaContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto, IdeaContainerProto

class IdeaContainerProto : public IntangibleContainerProto {
public:
    IdeaContainerProto(ResourceObjectPrototype &proto) : IntangibleContainerProto(proto) {}
    virtual ~IdeaContainerProto() {}

    //Holding Idea Objects
//  bool use( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   MemoryContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto, MemoryContainerProto

class MemoryContainerProto : public IntangibleContainerProto {
public:
    MemoryContainerProto(ResourceObjectPrototype &proto) : IntangibleContainerProto(proto) {}
    virtual ~MemoryContainerProto() {}

    //Holding Memories Of People You Met
//  bool use( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   PhychContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto, PsychContainerProto

class PsychContainerProto : public IntangibleContainerProto {
public:
    PsychContainerProto(ResourceObjectPrototype &proto) : IntangibleContainerProto(proto) {}
    virtual ~PsychContainerProto() {}

    //Holding Psychological Objects
//  bool use( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   SkillContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto, SkillContainerProto

class SkillContainerProto : public IntangibleContainerProto {
public:
    SkillContainerProto(ResourceObjectPrototype &proto) : IntangibleContainerProto(proto) {}
    virtual ~SkillContainerProto() {}

    //Holding Skills And Spells
//  bool use( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   MindContainerProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, IntangibleContainerProto, MindContainerProto

class MindContainerProto : public IntangibleContainerProto {
public:
    MindContainerProto(ResourceObjectPrototype &proto) : IntangibleContainerProto(proto) {}
    virtual ~MindContainerProto() {}

    //Contains Skill Psych Memory And Idea Containers
//  virtual bool use( ObjectID dObj, ObjectID enactor );

};

/* ======================================================================== *
   EnchantmentProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, EnchantmentProto

class EnchantmentProto : public ProtoObj {
public:
    EnchantmentProto(ResourceObjectPrototype &proto) : ProtoObj(proto) {}
    virtual ~EnchantmentProto() {}

    //  Do the background processing, if needed, for this object.
    void doBackgroundUpdate(GameObject *obj);

    virtual uint16 containmentSet();
};

/* ======================================================================== *
   GeneratorProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, GeneratorProto

class GeneratorProto : public ProtoObj {
public:
    GeneratorProto(ResourceObjectPrototype &proto) : ProtoObj(proto) {}
    virtual ~GeneratorProto() {}

    //Base class for monster, encounter, and mission generators

    virtual uint16 containmentSet();
};

/* ======================================================================== *
   MonsterGeneratorProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, GeneratorProto, MonsterGeneratorProto

class MonsterGeneratorProto : public GeneratorProto {
public:
    MonsterGeneratorProto(ResourceObjectPrototype &proto) : GeneratorProto(proto) {}
    virtual ~MonsterGeneratorProto() {}

    //Monster generators
    //  REM: We don't want to generate monsters as a background activity, since
    //  we may want more rapid generation that once every 10 seconds, and we only
    //  want to do it while active anyway.
};

/* ======================================================================== *
   EncounterGeneratorProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, GeneratorProto, EncounterGeneratorProto

class EncounterGeneratorProto : public GeneratorProto {
public:
    EncounterGeneratorProto(ResourceObjectPrototype &proto) : GeneratorProto(proto) {}
    virtual ~EncounterGeneratorProto() {}

    //Encounter generator

    //  Generate an encounter at approx. 10-second intervals
    void doBackgroundUpdate(GameObject *obj);
};

/* ======================================================================== *
   MissionGeneratorProto
 * ======================================================================== */

//  hierarchy:
//      ProtoObj, GeneratorProto, MissionGeneratorProto

class MissionGeneratorProto : public GeneratorProto {
public:
    MissionGeneratorProto(ResourceObjectPrototype &proto) : GeneratorProto(proto) {}
    virtual ~MissionGeneratorProto() {}

    //  Check every 10 seconds to see if we want to generate a mission.
    void doBackgroundUpdate(GameObject *obj);
};

/*  Subclasses of "ProtoObj" which haven't been defined yet

        InventoryObjectPrototype            // can be dropped on ground
            ContainerPrototype              // holds a list of items
            BottlePrototype                 // holds 1 liquid
            FoodPrototype                   // edible
            WearablePrototype               // armor and jewelry
            WeaponPrototype                 // does damage efficiently
            DocumentPrototype               // expands to document window
        IntangableObjectPrototype           // Ideas and Magic
            ConceptObjectPrototype          // Basic Ideas (Food, Friend...)
            MemoryObjectPrototype           // Memories of game events
            PsychObjectPrototype            // I am ... (Brave, Humble...)
            SpellObjectPrototype            // Spells to cast
            EnchantmentObjectPrototype      // Enchants object that holds it
        IntangableContainerPrototype        // Containers for Ideas and Magic
            ConceptContainerPrototype       // Containers for Basic Ideas (Food, Friend...)
            MemoryContainerPrototype        // Containers for Memories of game events
            PsychContainerPrototype         // Containers for I am ... (Brave, Humble...)
            SpellContainerPrototype         // Containers for Spells to cast
//          EnchantmentContainerPrototype   // Enchants object that holds it
        ProjectilePrototype                 // a missile in flight
**      ActorPrototype
*/

} // end of namespace Saga2

#endif