ILLUSIONS: Start with ScriptResource and related code

5 files changed, 318 insertions, 0 deletions

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