From bb67c2c2ffdb8794d08fd1937a533caec2465a62 Mon Sep 17 00:00:00 2001 From: johndoe123 Date: Thu, 13 Mar 2014 11:54:56 +0100 Subject: ILLUSIONS: Start with ScriptResource and related code --- engines/illusions/illusions.cpp | 9 ++ engines/illusions/illusions.h | 3 + engines/illusions/module.mk | 1 + engines/illusions/scriptresource.cpp | 197 +++++++++++++++++++++++++++++++++++ engines/illusions/scriptresource.h | 108 +++++++++++++++++++ 5 files changed, 318 insertions(+) create mode 100644 engines/illusions/scriptresource.cpp create mode 100644 engines/illusions/scriptresource.h diff --git a/engines/illusions/illusions.cpp b/engines/illusions/illusions.cpp index 06662fb4aa..17fb730a50 100644 --- a/engines/illusions/illusions.cpp +++ b/engines/illusions/illusions.cpp @@ -32,6 +32,7 @@ #include "illusions/actor.h" #include "illusions/actorresource.h" #include "illusions/thread.h" +#include "illusions/scriptresource.h" #include "audio/audiostream.h" #include "common/config-manager.h" @@ -80,6 +81,7 @@ Common::Error IllusionsEngine::run() { _resSys = new ResourceSystem(); _resSys->addResourceLoader(0x00060000, new ActorResourceLoader(this)); + _resSys->addResourceLoader(0x000D0000, new ScriptResourceLoader(this)); _resSys->addResourceLoader(0x00100000, new ActorResourceLoader(this)); _resSys->addResourceLoader(0x00110000, new BackgroundResourceLoader(this)); @@ -87,15 +89,22 @@ Common::Error IllusionsEngine::run() { _backgroundItems = new BackgroundItems(this); _camera = new Camera(this); + /* + // ActorResource test _resSys->loadResource(0x00100006, 0, 0); + */ /* + // BackgroundResource test _resSys->loadResource(0x0011000B, 0, 0); BackgroundItem *backgroundItem = _backgroundItems->debugFirst(); _system->copyRectToScreen(backgroundItem->_surfaces[0]->getPixels(), backgroundItem->_surfaces[0]->pitch, 0, 0, 640, 480); _system->updateScreen(); */ + + // ScriptResource test + _resSys->loadResource(0x000D0001, 0, 0); while (!shouldQuit()) { updateEvents(); diff --git a/engines/illusions/illusions.h b/engines/illusions/illusions.h index f375477b47..f283f17255 100644 --- a/engines/illusions/illusions.h +++ b/engines/illusions/illusions.h @@ -54,6 +54,7 @@ class BackgroundItem; class BackgroundItems; class BackgroundResource; class Camera; +class ScriptResource; class IllusionsEngine : public Engine { protected: @@ -76,6 +77,8 @@ public: ActorItems *_actorItems; BackgroundItems *_backgroundItems; Camera *_camera; + + ScriptResource *_scriptResource; // Screen functions Graphics::Surface *allocSurface(int16 width, int16 height); diff --git a/engines/illusions/module.mk b/engines/illusions/module.mk index 99e84f5efb..e8d83eff88 100644 --- a/engines/illusions/module.mk +++ b/engines/illusions/module.mk @@ -11,6 +11,7 @@ MODULE_OBJS := \ illusions.o \ input.o \ resourcesystem.o \ + scriptresource.o \ spritedecompressqueue.o \ spritedrawqueue.o \ thread.o \ diff --git a/engines/illusions/scriptresource.cpp b/engines/illusions/scriptresource.cpp new file mode 100644 index 0000000000..27f5cad5e1 --- /dev/null +++ b/engines/illusions/scriptresource.cpp @@ -0,0 +1,197 @@ +/* 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 "illusions/illusions.h" +#include "illusions/scriptresource.h" + +namespace Illusions { + +// ScriptResourceLoader + +void ScriptResourceLoader::load(Resource *resource) { + debug("ScriptResourceLoader::load() Loading script %08X from %s...", resource->_resId, resource->_filename.c_str()); + + ScriptResource *scriptResource = new ScriptResource(); + scriptResource->load(resource->_data, resource->_dataSize); + + + + _vm->_scriptResource = scriptResource; + +} + +void ScriptResourceLoader::unload(Resource *resource) { +} + +void ScriptResourceLoader::buildFilename(Resource *resource) { + resource->_filename = Common::String::format("%08X.scr", resource->_resId); +} + +bool ScriptResourceLoader::isFlag(int flag) { + return + flag == kRlfLoadFile; +} + +Properties::Properties() + : _count(0), _properties(0) { +} + +void Properties::init(uint count, byte *properties) { + _count = count; + _properties = properties; +} + +// BlockCounters + +BlockCounters::BlockCounters() + : _count(0), _blockCounters(0) { +} + +void BlockCounters::init(uint count, byte *blockCounters) { + _count = count; + _blockCounters = blockCounters; +} + + +// TriggerCause + +void TriggerCause::load(Common::SeekableReadStream &stream) { + _verbId = stream.readUint32LE(); + _objectId2 = stream.readUint32LE(); + _codeOffs = stream.readUint32LE(); + + debug("TriggerCause::load() _verbId: %08X; _objectId2: %08X; _codeOffs: %08X", + _verbId, _objectId2, _codeOffs); +} + +// TriggerObject + +TriggerObject::TriggerObject() + : _causesCount(0), _causes(0) { +} + +TriggerObject::~TriggerObject() { + delete[] _causes; +} + +void TriggerObject::load(byte *dataStart, Common::SeekableReadStream &stream) { + _objectId = stream.readUint32LE(); + _causesCount = stream.readUint16LE(); + stream.skip(2); // Skip padding + debug("TriggerObject::load() _objectId: %08X; _causesCount: %d", + _objectId, _causesCount); + _causes = new TriggerCause[_causesCount]; + for (uint i = 0; i < _causesCount; ++i) + _causes[i].load(stream); +} + +// ProgInfo + +ProgInfo::ProgInfo() + : _triggerObjectsCount(0), _triggerObjects(0) { +} + +ProgInfo::~ProgInfo() { + delete[] _triggerObjects; +} + +char *debugW2I(byte *wstr) { + static char buf[65]; + char *p = buf; + while (*wstr != 0) { + *p++ = *wstr; + wstr += 2; + } + *p = 0; + return buf; +} + +void ProgInfo::load(byte *dataStart, Common::SeekableReadStream &stream) { + _id = stream.readUint16LE(); + _unk = stream.readUint16LE(); + _name = dataStart + stream.pos(); + stream.skip(128); + _triggerObjectsCount = stream.readUint16LE(); + stream.skip(2); // Skip padding + debug("\nProgInfo::load() _id: %d; _unk: %d; _name: [%s]", + _id, _unk, debugW2I(_name)); + uint32 triggerObjectsListOffs = stream.readUint32LE(); + if (_triggerObjectsCount > 0) { + _triggerObjects = new TriggerObject[_triggerObjectsCount]; + for (uint i = 0; i < _triggerObjectsCount; ++i) { + stream.seek(triggerObjectsListOffs + i * 4); + uint32 triggerObjectOffs = stream.readUint32LE(); + stream.seek(triggerObjectOffs); + _triggerObjects[i].load(dataStart, stream); + } + } +} + +// ScriptResource + +ScriptResource::ScriptResource() + : _codeOffsets(0) { +} + +ScriptResource::~ScriptResource() { + delete[] _codeOffsets; +} + +void ScriptResource::load(byte *data, uint32 dataSize) { + Common::MemoryReadStream stream(data, dataSize, DisposeAfterUse::NO); + + stream.skip(4); // Skip unused + uint propertiesCount = stream.readUint16LE(); + uint blockCountersCount = stream.readUint16LE(); + uint codeCount = stream.readUint16LE(); + _progInfosCount = stream.readUint16LE(); + uint32 propertiesOffs = stream.readUint32LE(); + uint32 blockCountersOffs = stream.readUint32LE(); + uint32 codeTblOffs = stream.readUint32LE(); + + // Init properties + _properties.init(propertiesCount, data + propertiesOffs); + + // Init blockcounters + _blockCounters.init(blockCountersCount, data + blockCountersOffs); + + _codeOffsets = new uint32[codeCount]; + stream.seek(codeTblOffs); + for (uint i = 0; i < codeCount; ++i) + _codeOffsets[i] = stream.readUint32LE(); + + _progInfos = new ProgInfo[_progInfosCount]; + for (uint i = 0; i < _progInfosCount; ++i) { + stream.seek(0x18 + i * 4); + uint32 progInfoOffs = stream.readUint32LE(); + stream.seek(progInfoOffs); + _progInfos[i].load(data, stream); + } + + debug("ScriptResource::load() propertiesCount: %d; blockCountersCount: %d; codeCount: %d; _progInfosCount: %d", + propertiesCount, blockCountersCount, codeCount, _progInfosCount); + debug("ScriptResource::load() propertiesOffs: %08X; blockCountersOffs: %08X; codeTblOffs: %08X", + propertiesOffs, blockCountersOffs, codeTblOffs); + +} + +} // End of namespace Illusions diff --git a/engines/illusions/scriptresource.h b/engines/illusions/scriptresource.h new file mode 100644 index 0000000000..4e010e975b --- /dev/null +++ b/engines/illusions/scriptresource.h @@ -0,0 +1,108 @@ +/* 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. + * + */ + +#ifndef ILLUSIONS_SCRIPTRESOURCE_H +#define ILLUSIONS_SCRIPTRESOURCE_H + +#include "illusions/resourcesystem.h" + +namespace Illusions { + +class IllusionsEngine; + +class ScriptResourceLoader : public BaseResourceLoader { +public: + ScriptResourceLoader(IllusionsEngine *vm) : _vm(vm) {} + virtual ~ScriptResourceLoader() {} + virtual void load(Resource *resource); + virtual void unload(Resource *resource); + virtual void buildFilename(Resource *resource); + virtual bool isFlag(int flag); +protected: + IllusionsEngine *_vm; +}; + +class Properties { +public: + Properties(); + void init(uint count, byte *properties); +public: + uint _count; + byte *_properties; +}; + +class BlockCounters { +public: + BlockCounters(); + void init(uint count, byte *blockCounters); +public: + uint _count; + byte *_blockCounters; +}; + +struct TriggerCause { + uint32 _verbId; + uint32 _objectId2; + uint32 _codeOffs; + void load(Common::SeekableReadStream &stream); +}; + +class TriggerObject { +public: + TriggerObject(); + ~TriggerObject(); + void load(byte *dataStart, Common::SeekableReadStream &stream); +public: + uint32 _objectId; + uint _causesCount; + TriggerCause *_causes; +}; + +class ProgInfo { +public: + ProgInfo(); + ~ProgInfo(); + void load(byte *dataStart, Common::SeekableReadStream &stream); +protected: + uint16 _id; + uint16 _unk; + byte *_name; + uint _triggerObjectsCount; + TriggerObject *_triggerObjects; +}; + +class ScriptResource { +public: + ScriptResource(); + ~ScriptResource(); + void load(byte *data, uint32 dataSize); +public: + Properties _properties; + BlockCounters _blockCounters; + uint32 *_codeOffsets; + uint _progInfosCount; + ProgInfo *_progInfos; +}; + +} // End of namespace Illusions + +#endif // ILLUSIONS_ACTORRESOURCE_H -- cgit v1.2.3