From 6160ee3cf2f0cb93807ea115b94601b11d5543c4 Mon Sep 17 00:00:00 2001 From: johndoe123 Date: Fri, 28 Sep 2012 16:49:36 +0000 Subject: NEVERHOOD: Move code from entity.h to new entity.cpp --- engines/neverhood/entity.cpp | 115 +++++++++++++++++++++++++++++++++++++++++++ engines/neverhood/entity.h | 98 +++++++++++------------------------- engines/neverhood/module.mk | 1 + 3 files changed, 145 insertions(+), 69 deletions(-) create mode 100644 engines/neverhood/entity.cpp diff --git a/engines/neverhood/entity.cpp b/engines/neverhood/entity.cpp new file mode 100644 index 0000000000..e837225998 --- /dev/null +++ b/engines/neverhood/entity.cpp @@ -0,0 +1,115 @@ +/* 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 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "neverhood/entity.h" + +namespace Neverhood { + +uint32 MessageParam::asInteger() const { + assert(_type == mptInteger); + return _integer; +} + +NPoint MessageParam::asPoint() const { + assert(_type == mptInteger || _type == mptPoint); + if (_type == mptInteger) { + NPoint pt; + pt.x = _integer & 0xFFFF; + pt.y = (_integer >> 16) & 0xFFFF; + return pt; + } + return _point; +} + +Entity *MessageParam::asEntity() const { + assert(_type == mptEntity); + return _entity; +} + +// TODO: Disable heavy debug stuff in release mode + +#define SetUpdateHandler(handler) _updateHandlerCb = static_cast (handler); debug(2, "SetUpdateHandler(" #handler ")"); _updateHandlerCbName = #handler +#define SetMessageHandler(handler) _messageHandlerCb = static_cast (handler); debug(2, "SetMessageHandler(" #handler ")"); _messageHandlerCbName = #handler + +Entity::Entity(NeverhoodEngine *vm, int priority) + : _vm(vm), _updateHandlerCb(NULL), _messageHandlerCb(NULL), _priority(priority), _name("Entity") { +} + +Entity::~Entity() { +} + +void Entity::draw() { +} + +void Entity::handleUpdate() { + //debug("Entity(%s).handleUpdate", _name.c_str()); + debug(2, "handleUpdate() -> [%s]", _updateHandlerCbName.c_str()); + if (_updateHandlerCb) + (this->*_updateHandlerCb)(); +} + +uint32 Entity::receiveMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + debug(2, "receiveMessage(%04X) -> [%s]", messageNum, _messageHandlerCbName.c_str()); + return _messageHandlerCb ? (this->*_messageHandlerCb)(messageNum, param, sender) : 0; +} + +uint32 Entity::sendMessage(Entity *receiver, int messageNum, const MessageParam ¶m) { + return receiver ? receiver->receiveMessage(messageNum, param, this) : 0; +} + +uint32 Entity::sendMessage(Entity *receiver, int messageNum, uint32 param) { + return sendMessage(receiver, messageNum, MessageParam(param)); +} + +uint32 Entity::sendPointMessage(Entity *receiver, int messageNum, const NPoint ¶m) { + return sendMessage(receiver, messageNum, MessageParam(param)); +} + +uint32 Entity::sendEntityMessage(Entity *receiver, int messageNum, Entity *param) { + return sendMessage(receiver, messageNum, MessageParam((Entity*)param)); +} + +uint32 Entity::getGlobalVar(uint32 nameHash) { + return _vm->_gameVars->getGlobalVar(nameHash); +} + +void Entity::setGlobalVar(uint32 nameHash, uint32 value) { + _vm->_gameVars->setGlobalVar(nameHash, value); +} + +uint32 Entity::getSubVar(uint32 nameHash, uint32 subNameHash) { + return _vm->_gameVars->getSubVar(nameHash, subNameHash); +} + +void Entity::setSubVar(uint32 nameHash, uint32 subNameHash, uint32 value) { + _vm->_gameVars->setSubVar(nameHash, subNameHash, value); +} + +void Entity::incGlobalVar(uint32 nameHash, int incrValue) { + setGlobalVar(nameHash, getGlobalVar(nameHash) + incrValue); +} + +void Entity::incSubVar(uint32 nameHash, uint32 subNameHash, int incrValue) { + setSubVar(nameHash, subNameHash, getSubVar(nameHash, subNameHash) + incrValue); +} + +} // End of namespace Neverhood diff --git a/engines/neverhood/entity.h b/engines/neverhood/entity.h index 22eb780024..0f96eba3b4 100644 --- a/engines/neverhood/entity.h +++ b/engines/neverhood/entity.h @@ -44,24 +44,9 @@ public: MessageParam(uint32 value) : _type(mptInteger), _integer(value) {} MessageParam(NPoint value) : _type(mptPoint), _point(value) {} MessageParam(Entity *entity) : _type(mptEntity), _entity(entity) {} - uint32 asInteger() const { - assert(_type == mptInteger); - return _integer; - } - NPoint asPoint() const { - assert(_type == mptInteger || _type == mptPoint); - if (_type == mptInteger) { - NPoint pt; - pt.x = _integer & 0xFFFF; - pt.y = (_integer >> 16) & 0xFFFF; - return pt; - } - return _point; - } - Entity *asEntity() const { - assert(_type == mptEntity); - return _entity; - } + uint32 asInteger() const; + NPoint asPoint() const; + Entity *asEntity() const; protected: union { uint32 _integer; @@ -75,66 +60,41 @@ protected: // TODO: Disable heavy debug stuff in release mode -#define SetUpdateHandler(handler) _updateHandlerCb = static_cast (handler); debug(2, "SetUpdateHandler(" #handler ")"); _updateHandlerCbName = #handler -#define SetMessageHandler(handler) _messageHandlerCb = static_cast (handler); debug(2, "SetMessageHandler(" #handler ")"); _messageHandlerCbName = #handler +#define SetUpdateHandler(handler) \ + _updateHandlerCb = static_cast (handler); \ + debug(2, "SetUpdateHandler(" #handler ")"); \ + _updateHandlerCbName = #handler + +#define SetMessageHandler(handler) \ + _messageHandlerCb = static_cast (handler); \ + debug(2, "SetMessageHandler(" #handler ")"); \ + _messageHandlerCbName = #handler class Entity { public: Common::String _name; // Entity name for debugging purposes Common::String _updateHandlerCbName; Common::String _messageHandlerCbName; - Entity(NeverhoodEngine *vm, int priority) - : _vm(vm), _updateHandlerCb(NULL), _messageHandlerCb(NULL), _priority(priority), _name("Entity") { - } - virtual ~Entity() { - } - virtual void draw() { - } - void handleUpdate() { - //debug("Entity(%s).handleUpdate", _name.c_str()); - debug(2, "handleUpdate() -> [%s]", _updateHandlerCbName.c_str()); - if (_updateHandlerCb) - (this->*_updateHandlerCb)(); - } - bool hasMessageHandler() const { return _messageHandlerCb != NULL; } - uint32 receiveMessage(int messageNum, const MessageParam ¶m, Entity *sender) { - debug(2, "receiveMessage(%04X) -> [%s]", messageNum, _messageHandlerCbName.c_str()); - return _messageHandlerCb ? (this->*_messageHandlerCb)(messageNum, param, sender) : 0; - } + Entity(NeverhoodEngine *vm, int priority); + virtual ~Entity(); + virtual void draw(); + void handleUpdate(); + uint32 receiveMessage(int messageNum, const MessageParam ¶m, Entity *sender); // NOTE: These were overloaded before for the various message parameter types // it caused some problems so each type gets its own sendMessage variant now - uint32 sendMessage(Entity *receiver, int messageNum, const MessageParam ¶m) { - return receiver ? receiver->receiveMessage(messageNum, param, this) : 0; - } - uint32 sendMessage(Entity *receiver, int messageNum, uint32 param) { - return sendMessage(receiver, messageNum, MessageParam(param)); - } - uint32 sendPointMessage(Entity *receiver, int messageNum, const NPoint ¶m) { - return sendMessage(receiver, messageNum, MessageParam(param)); - } - uint32 sendEntityMessage(Entity *receiver, int messageNum, Entity *param) { - return sendMessage(receiver, messageNum, MessageParam((Entity*)param)); - } - int getPriority() const { return _priority; } + uint32 sendMessage(Entity *receiver, int messageNum, const MessageParam ¶m); + uint32 sendMessage(Entity *receiver, int messageNum, uint32 param); + uint32 sendPointMessage(Entity *receiver, int messageNum, const NPoint ¶m); + uint32 sendEntityMessage(Entity *receiver, int messageNum, Entity *param); // Shortcuts for game variable access - uint32 getGlobalVar(uint32 nameHash) { - return _vm->_gameVars->getGlobalVar(nameHash); - } - void setGlobalVar(uint32 nameHash, uint32 value) { - _vm->_gameVars->setGlobalVar(nameHash, value); - } - uint32 getSubVar(uint32 nameHash, uint32 subNameHash) { - return _vm->_gameVars->getSubVar(nameHash, subNameHash); - } - void setSubVar(uint32 nameHash, uint32 subNameHash, uint32 value) { - _vm->_gameVars->setSubVar(nameHash, subNameHash, value); - } - void incGlobalVar(uint32 nameHash, int incrValue) { - setGlobalVar(nameHash, getGlobalVar(nameHash) + incrValue); - } - void incSubVar(uint32 nameHash, uint32 subNameHash, int incrValue) { - setSubVar(nameHash, subNameHash, getSubVar(nameHash, subNameHash) + incrValue); - } + uint32 getGlobalVar(uint32 nameHash); + void setGlobalVar(uint32 nameHash, uint32 value); + uint32 getSubVar(uint32 nameHash, uint32 subNameHash); + void setSubVar(uint32 nameHash, uint32 subNameHash, uint32 value); + void incGlobalVar(uint32 nameHash, int incrValue); + void incSubVar(uint32 nameHash, uint32 subNameHash, int incrValue); + int getPriority() const { return _priority; } + bool hasMessageHandler() const { return _messageHandlerCb != NULL; } protected: void (Entity::*_updateHandlerCb)(); uint32 (Entity::*_messageHandlerCb)(int messageNum, const MessageParam ¶m, Entity *sender); diff --git a/engines/neverhood/module.mk b/engines/neverhood/module.mk index f9f349b04b..2ee28d2440 100644 --- a/engines/neverhood/module.mk +++ b/engines/neverhood/module.mk @@ -6,6 +6,7 @@ MODULE_OBJS = \ collisionman.o \ detection.o \ diskplayerscene.o \ + entity.o \ gamemodule.o \ gamevars.o \ graphics.o \ -- cgit v1.2.3