mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 21:59:17 +00:00
1470 lines
40 KiB
C++
1470 lines
40 KiB
C++
/* 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_OBJECTS_H
|
|
#define SAGA2_OBJECTS_H
|
|
|
|
#include "saga2/objproto.h"
|
|
#include "saga2/property.h"
|
|
|
|
namespace Saga2 {
|
|
|
|
/* ======================================================================= *
|
|
GameObject: Describes an instance of an object
|
|
* ======================================================================= */
|
|
|
|
class GameWorld;
|
|
|
|
const uint16 unlimitedCapacity = maxuint16;
|
|
|
|
enum ActorManaID {
|
|
manaIDRed = 0,
|
|
manaIDOrange,
|
|
manaIDYellow,
|
|
manaIDGreen,
|
|
manaIDBlue,
|
|
manaIDViolet,
|
|
|
|
numManas
|
|
};
|
|
|
|
// Used to indicate if objects can be stacked or merged
|
|
enum {
|
|
cannotStackOrMerge = 0,
|
|
canStack,
|
|
canMerge
|
|
};
|
|
|
|
// The ResourceGameObject structure represents the game object data as
|
|
// it is structured in the resource file.
|
|
|
|
struct ResourceGameObject {
|
|
int16 protoIndex;
|
|
TilePoint location;
|
|
uint16 nameIndex;
|
|
ObjectID parentID;
|
|
uint16 script;
|
|
uint16 objectFlags;
|
|
uint8 hitPoints;
|
|
uint16 misc;
|
|
|
|
ResourceGameObject(Common::SeekableReadStream *stream);
|
|
};
|
|
|
|
// Base class of all objects
|
|
//
|
|
// Unlike the object prototypes, the only subclass of GameObject is
|
|
// the actor subclass, which is kept in an entirely separate table.
|
|
// This allows all objects to be kept in an array (indexed by ID number)
|
|
|
|
#include "common/pack-start.h"
|
|
|
|
struct ObjectData {
|
|
uint32 projectDummy;
|
|
TilePoint location; // where object is located.
|
|
uint16 nameIndex; // object's proper name, if any
|
|
ObjectID parentID, // ID of parent object
|
|
siblingID, // ID of next in chain
|
|
childID; // ID of 1st child
|
|
uint16 script; // script attached to this object
|
|
uint16 objectFlags; // various flags
|
|
uint8 hitPoints; // object hit points
|
|
uint8 bParam; // number of spell charges an object has
|
|
// (also generator radius in metatiles)
|
|
union {
|
|
uint16 massCount; // for mergeables, object count
|
|
uint16 textStringID; // inscription for documents
|
|
uint16 enchantmentType; // for enchantments
|
|
uint16 generatorFrequency; // for encounter and mission generators
|
|
};
|
|
|
|
uint8 missileFacing;
|
|
ActiveItemID currentTAG; // ActiveItem object is on
|
|
uint8 sightCtr; // Line of sight counter
|
|
|
|
uint8 reserved[2];
|
|
|
|
GameObject *obj;
|
|
} PACKED_STRUCT;
|
|
|
|
#include "common/pack-end.h"
|
|
|
|
void initActors();
|
|
void saveActors(Common::OutSaveFile *outS);
|
|
void loadActors(Common::InSaveFile *in);
|
|
void cleanupActors();
|
|
class GameObject {
|
|
|
|
friend void initWorlds();
|
|
friend void cleanupWorlds();
|
|
|
|
friend void initObjects();
|
|
friend void saveObjects(Common::OutSaveFile *out);
|
|
friend void loadObjects(Common::InSaveFile *in);
|
|
friend void cleanupObjects();
|
|
|
|
friend void buildDisplayList();
|
|
friend void drawDisplayList();
|
|
friend void setMindContainer(int NewContainerClass, IntangibleContainerWindow &cw);
|
|
friend class EnchantmentContainerWindow;
|
|
friend bool Enchantment(ObjectID, ObjectID);
|
|
friend class ProtoObj;
|
|
friend class PhysicalContainerProto;
|
|
friend class IntangibleContainerProto;
|
|
friend class KeyProto;
|
|
friend class BottleProto;
|
|
friend class SkillProto;
|
|
friend class ActorProto;
|
|
friend class MotionTask;
|
|
friend class MotionTaskList;
|
|
friend class ObjectIterator;
|
|
friend class ContainerIterator;
|
|
friend class RecursiveContainerIterator;
|
|
friend class ShopMode;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// container info
|
|
enum {
|
|
maxRow = 20,
|
|
maxCol = 4
|
|
};
|
|
|
|
public:
|
|
|
|
ObjectID thisID(); // calculate our own ID value
|
|
|
|
static const char *nameText(uint16 index);
|
|
|
|
protected:
|
|
// get address of head-of-chain id.
|
|
static ObjectID *getHeadPtr(ObjectID parentID, TilePoint &l);
|
|
|
|
// Object list management functions
|
|
void remove(); // removes from old list
|
|
void append(ObjectID newParent); // adds to new list (no remove)
|
|
void insert(ObjectID newPrev); // inserts after this item (no remove)
|
|
|
|
ProtoObj *prototype; // object that defines our behavior
|
|
public:
|
|
ObjectData _data;
|
|
uint _index;
|
|
bool _godmode;
|
|
// Default constructor
|
|
GameObject();
|
|
|
|
// Constructor -- initial construction
|
|
GameObject(const ResourceGameObject &res);
|
|
|
|
GameObject(Common::InSaveFile *in);
|
|
|
|
void read(Common::InSaveFile *in, bool expandProto);
|
|
|
|
// Return the number of bytes needed to archive this object in
|
|
// a buffer
|
|
int32 archiveSize();
|
|
|
|
void write(Common::MemoryWriteStreamDynamic *out, bool expandProto);
|
|
|
|
// returns the address of the object based on the ID, and this
|
|
// includes accounting for actors.
|
|
static GameObject *objectAddress(ObjectID id);
|
|
|
|
// Converts object ID into prototype address...
|
|
static ProtoObj *protoAddress(ObjectID id);
|
|
|
|
// Returns first object id found associate with the given name index
|
|
static int32 nameIndexToID(uint16 ind);
|
|
|
|
// Returns first object id found assciated with the given name
|
|
static Common::Array<ObjectID> nameToID(Common::String name);
|
|
|
|
// object creation and deletion
|
|
static GameObject *newObject(); // get a newly created object
|
|
void deleteObject(); // delete this object and remove
|
|
void deleteObjectRecursive(); // delete this object and every
|
|
// object it contains
|
|
|
|
// Return pointer to parent/child/next sibling object, if any
|
|
GameObject *parent() {
|
|
return _data.parentID == Nothing ? NULL : objectAddress(_data.parentID);
|
|
}
|
|
GameObject *next() {
|
|
return _data.siblingID == Nothing ? NULL : objectAddress(_data.siblingID);
|
|
}
|
|
GameObject *child() {
|
|
return _data.childID == Nothing ? NULL : objectAddress(_data.childID);
|
|
}
|
|
|
|
// Return ID of parent/child/next sibling object, if any
|
|
ObjectID IDParent() {
|
|
return _data.parentID ;
|
|
}
|
|
ObjectID IDNext() {
|
|
return _data.siblingID;
|
|
}
|
|
ObjectID IDChild() {
|
|
return _data.childID ;
|
|
}
|
|
|
|
// Return a pointer to the world on which this object resides
|
|
GameWorld *world();
|
|
|
|
// Return the number of the map of the world on which this object
|
|
// resides
|
|
int16 getMapNum();
|
|
|
|
// graphics functions
|
|
int16 sprNum(int16 state); // returns current sprite number
|
|
|
|
// gets the offset to the spr image according to masscount for mergeables
|
|
int32 getSprOffset(int16 num = -1);
|
|
|
|
// completely restore the magical energy of a magical object
|
|
void recharge();
|
|
|
|
// returns the type of charge an object has
|
|
// be it none, red, violet, etc...
|
|
int16 getChargeType();
|
|
|
|
// use charge of this object
|
|
bool deductCharge(ActorManaID manaID, uint16 manaCost);
|
|
|
|
// check charge of this object
|
|
bool hasCharge(ActorManaID manaID, uint16 manaCost);
|
|
|
|
// context-changing functions
|
|
void setLocation(const Location &loc); // move to new location in world
|
|
void setLocation(const TilePoint &tp); // move to new location in world
|
|
void move(const Location &loc); // move to new location in world
|
|
void move(const Location &loc, int16 num); // move to new location in world
|
|
void move(const TilePoint &tp); // move to new location in world
|
|
void updateImage(ObjectID); // move to new location in world,
|
|
// (assumes setLocation has been called)
|
|
|
|
// Remove an object from a stack of objects. Returns true if it was in a stack.
|
|
bool unstack();
|
|
|
|
// this correctly moves merged or stacked objects
|
|
bool moveMerged(const Location &loc);
|
|
bool moveMerged(const Location &loc, int16 num = 1);
|
|
bool moveMerged(const TilePoint &tp);
|
|
|
|
// Extract a merged object with specified merge number from another
|
|
// merged object and return its ID
|
|
ObjectID extractMerged(const Location &loc, int16 num);
|
|
GameObject *extractMerged(int16 num);
|
|
|
|
void moveRandom(const TilePoint &minLoc, const TilePoint &maxLoc); //move to random location Between Two Points
|
|
|
|
ObjectID copy(const Location &loc); // copy item to new context
|
|
ObjectID copy(const Location &loc, int16 num); // copy item to new context
|
|
|
|
// Create an alias of this object
|
|
ObjectID makeAlias(const Location &loc);
|
|
|
|
// move the item with a given context
|
|
void move(int16 slot); // move to new slot in container
|
|
|
|
// Activate the object
|
|
void activate();
|
|
|
|
// Deactivate this object
|
|
void deactivate();
|
|
|
|
// Determine if this object is an alias for another object
|
|
bool isAlias() {
|
|
return (_data.objectFlags & objectAlias) != 0;
|
|
}
|
|
|
|
// check to see if item can be contained by this object
|
|
bool canContain(ObjectID item) {
|
|
return prototype->canContain(thisID(), item);
|
|
}
|
|
|
|
// check to see if item is contained by the object
|
|
bool isContaining(GameObject *item);
|
|
|
|
// check if an instance of the specified target is contained in
|
|
// this object
|
|
bool isContaining(ObjectTarget *objTarget);
|
|
|
|
// determine wether this object has a specified property
|
|
bool hasProperty(const ObjectProperty &objProp) {
|
|
return objProp.operator()(this);
|
|
}
|
|
|
|
// Return the location of the first empty slot
|
|
TilePoint getFirstEmptySlot(GameObject *obj);
|
|
|
|
// Return the location of the first available slot within this object
|
|
// in which to place the specified object
|
|
bool getAvailableSlot(
|
|
GameObject *obj,
|
|
TilePoint *slot,
|
|
bool canMerge = false,
|
|
GameObject **mergeObj = NULL);
|
|
|
|
// Find a slot to place the specified object within this object and
|
|
// drop it in that slot
|
|
// If merge count == 0, then no auto-merging allowed
|
|
bool placeObject(
|
|
ObjectID enactor,
|
|
ObjectID objID,
|
|
bool canMerge = false,
|
|
int16 num = 1);
|
|
|
|
// Drop the specified object on the ground in a semi-random location
|
|
void dropInventoryObject(GameObject *obj, int16 count = 1);
|
|
|
|
//Get Specific Container From Object
|
|
GameObject *getIntangibleContainer(int containerType);
|
|
|
|
// generic actions
|
|
bool use(ObjectID enactor) {
|
|
return prototype->use(thisID(), enactor);
|
|
}
|
|
bool useOn(ObjectID enactor, ObjectID item) {
|
|
return prototype->useOn(thisID(), enactor, item);
|
|
}
|
|
|
|
bool useOn(ObjectID enactor, ActiveItem *item) {
|
|
return prototype->useOn(thisID(), enactor, item);
|
|
}
|
|
|
|
bool useOn(ObjectID enactor, Location &loc) {
|
|
return prototype->useOn(thisID(), enactor, loc);
|
|
}
|
|
|
|
// various verb actions that can take place
|
|
bool take(ObjectID enactor, int16 num = 1) {
|
|
return prototype->take(thisID(), enactor, num);
|
|
}
|
|
bool drop(ObjectID enactor, const Location &l, int16 num = 1) {
|
|
return prototype->drop(thisID(), enactor, l, num);
|
|
}
|
|
// drop an object onto another object and handle the result.
|
|
bool dropOn(ObjectID enactor, ObjectID target, int16 num = 1) {
|
|
return prototype->dropOn(thisID(), enactor, target, num);
|
|
}
|
|
// drop this object on a TAG
|
|
bool dropOn(ObjectID enactor, ActiveItem *target, const Location &loc, int16 num = 1) {
|
|
return prototype->dropOn(thisID(), enactor, target, loc, num);
|
|
}
|
|
bool open(ObjectID enactor) {
|
|
return prototype->open(thisID(), enactor);
|
|
}
|
|
bool close(ObjectID enactor) {
|
|
return prototype->close(thisID(), enactor);
|
|
}
|
|
bool strike(ObjectID enactor, ObjectID item) {
|
|
return prototype->strike(thisID(), enactor, item);
|
|
}
|
|
bool damage(ObjectID enactor, ObjectID target) {
|
|
return prototype->damage(thisID(), enactor, target);
|
|
}
|
|
bool eat(ObjectID enactor) {
|
|
return prototype->eat(thisID(), enactor);
|
|
}
|
|
bool insert(ObjectID enactor, ObjectID item) {
|
|
return prototype->insert(thisID(), enactor, item);
|
|
}
|
|
bool remove(ObjectID enactor) {
|
|
return prototype->remove(thisID(), enactor);
|
|
}
|
|
bool acceptDrop(ObjectID enactor, ObjectID droppedObj, int count) {
|
|
return prototype->acceptDrop(thisID(), enactor, droppedObj, count);
|
|
}
|
|
bool acceptDamage(
|
|
ObjectID enactor,
|
|
int8 absDamage,
|
|
effectDamageTypes dType = kDamageOther,
|
|
int8 dice = 0,
|
|
uint8 sides = 1,
|
|
int8 perDieMod = 0) {
|
|
if (_godmode)
|
|
return false;
|
|
|
|
return prototype->acceptDamage(
|
|
thisID(),
|
|
enactor,
|
|
absDamage,
|
|
dType,
|
|
dice,
|
|
sides,
|
|
perDieMod);
|
|
}
|
|
bool acceptHealing(ObjectID enactor, int8 absDamage, int8 dice = 0, uint8 sides = 1, int8 perDieMod = 0) {
|
|
return prototype->acceptHealing(thisID(), enactor, absDamage, dice, sides, perDieMod);
|
|
}
|
|
bool acceptStrike(
|
|
ObjectID enactor,
|
|
ObjectID strikingObj,
|
|
uint8 skillIndex) {
|
|
return prototype->acceptStrike(
|
|
thisID(),
|
|
enactor,
|
|
strikingObj,
|
|
skillIndex);
|
|
}
|
|
bool acceptLockToggle(ObjectID enactor, uint8 keyCode) {
|
|
return prototype->acceptLockToggle(thisID(), enactor, keyCode);
|
|
}
|
|
bool acceptMix(ObjectID enactor, ObjectID mixObj) {
|
|
return prototype->acceptMix(thisID(), enactor, mixObj);
|
|
}
|
|
bool acceptInsertion(ObjectID enactor, ObjectID item, int16 count) {
|
|
return prototype->acceptInsertion(thisID(), enactor, item, count);
|
|
}
|
|
bool acceptInsertionAt(ObjectID enactor, ObjectID item, const TilePoint &where, int16 num = 1) {
|
|
return prototype->acceptInsertionAt(thisID(), enactor, item, where, num);
|
|
}
|
|
|
|
// query functions:
|
|
ObjectID possessor(); // return actor posessing this object
|
|
|
|
// Access functions
|
|
ProtoObj *proto() {
|
|
return prototype;
|
|
}
|
|
TilePoint getLocation() const {
|
|
return _data.location;
|
|
}
|
|
TilePoint getWorldLocation();
|
|
bool getWorldLocation(Location &loc);
|
|
Location notGetLocation();
|
|
Location notGetWorldLocation();
|
|
|
|
// Return the name of this object (proper noun if it has one)
|
|
const char *objName() {
|
|
if (_data.nameIndex > 0)
|
|
return nameText((int16)_data.nameIndex);
|
|
else if (prototype)
|
|
return nameText((int16)prototype->nameIndex);
|
|
|
|
return nameText(0);
|
|
}
|
|
|
|
// return name of object, and it's quantity if merged
|
|
void objCursorText(char nameBuf[], const int8 size, int16 count = -1);
|
|
|
|
// find out if this is a trueskill
|
|
bool isTrueSkill();
|
|
|
|
// Access functions for name index
|
|
uint16 getNameIndex() {
|
|
return _data.nameIndex;
|
|
}
|
|
void setNameIndex(uint16 n) {
|
|
_data.nameIndex = n;
|
|
}
|
|
|
|
// Return the name of this type of object
|
|
const char *protoName() {
|
|
return nameText(prototype->nameIndex);
|
|
}
|
|
|
|
// Update the state of this object. This function is called every
|
|
// frame for every active object.
|
|
void updateState();
|
|
|
|
// Flag test functions
|
|
bool isOpen() {
|
|
return (int16)(_data.objectFlags & objectOpen);
|
|
}
|
|
bool isLocked() {
|
|
return (int16)(_data.objectFlags & objectLocked);
|
|
}
|
|
bool isImportant() {
|
|
return (int16)(_data.objectFlags & objectImportant);
|
|
}
|
|
bool isGhosted() {
|
|
return (_data.objectFlags & objectGhosted)
|
|
|| (prototype->flags & ResourceObjectPrototype::objPropGhosted);
|
|
}
|
|
bool isInvisible() {
|
|
return (_data.objectFlags & objectInvisible)
|
|
|| (prototype->flags & ResourceObjectPrototype::objPropHidden);
|
|
}
|
|
bool isMoving() {
|
|
return (int16)(_data.objectFlags & objectMoving);
|
|
}
|
|
bool isActivated() {
|
|
return (int16)(_data.objectFlags & objectActivated);
|
|
}
|
|
|
|
void setScavengable(bool val) {
|
|
if (val)
|
|
_data.objectFlags |= objectScavengable;
|
|
else
|
|
_data.objectFlags &= ~objectScavengable;
|
|
}
|
|
bool isScavengable() {
|
|
return (_data.objectFlags & objectScavengable) != 0;
|
|
}
|
|
|
|
void setObscured(bool val) {
|
|
if (val)
|
|
_data.objectFlags |= objectObscured;
|
|
else
|
|
_data.objectFlags &= ~objectObscured;
|
|
}
|
|
bool isObscured() {
|
|
return (_data.objectFlags & objectObscured) != 0;
|
|
}
|
|
|
|
void setTriggeringTAG(bool val) {
|
|
if (val)
|
|
_data.objectFlags |= objectTriggeringTAG;
|
|
else
|
|
_data.objectFlags &= ~objectTriggeringTAG;
|
|
}
|
|
bool isTriggeringTAG() {
|
|
return (_data.objectFlags & objectTriggeringTAG) != 0;
|
|
}
|
|
|
|
void setOnScreen(bool val) {
|
|
if (val)
|
|
_data.objectFlags |= objectOnScreen;
|
|
else
|
|
_data.objectFlags &= ~objectOnScreen;
|
|
}
|
|
bool isOnScreen() {
|
|
return (_data.objectFlags & objectOnScreen) != 0;
|
|
}
|
|
|
|
void setSightedByCenter(bool val) {
|
|
if (val)
|
|
_data.objectFlags |= objectSightedByCenter;
|
|
else
|
|
_data.objectFlags &= ~objectSightedByCenter;
|
|
}
|
|
bool isSightedByCenter() {
|
|
return (_data.objectFlags & objectSightedByCenter) != 0;
|
|
}
|
|
|
|
bool isMissile() {
|
|
return prototype->isMissile();
|
|
}
|
|
|
|
// image data
|
|
Sprite *getIconSprite(); // sprite when in inventory + cursor
|
|
Sprite *getGroundSprite(); // sprite when on ground
|
|
|
|
// world interaction type flags
|
|
uint16 containmentSet();
|
|
|
|
uint16 scriptClass() {
|
|
if (_data.script)
|
|
return _data.script;
|
|
if (prototype)
|
|
return prototype->script;
|
|
return 0;
|
|
}
|
|
|
|
// General access functions
|
|
|
|
// Script access functions
|
|
uint16 getScript() {
|
|
return _data.script;
|
|
}
|
|
void setScript(uint16 scr) {
|
|
_data.script = scr;
|
|
}
|
|
|
|
// access function to set object flags
|
|
void setFlags(uint8 newval, uint8 changeMask) {
|
|
// Only change the flags spec'd by changeFlags
|
|
_data.objectFlags = (newval & changeMask)
|
|
| (_data.objectFlags & ~changeMask);
|
|
}
|
|
|
|
// Access functions for hit points
|
|
uint8 getHitPoints() {
|
|
return _data.hitPoints;
|
|
}
|
|
void setHitPoints(uint8 hp) {
|
|
_data.hitPoints = hp;
|
|
}
|
|
|
|
// Builds the color remapping for this object based on the
|
|
// prototype's color map
|
|
void getColorTranslation(ColorTable map) {
|
|
prototype->getColorTranslation(map);
|
|
}
|
|
|
|
// Functions to get and set prototype (used by scripts)
|
|
int32 getProtoNum();
|
|
void setProtoNum(int32 nProto);
|
|
|
|
// Acess functions for extra data
|
|
uint16 getExtra() {
|
|
return _data.massCount;
|
|
}
|
|
void setExtra(uint16 x) {
|
|
_data.massCount = x;
|
|
}
|
|
|
|
// Function to evaluate the effects of all enchantments
|
|
void evalEnchantments();
|
|
|
|
bool makeSavingThrow() {
|
|
return prototype->makeSavingThrow();
|
|
}
|
|
|
|
// Generic range checking function
|
|
bool inRange(const TilePoint &tp, uint16 range);
|
|
|
|
// Generic function to test if object can be picked up
|
|
bool isCarryable() {
|
|
return prototype->mass <= 200 && prototype->bulk <= 200;
|
|
}
|
|
|
|
bool isMergeable() {
|
|
return (prototype->flags & ResourceObjectPrototype::objPropMergeable) != 0;
|
|
}
|
|
|
|
// A timer for this object has ticked
|
|
void timerTick(TimerID timer);
|
|
|
|
// A sensor for this object has sensed an object
|
|
void senseObject(SensorID sensor, ObjectID sensedObj);
|
|
|
|
// A sensor for this object has sensed an event
|
|
void senseEvent(
|
|
SensorID sensor,
|
|
int16 type,
|
|
ObjectID directObject,
|
|
ObjectID indirectObject);
|
|
|
|
// Timer related member functions
|
|
bool addTimer(TimerID id);
|
|
bool addTimer(TimerID id, int16 frameInterval);
|
|
void removeTimer(TimerID id);
|
|
void removeAllTimers();
|
|
|
|
// Sensor related member functions
|
|
private:
|
|
bool addSensor(Sensor *newSensor);
|
|
public:
|
|
bool addProtaganistSensor(SensorID id, int16 range);
|
|
bool addSpecificActorSensor(SensorID id, int16 range, Actor *a);
|
|
bool addSpecificObjectSensor(SensorID id, int16 range, ObjectID obj);
|
|
bool addActorPropertySensor(
|
|
SensorID id,
|
|
int16 range,
|
|
ActorPropertyID prop);
|
|
bool addObjectPropertySensor(
|
|
SensorID id,
|
|
int16 range,
|
|
ObjectPropertyID prop);
|
|
bool addEventSensor(SensorID id, int16 range, int16 eventType);
|
|
void removeSensor(SensorID id);
|
|
void removeAllSensors();
|
|
|
|
bool canSenseProtaganist(SenseInfo &info, int16 range);
|
|
bool canSenseSpecificActor(SenseInfo &info, int16 range, Actor *a);
|
|
bool canSenseSpecificObject(SenseInfo &info, int16 range, ObjectID obj);
|
|
bool canSenseActorProperty(
|
|
SenseInfo &info,
|
|
int16 range,
|
|
ActorPropertyID prop);
|
|
bool canSenseObjectProperty(
|
|
SenseInfo &info,
|
|
int16 range,
|
|
ObjectPropertyID prop);
|
|
|
|
static int32 canStackOrMerge(GameObject *dropObj, GameObject *target);
|
|
static void mergeWith(GameObject *dropObj, GameObject *target, int16 count);
|
|
|
|
bool merge(ObjectID enactor, ObjectID objToMergeID, int16 count);
|
|
bool stack(ObjectID enactor, ObjectID objToStackID);
|
|
|
|
bool canFitBulkwise(GameObject *obj) {
|
|
return prototype->canFitBulkwise(this, obj);
|
|
}
|
|
bool canFitMasswise(GameObject *obj) {
|
|
return prototype->canFitMasswise(this, obj);
|
|
}
|
|
|
|
uint16 totalContainedMass();
|
|
uint16 totalContainedBulk();
|
|
|
|
uint16 totalMass() {
|
|
return prototype->mass * (isMergeable() ? getExtra() : 1)
|
|
+ totalContainedMass();
|
|
}
|
|
uint16 totalBulk() {
|
|
return prototype->bulk * (isMergeable() ? getExtra() : 1);
|
|
}
|
|
|
|
uint16 massCapacity() {
|
|
return prototype->massCapacity(this);
|
|
}
|
|
uint16 bulkCapacity() {
|
|
return prototype->bulkCapacity(this);
|
|
}
|
|
};
|
|
|
|
/* ===================================================================== *
|
|
Sector struct
|
|
* ===================================================================== */
|
|
|
|
class Sector {
|
|
public:
|
|
uint16 activationCount;
|
|
ObjectID childID;
|
|
|
|
Sector() :
|
|
activationCount(0),
|
|
childID(Nothing) {
|
|
}
|
|
|
|
bool isActivated() {
|
|
return activationCount != 0;
|
|
}
|
|
|
|
void activate();
|
|
void deactivate();
|
|
|
|
void write(Common::MemoryWriteStreamDynamic *out);
|
|
void read(Common::InSaveFile *in);
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
GameWorld: Describes a world within the game
|
|
* ======================================================================= */
|
|
|
|
// Terminology note: A "sector" is a small portion of a map.
|
|
// All objects within a sector are stored on a single list.
|
|
|
|
// The size of a sector (length of side) in UV coodinates.
|
|
// A sector is an area of about 4x4 metatiles.
|
|
|
|
class GameWorld : public GameObject {
|
|
|
|
friend void initWorlds();
|
|
friend void cleanupWorlds();
|
|
friend void buildDisplayList();
|
|
|
|
friend class ProtoObj;
|
|
friend class GameObject;
|
|
friend class ObjectIterator;
|
|
|
|
public:
|
|
TilePoint size; // size of world in U/V coords
|
|
int16 sectorArraySize; // size of sector array
|
|
Sector *sectorArray; // array of sectors
|
|
int16 mapNum; // map number for this world.
|
|
|
|
// Default constructor
|
|
GameWorld() : sectorArraySize(0), sectorArray(nullptr), mapNum(0) {}
|
|
|
|
// Initial constructor
|
|
GameWorld(int16 map);
|
|
|
|
GameWorld(Common::SeekableReadStream *stream);
|
|
|
|
~GameWorld();
|
|
|
|
int32 archiveSize();
|
|
|
|
void cleanup();
|
|
|
|
Sector *getSector(int16 u, int16 v) {
|
|
if (u == -1 && v == -1)
|
|
return nullptr;
|
|
|
|
if (v * sectorArraySize + u >= sectorArraySize * sectorArraySize ||
|
|
v * sectorArraySize + u < 0) {
|
|
warning("Sector::getSector: Invalid sector: (%d, %d) (sectorArraySize = %d)", u, v, sectorArraySize);
|
|
return nullptr;
|
|
}
|
|
|
|
return &(sectorArray)[v * sectorArraySize + u];
|
|
}
|
|
|
|
TilePoint sectorSize() { // size of map in sectors
|
|
return TilePoint(sectorArraySize, sectorArraySize, 0);
|
|
}
|
|
|
|
static uint32 IDtoMapNum(ObjectID id) {
|
|
assert(isWorld(id));
|
|
return ((GameWorld *)GameObject::objectAddress(id))->mapNum;
|
|
}
|
|
};
|
|
|
|
void setCurrentWorld(ObjectID worldID);
|
|
|
|
extern GameWorld *currentWorld;
|
|
|
|
/* ======================================================================= *
|
|
GameObject inline member function
|
|
* ======================================================================= */
|
|
|
|
//------------------------------------------------------------------------
|
|
// Return the number of the map of the world on which this object resides.
|
|
|
|
inline int16 GameObject::getMapNum() {
|
|
if (world())
|
|
return world()->mapNum;
|
|
else if (_data.siblingID) {
|
|
GameObject *sibling = GameObject::objectAddress(_data.siblingID);
|
|
return sibling->getMapNum();
|
|
} else
|
|
return currentWorld->mapNum;
|
|
}
|
|
|
|
/* ======================================================================= *
|
|
Enchantment Class
|
|
* ======================================================================= */
|
|
//class Enchantment {
|
|
//
|
|
//public:
|
|
// Enchantment(ObjectID Skill,ObjectID Obj);
|
|
// ~Enchantment();
|
|
//
|
|
//};
|
|
|
|
/* ===================================================================== *
|
|
ActiveRegion class
|
|
* ===================================================================== */
|
|
|
|
class ActiveRegion {
|
|
|
|
friend void initActiveRegions();
|
|
friend void cleanupActiveRegions();
|
|
|
|
friend class ActiveRegionObjectIterator;
|
|
|
|
ObjectID anchor; // ID of object this region is attached to
|
|
TilePoint anchorLoc; // Location of anchor
|
|
ObjectID worldID;
|
|
TileRegion region; // Region coords ( in sectors )
|
|
|
|
public:
|
|
|
|
enum {
|
|
kActiveRegionSize = 22
|
|
};
|
|
|
|
ActiveRegion() : anchor(0), worldID(0) {}
|
|
void update();
|
|
|
|
void read(Common::InSaveFile *in);
|
|
void write(Common::MemoryWriteStreamDynamic *out);
|
|
|
|
// Return the current region in tile point coords
|
|
TileRegion getRegion() {
|
|
TileRegion tReg;
|
|
|
|
tReg.min.u = region.min.u << kSectorShift;
|
|
tReg.min.v = region.min.v << kSectorShift;
|
|
tReg.max.u = region.max.u << kSectorShift;
|
|
tReg.max.v = region.max.v << kSectorShift;
|
|
tReg.min.z = tReg.max.z = 0;
|
|
|
|
return tReg;
|
|
}
|
|
|
|
// Return the region world
|
|
GameWorld *getWorld() {
|
|
return (GameWorld *)GameObject::objectAddress(worldID);
|
|
}
|
|
};
|
|
|
|
void updateActiveRegions();
|
|
|
|
// Return a pointer to an active region given its PlayerActor's ID
|
|
ActiveRegion *getActiveRegion(PlayerActorID id);
|
|
|
|
void initActiveRegions();
|
|
void saveActiveRegions(Common::OutSaveFile *outS);
|
|
void loadActiveRegions(Common::InSaveFile *in);
|
|
inline void cleanupActiveRegions() {}
|
|
|
|
/* ======================================================================= *
|
|
ObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// This class simply defines a standard interface for all derived
|
|
// object iterator classes.
|
|
|
|
class ObjectIterator {
|
|
public:
|
|
// Virtual destructor
|
|
virtual ~ObjectIterator() {}
|
|
|
|
// Iteration functions
|
|
virtual ObjectID first(GameObject **obj) = 0;
|
|
virtual ObjectID next(GameObject **obj) = 0;
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
SectorRegionObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// This class iterates through every object within a given region of
|
|
// sectors.
|
|
|
|
class SectorRegionObjectIterator : public ObjectIterator {
|
|
|
|
TilePoint minSector,
|
|
maxSector,
|
|
sectorCoords;
|
|
GameWorld *searchWorld;
|
|
GameObject *_currentObject;
|
|
|
|
public:
|
|
// Constructor
|
|
SectorRegionObjectIterator(GameWorld *world);
|
|
|
|
// Constructor
|
|
SectorRegionObjectIterator(
|
|
GameWorld *world,
|
|
const TileRegion §orRegion) :
|
|
searchWorld(world),
|
|
minSector(sectorRegion.min),
|
|
maxSector(sectorRegion.max),
|
|
_currentObject(nullptr) {
|
|
assert(searchWorld != NULL);
|
|
assert(isWorld(searchWorld));
|
|
}
|
|
|
|
protected:
|
|
GameWorld *getSearchWorld() {
|
|
return searchWorld;
|
|
}
|
|
|
|
public:
|
|
// Iteration functions
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
RadialObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// This class will iterate through all objects within a given radius of
|
|
// a given center point.
|
|
|
|
class RadialObjectIterator : public SectorRegionObjectIterator {
|
|
private:
|
|
|
|
TilePoint center;
|
|
int16 radius;
|
|
|
|
// Compute the region of sectors to pass to the ObjectIterator
|
|
// constructor
|
|
static TileRegion computeSectorRegion(
|
|
const TilePoint §ors,
|
|
const TilePoint ¢er,
|
|
int16 radius);
|
|
|
|
// Compute the distance to the specified point from the search
|
|
// center
|
|
virtual int16 computeDist(const TilePoint &tp) = 0;
|
|
|
|
protected:
|
|
|
|
// Simply return the center coordinates
|
|
TilePoint getCenter() {
|
|
return center;
|
|
}
|
|
|
|
public:
|
|
|
|
// Constructor
|
|
RadialObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &searchCenter,
|
|
int16 distance) :
|
|
SectorRegionObjectIterator(
|
|
world,
|
|
computeSectorRegion(
|
|
world->sectorSize(),
|
|
searchCenter,
|
|
distance)),
|
|
center(searchCenter),
|
|
radius(distance) {
|
|
}
|
|
|
|
// Return the first object found
|
|
ObjectID first(GameObject **obj, int16 *dist);
|
|
// Return the next object found
|
|
ObjectID next(GameObject **obj, int16 *dist);
|
|
|
|
// Return the first object found
|
|
ObjectID first(GameObject **obj) {
|
|
return first(obj, NULL);
|
|
}
|
|
// Return the next object found
|
|
ObjectID next(GameObject **obj) {
|
|
return next(obj, NULL);
|
|
}
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
CircularObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a circular region
|
|
|
|
class CircularObjectIterator : public RadialObjectIterator {
|
|
protected:
|
|
|
|
// Compute the distance to the specified point from the center
|
|
int16 computeDist(const TilePoint &tp);
|
|
|
|
public:
|
|
// Constructor
|
|
CircularObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &searchCenter,
|
|
int16 distance) :
|
|
RadialObjectIterator(world, searchCenter, distance) {
|
|
}
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
RingObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a circular region
|
|
|
|
class RingObjectIterator : public CircularObjectIterator {
|
|
private:
|
|
|
|
int16 innerDist;
|
|
|
|
public:
|
|
// Constructor
|
|
RingObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &searchCenter,
|
|
int16 outerDistance,
|
|
int16 innerDistance) :
|
|
CircularObjectIterator(world, searchCenter, outerDistance) {
|
|
innerDist = innerDistance;
|
|
}
|
|
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
DispRegionObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a region parallel to the display
|
|
// area
|
|
|
|
class DispRegionObjectIterator : public RadialObjectIterator {
|
|
private:
|
|
|
|
// Compute the distance to the specified point from the center
|
|
int16 computeDist(const TilePoint &tp);
|
|
|
|
public:
|
|
// Constructor
|
|
DispRegionObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &searchCenter,
|
|
int16 distance) :
|
|
RadialObjectIterator(world, searchCenter, distance) {
|
|
}
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
RegionalObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a rectangular region
|
|
|
|
class RegionalObjectIterator : public SectorRegionObjectIterator {
|
|
|
|
TilePoint minCoords,
|
|
maxCoords;
|
|
|
|
// Calculate the sector region to pass to the ObjectIterator
|
|
// constructor
|
|
static TileRegion computeSectorRegion(
|
|
const TilePoint §ors,
|
|
const TilePoint &min,
|
|
const TilePoint &max);
|
|
|
|
// Test to see if the specified point is within the region
|
|
bool inRegion(const TilePoint &tp);
|
|
|
|
public:
|
|
// Constructor
|
|
RegionalObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &min,
|
|
const TilePoint &max) :
|
|
SectorRegionObjectIterator(
|
|
world,
|
|
computeSectorRegion(world->sectorSize(), min, max)),
|
|
minCoords(min),
|
|
maxCoords(max) {
|
|
}
|
|
|
|
// Iteration functions
|
|
virtual ObjectID first(GameObject **obj);
|
|
virtual ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
RectangularObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a rectangular region
|
|
|
|
class RectangularObjectIterator : public RegionalObjectIterator {
|
|
|
|
TilePoint center,
|
|
coords1,
|
|
coords2,
|
|
coords3,
|
|
coords4;
|
|
|
|
// Test to see if the specified point is within the region
|
|
bool inRegion(const TilePoint &tp);
|
|
|
|
public:
|
|
// Constructor
|
|
RectangularObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &c,
|
|
const TilePoint &cdelta1,
|
|
const TilePoint &cdelta2);
|
|
|
|
virtual ObjectID first(GameObject **obj);
|
|
virtual ObjectID next(GameObject **obj);
|
|
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
TriangularObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
// Iterate through all objects within a rectangular region
|
|
|
|
class TriangularObjectIterator : public RegionalObjectIterator {
|
|
|
|
TilePoint coords1,
|
|
coords2,
|
|
coords3;
|
|
|
|
// Test to see if the specified point is within the region
|
|
bool inRegion(const TilePoint &tp);
|
|
|
|
public:
|
|
// Constructor
|
|
TriangularObjectIterator(
|
|
GameWorld *world,
|
|
const TilePoint &c1,
|
|
const TilePoint &c2,
|
|
const TilePoint &c3);
|
|
|
|
// Iteration functions
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
CenterRegionObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
class CenterRegionObjectIterator : public RegionalObjectIterator {
|
|
|
|
static GameWorld *CenterWorld();
|
|
static TilePoint MinCenterRegion();
|
|
static TilePoint MaxCenterRegion();
|
|
|
|
public:
|
|
// Constructor
|
|
CenterRegionObjectIterator() :
|
|
RegionalObjectIterator(CenterWorld(),
|
|
MinCenterRegion(),
|
|
MaxCenterRegion()) {}
|
|
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
ActiveRegionObjectIterator Class
|
|
* ======================================================================= */
|
|
|
|
class ActiveRegionObjectIterator : public ObjectIterator {
|
|
|
|
int16 activeRegionIndex;
|
|
TilePoint baseSectorCoords,
|
|
size,
|
|
sectorCoords;
|
|
uint8 sectorBitMask;
|
|
GameWorld *currentWorld;
|
|
GameObject *_currentObject;
|
|
|
|
bool firstActiveRegion();
|
|
bool nextActiveRegion();
|
|
bool firstSector();
|
|
bool nextSector();
|
|
|
|
public:
|
|
// Constructor
|
|
ActiveRegionObjectIterator() : activeRegionIndex(-1), sectorBitMask(0), currentWorld(nullptr), _currentObject(nullptr) {}
|
|
|
|
// Iteration functions
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ============================================================================ *
|
|
Container Iterator Class
|
|
* ============================================================================ */
|
|
|
|
// This class iterates through every object within a container
|
|
|
|
class ContainerIterator {
|
|
ObjectID nextID;
|
|
|
|
public:
|
|
GameObject *object;
|
|
|
|
// Constructor
|
|
ContainerIterator(GameObject *container);
|
|
|
|
// Iteration function
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
/* ============================================================================ *
|
|
Recursive Container iterator Class
|
|
* ============================================================================ */
|
|
|
|
// This class iterates through every object within a container and
|
|
// all of the containers within the container
|
|
|
|
#if 0
|
|
class RecursiveContainerIterator {
|
|
ObjectID id;
|
|
RecursiveContainerIterator *subIter;
|
|
|
|
public:
|
|
// Constructor
|
|
RecursiveContainerIterator(GameObject *container) :
|
|
id(container->IDChild()),
|
|
subIter(NULL) {
|
|
}
|
|
~RecursiveContainerIterator();
|
|
|
|
// Iteration functions
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
#else
|
|
|
|
class RecursiveContainerIterator {
|
|
ObjectID id,
|
|
root;
|
|
|
|
public:
|
|
// Constructor
|
|
RecursiveContainerIterator(GameObject *container) :
|
|
root(container->thisID()), id(0) {}
|
|
|
|
// Iteration functions
|
|
ObjectID first(GameObject **obj);
|
|
ObjectID next(GameObject **obj);
|
|
};
|
|
|
|
#endif
|
|
|
|
/* ============================================================================ *
|
|
Object sound effect struct
|
|
* ============================================================================ */
|
|
|
|
struct ObjectSoundFXs {
|
|
uint8 soundFXHitFlesh,
|
|
soundFXHitHard,
|
|
soundFXParried,
|
|
soundFXMissed;
|
|
};
|
|
|
|
/* ======================================================================= *
|
|
Misc Prototypes
|
|
* ======================================================================= */
|
|
|
|
|
|
// Defines values for sixteen missile facings, plus a value for no
|
|
// missile facing.
|
|
enum MissileFacings {
|
|
missileUp,
|
|
missileUpUpLf,
|
|
missileUpLf,
|
|
missileUpLfLf,
|
|
missileLf,
|
|
missileDnLfLf,
|
|
missileDnLf,
|
|
missileDnDnLf,
|
|
missileDn,
|
|
missileDnDnRt,
|
|
missileDnRt,
|
|
missileDnRtRt,
|
|
missileRt,
|
|
missileUpRtRt,
|
|
missileUpRt,
|
|
missileUpUpRt,
|
|
missileNoFacing
|
|
};
|
|
|
|
enum blockageType {
|
|
blockageNone = 0,
|
|
blockageTerrain,
|
|
blockageObject
|
|
};
|
|
|
|
uint32 objectTerrain(GameObject *obj);
|
|
|
|
// Return an object which is in collision with another object.
|
|
GameObject *objectCollision(GameObject *obj, GameWorld *world, const TilePoint &loc);
|
|
|
|
// Test for line of sight between two objects
|
|
bool lineOfSight(GameObject *obj1, GameObject *obj2, uint32 terrainMask);
|
|
bool lineOfSight(GameObject *obj, const TilePoint &loc, uint32 terrainMask);
|
|
bool lineOfSight(
|
|
GameWorld *world,
|
|
const TilePoint &loc1,
|
|
const TilePoint &loc2,
|
|
uint32 terrainMask);
|
|
|
|
// Test if object is obscured by terrain
|
|
bool objObscured(GameObject *testObj);
|
|
|
|
// Determine which object mouse pointer is picking
|
|
ObjectID pickObject(const StaticPoint32 &mouse, StaticTilePoint &objPos);
|
|
|
|
// Create enchantment attach it to object
|
|
ObjectID EnchantObject(
|
|
ObjectID target,
|
|
int enchantmentType,
|
|
int duration);
|
|
|
|
// Find an enchantment of a particular type
|
|
ObjectID FindObjectEnchantment(
|
|
ObjectID target,
|
|
int enchantmentType);
|
|
|
|
// Remove an enchantment of a particular type
|
|
bool DispelObjectEnchantment(
|
|
ObjectID target,
|
|
int enchantmentType);
|
|
|
|
// Function to eval the enchantments on an actor
|
|
void evalActorEnchantments(Actor *a);
|
|
|
|
// Function to eval the enchantments on an actor
|
|
void evalObjectEnchantments(GameObject *obj);
|
|
|
|
// Load prototypes from resource file
|
|
void initPrototypes();
|
|
|
|
// Cleanup the prototype lists
|
|
void cleanupPrototypes();
|
|
|
|
// Load the sound effects table
|
|
void initObjectSoundFXTable();
|
|
|
|
// Cleanup the sound effects table
|
|
void cleanupObjectSoundFXTable();
|
|
|
|
// Allocate array to hold the counts of the temp actors
|
|
void initTempActorCount();
|
|
|
|
// Save the array of temp actor counts
|
|
void saveTempActorCount(Common::OutSaveFile *outS);
|
|
|
|
// Load the array of temp actor counts
|
|
void loadTempActorCount(Common::InSaveFile *in, int32 chunkSize);
|
|
|
|
// Cleanup the array to temp actor counts
|
|
void cleanupTempActorCount();
|
|
|
|
// Increment the temporary actor count for the specified prototype
|
|
void incTempActorCount(uint16 protoNum);
|
|
|
|
// Decrement the temporary actor count for the specified prototype
|
|
void decTempActorCount(uint16 protoNum);
|
|
|
|
// Return the number of temporary actors for the specified prototype
|
|
uint16 getTempActorCount(uint16 protoNum);
|
|
|
|
// Init game worlds
|
|
void initWorlds();
|
|
|
|
// Save worlds to the save file
|
|
void saveWorlds(Common::OutSaveFile *outS);
|
|
|
|
// Load worlds from the save file
|
|
void loadWorlds(Common::InSaveFile *in);
|
|
|
|
// Cleanup game worlds
|
|
void cleanupWorlds();
|
|
|
|
// Initialize object list
|
|
void initObjects();
|
|
|
|
// Save the objects to the save file
|
|
void saveObjects(Common::OutSaveFile *outS);
|
|
|
|
// Load the objects from the save file
|
|
void loadObjects(Common::InSaveFile *in);
|
|
|
|
// Cleanup object list
|
|
void cleanupObjects();
|
|
|
|
// Do background processing for objects
|
|
void doBackgroundSimulation();
|
|
|
|
void pauseBackgroundSimulation();
|
|
void resumeBackgroundSimulation();
|
|
|
|
// This function simply calls the GameObject::updateState() method
|
|
// for all active objects directly within a world.
|
|
void updateObjectStates();
|
|
|
|
void pauseObjectStates();
|
|
void resumeObjectStates();
|
|
|
|
void readyContainerSetup();
|
|
void cleanupReadyContainers();
|
|
|
|
} // end of namespace Saga2
|
|
|
|
#endif
|