Initial commit of tool to create lure.dat file

svn-id: r23578

4 files changed, 1893 insertions, 0 deletions

diff --git a/tools/create_lure/Makefile b/tools/create_lure/Makefile
new file mode 100644
index 0000000000..1ed33b594c
--- /dev/null
+++ b/tools/create_lure/Makefile
@@ -0,0 +1,4 @@
+# $Id$
+
+all:
+	g++ -I../.. create_lure_dat.cpp process_actions.cpp -o create_lure
diff --git a/tools/create_lure/create_lure_dat.cpp b/tools/create_lure/create_lure_dat.cpp
new file mode 100644
index 0000000000..42b06d5432
--- /dev/null
+++ b/tools/create_lure/create_lure_dat.cpp
@@ -0,0 +1,1147 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2005-2006 The ScummVM project
+ *
+ * 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ * This is a utility for extracting needed resource data from the Lure of the Temptress
+ * lure.exe file into a new file lure.dat - this file is required for the ScummVM
+ * Lure of the Temptress module to work properly
+ *
+ * TODO: 
+ * Some of the field values, such as hotspot tick proc offsets, will vary with
+ * different language versions. These will need to be remapped to a language independant
+ * value once I've fully implemented the English version.
+ * Some areas of the data segment are still to be decoded
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "create_lure_dat.h"
+
+File lure_exe;
+
+uint16 animOffsets[MAX_NUM_ANIM_RECORDS];
+int animIndex = 0;
+uint16 actionOffsets[MAX_NUM_ACTION_RECORDS];
+int actionIndex = 0;
+
+
+void add_anim_record(uint16 offset) {
+	for (int ctr = 0; ctr < animIndex; ++ctr)
+		if (animOffsets[ctr] == offset) return;
+	if (animIndex == MAX_NUM_ANIM_RECORDS) {
+		printf("Animation record offset table size exceeded\n");
+		exit(1);
+	}
+	animOffsets[animIndex++] = offset;
+}
+
+void add_action_list(uint16 offset) {
+	for (int ctr = 0; ctr < actionIndex; ++ctr)
+		if (actionOffsets[ctr] == offset) return;
+	if (actionIndex == MAX_NUM_ACTION_RECORDS) {
+		printf("Action record offset table size exceeded\n");
+		exit(1);
+	}
+	actionOffsets[actionIndex++] = offset;
+}
+
+void read_basic_palette(byte *&data, uint16 &totalSize) {
+	totalSize = PALETTE_SIZE;
+	lure_exe.seek(PALETTE_OFFSET);
+	data = (byte *) malloc(PALETTE_SIZE);
+	lure_exe.read(data, totalSize);
+}
+
+#define ALT_PALETTE_1 0x1757
+#define ALT_PALETTE_1_SIZE 180
+#define ALT_PALETTE_2 0x180B
+#define ALT_PALETTE_2_SIZE 24
+
+void read_replacement_palette(byte *&data, uint16 &totalSize) {
+	totalSize = ALT_PALETTE_1_SIZE + ALT_PALETTE_2_SIZE;
+	data = (byte *) malloc(totalSize);
+
+	lure_exe.seek(DATA_SEGMENT + ALT_PALETTE_1);
+	lure_exe.read(data, ALT_PALETTE_1_SIZE);
+	lure_exe.seek(DATA_SEGMENT + ALT_PALETTE_2);
+	lure_exe.read(data + ALT_PALETTE_1_SIZE, ALT_PALETTE_2_SIZE);
+}
+
+void read_dialog_data(byte *&data, uint16 &totalSize) {
+	totalSize = DIALOG_SIZE;
+	lure_exe.seek(DIALOG_OFFSET);
+	data = (byte *) malloc(DIALOG_SIZE);
+	lure_exe.read(data, totalSize);
+}
+
+void read_talk_dialog_data(byte *&data, uint16 &totalSize) {
+	totalSize = TALK_DIALOG_SIZE;
+	lure_exe.seek(TALK_DIALOG_OFFSET, SEEK_SET);
+	data = (byte *) malloc(TALK_DIALOG_SIZE);
+	lure_exe.read(data, totalSize);
+}
+
+void read_room_data(byte *&data, uint16 &totalSize) 
+{
+	data = (byte *) malloc(MAX_DATA_SIZE);
+	memset(data, 0, MAX_DATA_SIZE);
+
+	uint16 *offsetPtr = (uint16 *) data;
+	uint16 offset = (ROOM_NUM_ENTRIES + 1) * sizeof(uint16);
+	uint16 pixelOffset;
+	RoomResource buffer;
+	int outputIndex = 0;
+	RoomHeaderEntry headerEntry;
+	RoomRectIn bounds;
+
+	for (int index = 0; index < ROOM_NUM_ENTRIES; ++index) {
+
+		lure_exe.seek(DATA_SEGMENT + ROOM_TABLE + index * 9);
+		lure_exe.read(&headerEntry, sizeof(RoomHeaderEntry));
+
+		if ((FROM_LE_16(headerEntry.offset) != 0) && 
+			(FROM_LE_16(headerEntry.offset) != 0xffff) &&
+			(FROM_LE_16(headerEntry.roomNumber) != 0xc09) && 
+			(FROM_LE_16(headerEntry.roomNumber) != 0)) {
+			// Store offset of room entry
+			*offsetPtr++ = TO_LE_16(offset);
+
+			// Copy over basic room details
+			lure_exe.seek(DATA_SEGMENT + headerEntry.offset);
+			lure_exe.read(&buffer, sizeof(RoomResource));
+
+			RoomResourceOutput *rec = (RoomResourceOutput *) (data + offset);
+			rec->roomNumber = headerEntry.roomNumber;
+			rec->descId = headerEntry.descId;
+			rec->numLayers = buffer.numLayers;
+			memcpy(rec->layers, buffer.layers, 8);
+			rec->sequenceOffset = buffer.sequenceOffset;			
+			rec->clippingXStart = TO_LE_16(FROM_LE_16(buffer.clippingXStart) - 0x80);
+			rec->clippingXEnd = (FROM_LE_16(buffer.clippingXEnd) == 0) ? 0 : 
+			  TO_LE_16(FROM_LE_16(buffer.clippingXEnd) - 0x80);
+			rec->numExits = 0;
+
+			offset += sizeof(RoomResourceOutput);
+
+			// Copy over room exits
+			for (;;) {
+				RoomResourceExit1 *p = (RoomResourceExit1 *) (data + offset);
+				lure_exe.read(p, sizeof(RoomResourceExit1));
+				if (FROM_LE_16(p->xs) == 0xffff) break;
+
+				rec->numExits = TO_LE_16(FROM_LE_16(rec->numExits) + 1);
+				p->xs = TO_LE_16(FROM_LE_16(p->xs) - 0x80);
+				p->ys = TO_LE_16(FROM_LE_16(p->ys) - 0x80);
+				p->xe = TO_LE_16(FROM_LE_16(p->xe) - 0x80);
+				p->ye = TO_LE_16(FROM_LE_16(p->ye) - 0x80);
+				offset += sizeof(RoomResourceExit1);
+				RoomResourceExit2 *p2 = (RoomResourceExit2 *) (data + offset);
+
+				if (FROM_LE_16(p->sequenceOffset) == 0xffff) {
+					lure_exe.read(p2, sizeof(RoomResourceExit2));
+					p2->newRoomX = TO_LE_16(FROM_LE_16(p2->newRoomX) - 0x80);
+					p2->newRoomY = TO_LE_16(FROM_LE_16(p2->newRoomY) - 0x80);
+				} else {
+					p2->newRoom = 0;
+					p2->direction = 0;
+					p2->newRoomX = 0;
+					p2->newRoomY = 0;
+				}
+
+				offset += sizeof(RoomResourceExit2);
+			}
+
+			// Handle the random destination walk bounds for the room
+			lure_exe.seek(DATA_SEGMENT + WALK_AREAS_OFFSET + 
+				buffer.walkBoundsIndex * sizeof(RoomRectIn));
+			lure_exe.read(&bounds, sizeof(RoomRectIn));
+			rec->walkBounds.xs = TO_LE_16(FROM_LE_16(bounds.xs) - 0x80);
+			rec->walkBounds.xe = TO_LE_16(FROM_LE_16(bounds.xe) - 0x80);
+			rec->walkBounds.ys = TO_LE_16(FROM_LE_16(bounds.ys) - 0x80);
+			rec->walkBounds.ye = TO_LE_16(FROM_LE_16(bounds.ye) - 0x80);
+
+			// If the room has a default pixel blocks list, add the references
+			if (buffer.pixelListOffset != 0) {
+				lure_exe.seek(DATA_SEGMENT + FROM_LE_16(buffer.pixelListOffset));
+				pixelOffset = lure_exe.readWord();
+				while (pixelOffset != 0) {
+					add_anim_record(pixelOffset);
+					pixelOffset = lure_exe.readWord();
+				}
+			}
+		}
+	}
+
+	WRITE_LE_UINT16(offsetPtr, 0xffff);
+	totalSize = offset;
+}
+
+void read_hotspot_data(byte *&data, uint16 &totalSize) 
+{
+	uint16 offsets[4] = {0x5d98, 0x5eb8, 0x623e, 0x63b1};
+	uint16 startId[4] = {0x3e8, 0x408, 0x2710, 0x7530};
+	int walkNumEntries = 0;
+	int walkCtr;
+	int numEntries;
+	HotspotWalkToRecord rec;
+	HotspotWalkToRecord *walkList;
+	HotspotHeaderEntry entryHeader;
+	HotspotResource entry;
+	uint16 dataSize;
+	HotspotResourceOutput *r;
+	CurrentActionInput action;
+
+	// Allocate enough space for output hotspot list
+	data = (byte *) malloc(MAX_HOTSPOTS * sizeof(HotspotResourceOutput));
+
+	// Determine number of hotspot walk to entries
+	lure_exe.seek(DATA_SEGMENT + HOTSPOT_WALK_TO_OFFSET);
+	do {
+		++walkNumEntries;
+		lure_exe.read(&rec, sizeof(HotspotWalkToRecord));
+	} while (TO_LE_16(rec.hotspotId) != 0);
+	--walkNumEntries;
+
+	dataSize = walkNumEntries * sizeof(HotspotWalkToRecord);
+	walkList = (HotspotWalkToRecord *) malloc(dataSize);
+	lure_exe.seek(DATA_SEGMENT + HOTSPOT_WALK_TO_OFFSET);
+	lure_exe.read(walkList, sizeof(HotspotWalkToRecord) * walkNumEntries);
+
+	// Main code for creating the hotspot list
+
+	r = (HotspotResourceOutput *) data;
+	numEntries = 0;
+
+	for (int tableNum = 0; tableNum < 4; ++tableNum) {
+		uint16 hotspotIndex = 0;
+		for (;;) {
+			lure_exe.seek(DATA_SEGMENT + offsets[tableNum] +  hotspotIndex * 9);
+			lure_exe.read(&entryHeader, sizeof(HotspotHeaderEntry));
+			if (FROM_LE_16(entryHeader.offset) == 0xffff) break;
+
+			memset(r, 0, sizeof(HotspotResourceOutput));
+			r->hotspotId = TO_LE_16(startId[tableNum] + hotspotIndex);
+			r->nameId = TO_LE_16(FROM_LE_16(entryHeader.resourceId) & 0x1fff);
+			r->descId = TO_LE_16(FROM_LE_16(entryHeader.descId) & 0x1fff);
+			r->descId2 = TO_LE_16(FROM_LE_16(entryHeader.descId2) & 0x1fff);
+			r->hdrFlags = entryHeader.hdrFlags;
+
+			// Get the hotspot data
+			lure_exe.seek(DATA_SEGMENT + entryHeader.offset);
+			lure_exe.read(&entry, sizeof(HotspotResource));
+			
+			r->actions = entry.actions;
+			r->roomNumber = entry.roomNumber;
+			r->startX = TO_LE_16(FROM_LE_16(entry.startX) - 0x80);
+			r->startY = TO_LE_16(FROM_LE_16(entry.startY) - 0x80);
+
+			r->width = entry.width;
+			r->height = entry.height;
+			r->widthCopy = entry.widthCopy;
+			r->heightCopy = entry.heightCopy;
+			r->yCorrection = entry.yCorrection;
+			r->talkX = entry.talkX;
+			r->talkY = entry.talkY;
+			r->characterMode = entry.characterMode;
+			r->delayCtr = entry.delayCtr;
+			r->tickSequenceOffset = entry.tickSequenceOffset;
+
+			r->layer = entry.layer;
+			r->scriptLoadFlag = entry.scriptLoadFlag;
+			r->loadOffset = entry.loadOffset;
+			r->colourOffset = entry.colourOffset;
+			r->sequenceOffset = entry.sequenceOffset;
+			r->tickProcOffset = entry.tickProcOffset;
+			r->flags = entry.flags;
+
+			// Find the walk-to coordinates for the hotspot
+			walkCtr = 0;
+			while ((walkCtr < walkNumEntries) &&
+				   (FROM_LE_16(walkList[walkCtr].hotspotId) != FROM_LE_16(r->hotspotId)))
+				++walkCtr;
+			if (walkCtr == walkNumEntries) {
+				r->walkX = 0;
+				r->walkY = 0;
+			} else {
+				r->walkX = TO_LE_16(FROM_LE_16(walkList[walkCtr].x) - 0x80);
+				uint16 y = FROM_LE_16(walkList[walkCtr].y);
+				r->walkY = TO_LE_16((y & 0x8000) | (uint16) ((int16) (y & 0x7fff) - 0x80));
+			}
+
+			// Use the offset of the animation data as a dummy Id for the data
+			r->animRecordId = entry.animOffset;
+			r->tickTimeout = entry.tickTimeout;
+			add_anim_record(FROM_LE_16(entry.animOffset));
+
+			// Add in the actions offset table
+			r->actionsOffset = entry.actionsOffset;
+			if (FROM_LE_16(entry.actionsOffset) != 0)
+				add_action_list(FROM_LE_16(entry.actionsOffset));
+
+			if (FROM_LE_16(r->hotspotId) >= 0x408) {
+				// Hotspot is not an NPC
+				r->npcSchedule = 0;
+			} else {
+				// Check for an NPC schedule
+				lure_exe.seek(DATA_SEGMENT + entryHeader.offset + 0x63);
+				lure_exe.read(&action, sizeof(CurrentActionInput));
+
+				if (action.action != 2) 
+					r->npcSchedule = 0;
+				else {
+					r->npcSchedule = get_sequence_index(FROM_LE_16(action.dataOffset));
+				}
+			}
+
+			++hotspotIndex;
+			++r;
+			++numEntries;
+
+			if (numEntries == MAX_HOTSPOTS) {
+				printf("Ran out of stack spaces for hotspot copying\n");
+				exit(1);
+			}
+		}
+	}
+
+	r->hotspotId = TO_LE_16(0xffff);
+	totalSize = numEntries * sizeof(HotspotResourceOutput) + 2;
+
+	// Dispose of hotspot walk-to co-ordinate list
+	free(walkList);
+}
+
+void read_hotspot_override_data(byte *&data, uint16 &totalSize) 
+{
+	lure_exe.seek(DATA_SEGMENT + HOTSPOT_OVERRIDE_OFFSET);
+	int numOverrides = 0;
+	HotspotOverride rec;
+
+	// Determine number of hotspot overrides
+	do {
+		++numOverrides;
+		lure_exe.read(&rec, sizeof(HotspotOverride));
+	} while (FROM_LE_16(rec.hotspotId) != 0);
+	--numOverrides;
+
+	// Prepare output data and read in all entries at once
+	totalSize = numOverrides * sizeof(HotspotOverride) + 2;
+	data = (byte *) malloc(totalSize);
+	lure_exe.seek(DATA_SEGMENT + HOTSPOT_OVERRIDE_OFFSET);
+	lure_exe.read(data, totalSize - 2);
+	WRITE_LE_UINT16(data + totalSize - 2, 0xffff);
+
+	// Post-process the coordinates
+	HotspotOverride *p = (HotspotOverride *) data;
+	for (int overrideCtr = 0; overrideCtr < numOverrides; ++overrideCtr, ++p) {
+		p->xs = TO_LE_16(FROM_LE_16(p->xs) - 0x80);
+		p->xe = TO_LE_16(FROM_LE_16(p->xe) - 0x80);
+		p->ys = TO_LE_16(FROM_LE_16(p->ys) - 0x80);
+		p->ye = TO_LE_16(FROM_LE_16(p->ye) - 0x80);
+	}
+}
+
+void read_room_exits(byte *&data, uint16 &totalSize) {
+	RoomExitHotspotRecord rec;
+	uint16 offsets[NUM_ROOM_EXITS];
+	uint16 numEntries[NUM_ROOM_EXITS];
+	int roomCtr;
+	totalSize = (NUM_ROOM_EXITS + 1) * sizeof(uint16);
+
+	lure_exe.seek(DATA_SEGMENT + ROOM_EXITS_OFFSET);
+	for (roomCtr = 0; roomCtr < NUM_ROOM_EXITS; ++roomCtr)
+		offsets[roomCtr] = lure_exe.readWord();
+
+	// First loop to find total of room exit records there are
+	for (roomCtr = 0; roomCtr < NUM_ROOM_EXITS; ++roomCtr) {
+		numEntries[roomCtr] = 0;
+		if (offsets[roomCtr] == 0) continue;
+
+		// Get number of exits for the room
+		lure_exe.seek(DATA_SEGMENT + offsets[roomCtr]);
+		lure_exe.read(&rec, sizeof(RoomExitHotspotRecord));
+		while (FROM_LE_16(rec.xs) != 0) {
+			totalSize += sizeof(RoomExitHotspotOutputRecord);
+			numEntries[roomCtr]++;
+			lure_exe.read(&rec, sizeof(RoomExitHotspotRecord));
+		}
+		totalSize += sizeof(uint16); // save room for room list end flag
+	}
+
+	// Alloacte the total needed space
+	data = (byte *) malloc(totalSize);
+	uint16 *offset = (uint16 *) data;
+	uint16 destIndex = (NUM_ROOM_EXITS + 1) * sizeof(uint16);
+	uint16 entryCtr;
+	
+	// Loop to build up the result table
+
+	for (roomCtr = 0; roomCtr < NUM_ROOM_EXITS; ++roomCtr) {
+		if (offsets[roomCtr] == 0) {
+			*offset++ = 0;		// No entries
+		} else {
+			// Read in the entries for the room
+			*offset++ = TO_LE_16(destIndex);
+
+			RoomExitHotspotOutputRecord *destP = (RoomExitHotspotOutputRecord *) 
+				(data + destIndex);
+
+			lure_exe.seek(DATA_SEGMENT + offsets[roomCtr]);
+
+			for (entryCtr = 0; entryCtr < numEntries[roomCtr]; ++entryCtr, ++destP) {
+				lure_exe.read(&rec, sizeof(RoomExitHotspotRecord));
+
+				// Copy over the record
+				destP->xs = TO_LE_16(FROM_LE_16(rec.xs) - 0x80);
+				destP->xe = TO_LE_16(FROM_LE_16(rec.xe) - 0x80);
+				destP->ys = TO_LE_16(FROM_LE_16(rec.ys) - 0x80);
+				destP->ye = TO_LE_16(FROM_LE_16(rec.ye) - 0x80);
+				destP->hotspotId = rec.hotspotId;
+				destP->cursorNum = rec.cursorNum;
+				destP->destRoomNumber = rec.destRoomNumber;
+			}
+			
+			destIndex += numEntries[roomCtr] * sizeof(RoomExitHotspotOutputRecord);
+			WRITE_LE_UINT16(data + destIndex, 0xffff);
+			destIndex += sizeof(uint16);
+		}
+	}
+	WRITE_LE_UINT16(offset, 0xffff);
+}
+
+void read_room_exit_joins(byte *&data, uint16 &totalSize) {
+	RoomExitHotspotJoinRecord rec, *p;
+	lure_exe.seek(DATA_SEGMENT + ROOM_EXIT_JOINS_OFFSET);
+	int numRecords = 0;
+	uint32 unused;
+
+	lure_exe.seek(DATA_SEGMENT + ROOM_EXIT_JOINS_OFFSET);
+	do {
+		lure_exe.read(&rec, sizeof(RoomExitHotspotJoinRecord));
+		lure_exe.read(&unused, sizeof(uint32));
+		++numRecords;
+	} while (FROM_LE_16(rec.hotspot1Id) != 0);
+	--numRecords;
+
+	// Allocate the data and read in all the records
+	totalSize = (numRecords * sizeof(RoomExitHotspotJoinRecord)) + 2;
+	data = (byte *) malloc(totalSize);
+	lure_exe.seek(DATA_SEGMENT + ROOM_EXIT_JOINS_OFFSET);
+	
+	p = (RoomExitHotspotJoinRecord *) data;
+	for (int recordCtr = 0; recordCtr < numRecords; ++recordCtr)
+	{
+		lure_exe.read(p, sizeof(RoomExitHotspotJoinRecord));
+		lure_exe.read(&unused, sizeof(uint32));
+		++p;
+	}
+	WRITE_LE_UINT16(p, 0xffff);
+}
+
+// This next method reads in the animation and movement data. At the moment I
+// figure out which animations have valid movement record sets by finding
+// animations whose four direction offsets are near each other. There's 
+// probably a better method than this, but it'll do for now
+
+void read_anim_data(byte *&data, uint16 &totalSize) {
+	// Add special pixel records
+	add_anim_record(0x5c95);
+
+	// Get the animation data records
+	AnimRecord inRec;
+	MovementRecord move;
+	MovementRecord *destMove;
+	uint16 offset, moveOffset;
+	uint16 startOffset;
+	int ctr, dirCtr;
+	int movementSize = 0;
+	bool *includeAnim = (bool *) malloc(animIndex);
+
+	// Loop to figure out the total number of movement records there are
+	for (ctr = 0; ctr < animIndex; ++ctr) {
+		lure_exe.seek(DATA_SEGMENT + animOffsets[ctr]);
+		lure_exe.read(&inRec, sizeof(AnimRecord));
+
+		if ((FROM_LE_16(inRec.leftOffset) < 0x5000) || 
+			(FROM_LE_16(inRec.rightOffset) < 0x5000) ||
+			(abs(FROM_LE_16(inRec.leftOffset)-FROM_LE_16(inRec.rightOffset)) > 0x800) ||
+			(abs(FROM_LE_16(inRec.rightOffset)-FROM_LE_16(inRec.upOffset)) > 0x800) ||
+			(abs(FROM_LE_16(inRec.upOffset)-FROM_LE_16(inRec.downOffset)) > 0x800)) {
+			// Animation doesn't have valid movement data
+			includeAnim[ctr] = false;
+		} else {
+			includeAnim[ctr] = true;
+			for (dirCtr=0; dirCtr<4; ++dirCtr) {
+				switch (dirCtr) {
+				case 0:
+					offset = FROM_LE_16(inRec.leftOffset);
+					break;
+				case 1:
+					offset = FROM_LE_16(inRec.rightOffset);
+					break;
+				case 2:
+					offset = FROM_LE_16(inRec.upOffset);
+					break;
+				default:
+					offset = FROM_LE_16(inRec.downOffset);
+				}
+
+				if (offset != 0) {
+					lure_exe.seek(DATA_SEGMENT + offset);
+					lure_exe.read(&move, sizeof(MovementRecord));
+
+					while (FROM_LE_16(move.frameNumber) != 0xffff) {
+						movementSize += sizeof(MovementRecord);
+						lure_exe.read(&move, sizeof(MovementRecord));
+					}
+					movementSize += 2;
+				}
+			}
+		}
+	}
+
+	totalSize = animIndex * sizeof(AnimRecordOutput) + 2 + movementSize;
+	AnimRecordOutput *rec = (AnimRecordOutput *) malloc(totalSize);
+	data = (byte *) rec;
+	moveOffset = animIndex * sizeof(AnimRecordOutput) + 2;
+
+	// Loop to get in the animation records
+	for (ctr = 0; ctr < animIndex; ++ctr, ++rec) {
+		lure_exe.seek(DATA_SEGMENT + animOffsets[ctr]);
+		lure_exe.read(&inRec, sizeof(AnimRecord));
+
+		rec->animRecordId = animOffsets[ctr];
+		rec->animId = inRec.animId;
+		rec->flags = TO_LE_16(inRec.flags);
+
+		rec->leftOffset = 0; 
+		rec->rightOffset = 0;
+		rec->upOffset = 0;
+		rec->downOffset = 0;
+
+		rec->upFrame = inRec.upFrame;
+		rec->downFrame = inRec.downFrame;
+		rec->leftFrame = inRec.leftFrame;
+		rec->rightFrame = inRec.rightFrame;
+
+		if (includeAnim[ctr]) {
+			// Loop to get movement records
+			uint16 *inDirs[4] = {&inRec.leftOffset, &inRec.rightOffset,
+				&inRec.upOffset, &inRec.downOffset};
+			uint16 *outDirs[4] = {&rec->leftOffset, &rec->rightOffset,
+				&rec->upOffset, &rec->downOffset};
+
+			for (dirCtr=0; dirCtr<4; ++dirCtr) {
+				offset = READ_LE_UINT16(inDirs[dirCtr]);
+
+				if (offset == 0) {
+					startOffset = 0;
+				} else {
+					startOffset = moveOffset;
+
+					lure_exe.seek(DATA_SEGMENT + offset);
+					lure_exe.read(&move, sizeof(MovementRecord));
+					destMove = (MovementRecord *) (data + moveOffset);
+
+					while (FROM_LE_16(move.frameNumber) != 0xffff) {
+						destMove->frameNumber = move.frameNumber;
+						destMove->xChange = move.xChange;
+						destMove->yChange = move.yChange;
+
+						moveOffset += sizeof(MovementRecord);
+						++destMove;
+						lure_exe.read(&move, sizeof(MovementRecord));
+					}
+					
+					destMove->frameNumber = TO_LE_16(0xffff);
+					moveOffset += 2;
+				}
+
+				WRITE_LE_UINT16(outDirs[dirCtr], startOffset);
+			}
+		}
+	}
+
+	rec->animRecordId = TO_LE_16(0xffff);
+	delete includeAnim;
+}
+
+void read_script_data(byte *&data, uint16 &totalSize) {
+	lure_exe.seek(SCRIPT_SEGMENT);
+	
+	totalSize = SCRIPT_SEGMENT_SIZE;
+	data = (byte *) malloc(totalSize);
+	lure_exe.read(data, totalSize);
+}
+
+void read_script2_data(byte *&data, uint16 &totalSize) {
+	lure_exe.seek(SCRIPT2_SEGMENT);
+	
+	totalSize = SCRIPT2_SEGMENT_SIZE;
+	data = (byte *) malloc(totalSize);
+	lure_exe.read(data, totalSize);
+}
+
+void read_hotspot_script_offsets(byte *&data, uint16 &totalSize) {
+	lure_exe.seek(DATA_SEGMENT + HOTSPOT_SCRIPT_LIST);
+	
+	totalSize = HOTSPOT_SCRIPT_SIZE;
+	data = (byte *) malloc(totalSize);
+	lure_exe.read(data, totalSize);
+}
+
+void read_messages_segment(byte *&data, uint16 &totalSize) {
+	lure_exe.seek(MESSAGES_SEGMENT);
+	totalSize = MESSAGES_SEGMENT_SIZE;
+	data = (byte *) malloc(totalSize);
+	lure_exe.read(data, totalSize);
+}
+
+// Reads in the list of actions used
+
+void read_actions_list(byte *&data, uint16 &totalSize) {
+	// Allocate enough space for output action list
+	data = (byte *) malloc(MAX_DATA_SIZE);
+	HotspotActionsRecord *header = (HotspotActionsRecord *) data;
+	uint16 offset = actionIndex * sizeof(HotspotActionsRecord) + sizeof(uint16);
+
+	for (int ctr = 0; ctr < actionIndex; ++ctr) {
+		header->recordId = actionOffsets[ctr];
+		header->offset = offset;
+		++header;
+
+		lure_exe.seek(DATA_SEGMENT + actionOffsets[ctr]);
+		uint16 *numItems = (uint16 *) (data + offset);
+		lure_exe.read(numItems, sizeof(uint16));
+		offset += 2;
+
+		if (READ_UINT16(numItems) > 0) {
+			lure_exe.read(data + offset, READ_UINT16(numItems) * 3);
+			offset += READ_UINT16(numItems) * 3;
+		}
+	}
+	header->recordId = TO_LE_16(0xffff);
+}
+
+// Reads in the talk data 
+
+#define TALK_OFFSET 0x505c
+#define TALK_NUM_ENTRIES 28
+#define MAX_TALK_LISTS 300
+
+uint16 talkOffsets[MAX_TALK_LISTS];
+int talkOffsetIndex = 0;
+
+void add_talk_offset(uint16 offset) {
+	for (int ctr = 0; ctr < talkOffsetIndex; ++ctr) 
+		if (talkOffsets[ctr] == offset) return;
+	if (talkOffsetIndex == MAX_TALK_LISTS) {
+		printf("Exceeded maximum talk offset list size\n");
+		exit(1);
+	}
+
+	talkOffsets[talkOffsetIndex++] = offset;
+}
+
+struct TalkEntry {
+	uint16 hotspotId;
+	uint16 offset;
+};
+
+void read_talk_headers(byte *&data, uint16 &totalSize) {
+	TalkEntry entries[TALK_NUM_ENTRIES];
+	uint16 sortedOffsets[TALK_NUM_ENTRIES+1];
+	int entryCtr, subentryCtr;
+
+	lure_exe.seek(DATA_SEGMENT + TALK_OFFSET);
+	lure_exe.read(&entries[0], sizeof(TalkEntry) * TALK_NUM_ENTRIES);
+
+	// Sort the entry offsets into a list - this is used to figure out each entry's size
+	int currVal, prevVal = 0;
+	for (entryCtr = 0; entryCtr < TALK_NUM_ENTRIES; ++entryCtr) {
+		currVal = 0xffff;
+		for (subentryCtr = 0; subentryCtr < TALK_NUM_ENTRIES; ++subentryCtr) {
+			if ((FROM_LE_16(entries[subentryCtr].offset) < currVal) &&
+				(FROM_LE_16(entries[subentryCtr].offset) > prevVal)) 
+				currVal = FROM_LE_16(entries[subentryCtr].offset);
+		}
+		if (currVal == 0xffff) break;
+
+		sortedOffsets[entryCtr] = currVal;
+		prevVal = currVal;
+	}
+	sortedOffsets[entryCtr] = 0x5540; // end for end record
+
+	data = (byte *) malloc(MAX_DATA_SIZE);
+	TalkEntry *entry = (TalkEntry *) data;
+	uint16 offset = TALK_NUM_ENTRIES * sizeof(TalkEntry) + sizeof(uint16);
+
+	for (int entryCtr = 0; entryCtr < TALK_NUM_ENTRIES; ++entryCtr) {
+		entry->hotspotId = entries[entryCtr].hotspotId;
+		entry->offset = TO_LE_16(offset);
+		++entry;
+
+		// Find the following offset in a sorted list
+		int startOffset = FROM_LE_16(entries[entryCtr].offset);
+		int nextOffset = 0;
+		for (subentryCtr = 0; subentryCtr < TALK_NUM_ENTRIES; ++subentryCtr) {
+			if (sortedOffsets[subentryCtr] == startOffset) {
+				nextOffset = sortedOffsets[subentryCtr+1];
+				break;
+			}
+		}
+		if (nextOffset == 0) 
+			exit(1);
+
+		// Read in line entries into the data
+		lure_exe.seek(DATA_SEGMENT + startOffset);
+		int size = nextOffset - startOffset;
+		uint16 *talkOffset = (uint16 *) (data + offset);
+		lure_exe.read(talkOffset, size);
+
+		while (size > 0) {
+			if (READ_UINT16(talkOffset) != 0) 
+				add_talk_offset(READ_UINT16(talkOffset));
+			size -= sizeof(uint16);
+			offset += sizeof(uint16);
+			talkOffset++;
+		}
+
+		WRITE_LE_UINT16(talkOffset, 0xffff);
+		offset += 2;
+	}
+
+	add_talk_offset(0xffff);
+	entry->hotspotId = TO_LE_16(0xffff);
+	totalSize = offset + 2;
+}
+
+// Reads in the contents of the previously loaded talk lists
+
+struct TalkRecord {
+	uint16 recordId;
+	uint16 listOffset;
+	uint16 responsesOffset;
+};
+
+uint16 giveTalkIds[6] = {0xCF5E, 0xCF14, 0xCF90, 0xCFAA, 0xCFD0, 0xCFF6};
+
+void read_talk_data(byte *&data, uint16 &totalSize) {
+	uint16 responseOffset;
+	int talkCtr, subentryCtr;
+	uint16 size;
+
+	for (talkCtr = 0; talkCtr < 6; ++talkCtr)
+		add_talk_offset(giveTalkIds[talkCtr]);
+
+	data = (byte *) malloc(MAX_DATA_SIZE);
+	TalkRecord *header = (TalkRecord *) data;
+	uint16 offset = talkOffsetIndex * sizeof(TalkRecord) + sizeof(uint16);
+
+	uint16 *sortedList = (uint16 *) malloc((talkOffsetIndex+1) * sizeof(uint16));
+	memset(sortedList, 0, (talkOffsetIndex+1) * sizeof(uint16));
+
+	// Sort the entry offsets into a list - this is used to figure out each entry's size
+	int currVal, prevVal = 0;
+	for (talkCtr = 0; talkCtr < talkOffsetIndex; ++talkCtr) {
+		currVal = 0xffff;
+		for (subentryCtr = 0; subentryCtr < talkOffsetIndex; ++subentryCtr) {
+			if ((talkOffsets[subentryCtr] < currVal) &&
+				(talkOffsets[subentryCtr] > prevVal)) 
+				currVal = talkOffsets[subentryCtr];
+		}
+		if (currVal == 0xffff) break;
+
+		sortedList[talkCtr] = currVal;
+		prevVal = currVal;
+	}
+	sortedList[talkCtr] = 0xf010;
+	int numTalks = talkCtr;
+
+	// Loop through the talk list
+
+	for (talkCtr = 0; talkCtr < numTalks; ++talkCtr) {
+		uint16 startOffset = sortedList[talkCtr];
+		uint16 nextOffset = sortedList[talkCtr+1];
+
+		header->recordId = startOffset;
+		header->listOffset = offset;
+		
+		lure_exe.seek(DATA_SEGMENT + startOffset);
+		responseOffset = lure_exe.readWord();
+		startOffset += 2;
+
+		// Special handling for entry at 0d930h
+		if (responseOffset == 0x8000) continue;
+
+		// Calculate talk data size - if response is within record range,
+		// use simple calculation size. Otherwise, read in full data until
+		// end of record
+		if ((responseOffset < startOffset) || (responseOffset >= nextOffset))
+			size = nextOffset - startOffset;
+		else
+			size = responseOffset - startOffset;
+		if ((size % 6) == 2) size -= 2;
+		if ((size % 6) != 0) {
+			printf("Failure reading talk data\n");
+			exit(1);
+		}
+
+		// Read in the list of talk entries
+		lure_exe.read(data + offset, size);
+		offset += size;
+		memset(data + offset, 0xff, 2);
+		offset += 2;
+
+		// Handle the response data
+		header->responsesOffset = offset;
+
+		// Scan through the list of record offsets and find the offset of
+		// the following record. This is done because although the talk
+		// records and responses are normally sequential, it can also
+		// point into another record's talk responses
+
+		nextOffset = 0;
+		for (subentryCtr = 0; subentryCtr < numTalks; ++subentryCtr) {
+			if ((responseOffset >= sortedList[subentryCtr]) &&
+				(responseOffset < sortedList[subentryCtr+1])) {
+				// Found a record				
+				nextOffset = sortedList[subentryCtr+1];
+				break;
+			}
+		}
+		if (nextOffset < responseOffset) {
+			printf("Failure reading talk data\n");
+			exit(1);
+		}
+		
+		size = nextOffset - responseOffset;
+		if ((size % 6) != 0) size -= (size % 6);
+
+		if ((size % 6) != 0) {
+			printf("Failure reading talk data\n");
+			exit(1);
+		}
+
+		lure_exe.read(data + offset, size);
+		offset += size;
+		WRITE_LE_UINT16(data + offset, 0xffff);
+		offset += 2;
+
+		++header;
+	}
+
+	header->recordId = TO_LE_16(0xffff);
+	totalSize = offset;
+	free(sortedList);
+}
+
+void read_room_pathfinding_data(byte *&data, uint16 &totalSize) {
+	lure_exe.seek(DATA_SEGMENT + PATHFIND_OFFSET);
+	
+	totalSize = PATHFIND_SIZE;
+	data = (byte *) malloc(totalSize);
+	lure_exe.read(data, totalSize);
+}
+
+void read_room_exit_coordinate_data(byte *&data, uint16 &totalSize) 
+{
+	// Read in the exit coordinates list	
+	int roomNum, entryNum;
+
+	totalSize = EXIT_COORDINATES_NUM_ROOMS * sizeof(RoomExitCoordinateEntryResource) + 2; 
+	data = (byte *) malloc(totalSize);
+	lure_exe.seek(DATA_SEGMENT + EXIT_COORDINATES_OFFSET);
+	lure_exe.read(data, totalSize - 2);
+	WRITE_LE_UINT16(data + totalSize - 2, 0xffff);
+
+	// Post process the list to adjust data
+	RoomExitCoordinateEntryResource *rec = (RoomExitCoordinateEntryResource *) data;
+	for (roomNum = 0; roomNum < EXIT_COORDINATES_NUM_ROOMS; ++roomNum, ++rec) {
+		for (entryNum = 0; entryNum < ROOM_EXIT_COORDINATES_NUM_ENTRIES; ++entryNum) {
+			if ((rec->entries[entryNum].x != 0) || (rec->entries[entryNum].y != 0)) {
+				rec->entries[entryNum].x = TO_LE_16(FROM_LE_16(rec->entries[entryNum].x) - 0x80);
+				uint16 tempY = FROM_LE_16(rec->entries[entryNum].y);
+				rec->entries[entryNum].y = TO_LE_16(
+					((tempY & 0xfff) - 0x80) | (tempY & 0xf000));
+			}
+		}
+
+		for (entryNum = 0; entryNum < ROOM_EXIT_COORDINATES_ENTRY_NUM_ROOMS; ++entryNum) {
+			rec->roomIndex[entryNum] = TO_LE_16(FROM_LE_16(rec->roomIndex[entryNum]) / 6);
+		}
+	}
+}
+
+void read_room_exit_hotspots_data(byte *&data, uint16 &totalSize) {
+	totalSize = 0;
+	data = (byte *) malloc(MAX_DATA_SIZE);
+
+	RoomExitIndexedHotspotResource *rec = (RoomExitIndexedHotspotResource *) data;
+	lure_exe.seek(DATA_SEGMENT + EXIT_HOTSPOTS_OFFSET);
+
+	lure_exe.read(rec, sizeof(RoomExitIndexedHotspotResource));
+	while (FROM_LE_16(rec->roomNumber) != 0) {
+		++rec;
+		totalSize += sizeof(RoomExitIndexedHotspotResource);
+		lure_exe.read(rec, sizeof(RoomExitIndexedHotspotResource));
+	}
+
+	WRITE_LE_UINT16(rec, 0xffff);
+	totalSize += sizeof(uint16);
+}
+
+void getEntry(uint8 entryIndex, uint16 &resourceId, byte *&data, uint16 &size)
+{
+	resourceId = 0x3f01 + entryIndex;
+
+	switch (entryIndex) 
+	{
+	case 0:
+		// Copy the default palette to file
+		read_basic_palette(data, size);
+		break;
+
+	case 1:
+		// Copy the replacement palette fragments to file
+		read_replacement_palette(data, size);
+		break;
+
+	case 2:
+		// Copy the dialog segment data into the new vga file
+		read_dialog_data(data, size);
+		break;
+
+	case 3:
+		// Copy the talk dialog segment data into the new vga file
+		read_talk_dialog_data(data, size);
+		break;
+
+	case 4:
+		// Get the room info data
+		read_room_data(data, size);
+		break;
+
+	case 5:
+		// Get the action sequence set for NPC characters
+		read_action_sequence(data, size);
+		break;
+
+	case 6:
+		// Get the hotspot info data
+		read_hotspot_data(data, size);
+		break;
+
+	case 7:
+		// Get the hotspot override info data
+		read_hotspot_override_data(data, size);
+		break;
+
+	case 8:
+		// Get the list of room exits
+		read_room_exits(data, size);
+		break;
+
+	case 9:
+		// Get the list of room exit joins
+		read_room_exit_joins(data, size);
+		break;
+
+	case 10:
+		// Get the hotspot animation record data
+		read_anim_data(data, size);
+		break;
+
+	case 11:
+		// Get the script segment data
+		read_script_data(data, size);
+		break;
+
+	case 12:
+		// Get the second script segment data
+		read_script2_data(data, size);
+		break;
+
+	case 13:
+		// Get a list of hotspot script offsets
+		read_hotspot_script_offsets(data, size);
+		break;
+
+	case 14:
+		// Get the messages segment 
+		read_messages_segment(data, size);
+		break;
+
+	case 15:
+		// Get the actions list
+		read_actions_list(data, size);
+		break;
+
+	case 16:
+		// Get the talk header information
+		read_talk_headers(data, size);
+		break;
+
+	case 17:
+		// Get the talk data
+		read_talk_data(data, size);
+		break;
+
+	case 18:
+		// Get the pathfinding data
+		read_room_pathfinding_data(data, size);
+		break;
+
+	case 19:
+		// Get the room exit coordinate list
+		read_room_exit_coordinate_data(data, size);
+		break;
+
+	case 20:
+		// Read the room exit hotspot list
+		read_room_exit_hotspots_data(data, size);
+		break;
+
+	default:
+		data = NULL;
+		size = 0;
+		resourceId = 0xffff;
+		break;
+	}
+}
+
+void createFile(const char *outFilename)
+{
+	FileEntry rec;
+	uint32 startOffset, numBytes;
+	uint16 resourceId;
+	uint16 resourceSize;
+	byte *resourceData;
+	bool resourceFlag;
+	byte tempBuffer[32];
+
+	File f;
+	f.open(outFilename, kFileWriteMode);
+	memset(tempBuffer, 0, 32);
+
+	// Write header
+	f.write("heywow", 6);
+	f.writeWord(0);
+
+	startOffset = 0x600;
+	resourceFlag = true;
+	for (int resIndex=0; resIndex<0xBE; ++resIndex)
+	{
+		resourceData = NULL;
+
+		// Get next data entry
+		if (resourceFlag)
+			// Get resource details
+			getEntry(resIndex, resourceId, resourceData, resourceSize); 
+
+		// Write out the next header entry
+		f.seek(8 + resIndex * 8);
+		if (resourceSize == 0) 
+		{
+			// Unused entry
+			memset(&rec, 0xff, sizeof(FileEntry));
+			resourceFlag = false;
+		}
+		else
+		{
+			rec.id = TO_LE_16(resourceId);
+			rec.offset = TO_LE_16(startOffset >> 5);
+			rec.sizeExtension = (uint8) ((resourceSize >> 16) & 0xff);
+			rec.size = TO_LE_16(resourceSize & 0xffff);
+			rec.unused = 0xff;
+		}
+
+		f.write(&rec, sizeof(FileEntry));
+
+		// Write out the resource
+		if (resourceFlag)
+		{
+			f.seek(startOffset);
+			f.write(resourceData, resourceSize);
+			startOffset += resourceSize;
+			free(resourceData);		// Free the data block
+
+			// Write out enough bytes to move to the next 32 byte boundary
+			numBytes = 0x20 * ((startOffset + 0x1f) / 0x20) - startOffset;
+			if (numBytes != 0) 
+			{
+				f.write(tempBuffer, numBytes);
+				startOffset += numBytes;
+			}
+		}
+	}
+
+	// Store file version in final file slot
+	f.seek(0xBF * 8);
+	FileEntry fileVersion;
+	memset(&fileVersion, 0xff, sizeof(FileEntry));
+	fileVersion.unused = VERSION_MAJOR;
+	fileVersion.sizeExtension = VERSION_MINOR;
+	f.write(&fileVersion, sizeof(FileEntry));
+
+	f.close();
+}
+
+// validate_executable
+// Validates that the correct executable is being used to generate the
+// resource file. Eventually the resource file creator will need to work
+// with the other language executables, but for now just make 
+
+#define NUM_BYTES_VALIDATE 1024
+#define FILE_CHECKSUM 64880
+
+void validate_executable() {
+	uint32 sumTotal = 0;
+	byte buffer[NUM_BYTES_VALIDATE];
+	lure_exe.read(buffer, NUM_BYTES_VALIDATE);
+	for (int ctr = 0; ctr < NUM_BYTES_VALIDATE; ++ctr) 
+		sumTotal += buffer[ctr];
+
+	if (sumTotal != FILE_CHECKSUM) {
+		printf("Lure executable not correct English version\n");
+		exit(1);
+	}
+}
+
+
+int main(int argc, char *argv[])
+{
+	const char *inFilename = (argc >= 2) ? argv[1] : "f:\\games\\lure\\lure.exe";
+	const char *outFilename = (argc == 3) ? argv[2] : "f:\\games\\lure\\lure.dat";
+
+	if (!lure_exe.open(inFilename))
+	{
+		if (argc == 1) 
+			printf("Format: %s input_exe_filename output_filename\n");
+		else
+			printf("Could not open file: %s\n", inFilename);
+	} 
+	else 
+	{
+		validate_executable();
+		createFile(outFilename);	
+		lure_exe.close();
+	}
+}
diff --git a/tools/create_lure/create_lure_dat.h b/tools/create_lure/create_lure_dat.h
new file mode 100644
index 0000000000..ffdde22053
--- /dev/null
+++ b/tools/create_lure/create_lure_dat.h
@@ -0,0 +1,401 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2005-2006 The ScummVM project
+ *
+ * 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef __createlure_dat__
+#define __createlure_dat__
+
+#include "common/stdafx.h"
+#include "common/endian.h"
+
+#define VERSION_MAJOR 1
+#define VERSION_MINOR 10
+#define ENGLISH_LURE 
+
+#define DATA_SEGMENT 0xac50
+
+#define DIALOG_OFFSET 0x1dcb0
+#define DIALOG_SIZE 0x150
+
+#define TALK_DIALOG_OFFSET 0x1de00
+#define TALK_DIALOG_SIZE 0x30
+
+#define PALETTE_OFFSET 0xc0a7
+#define PALETTE_SIZE 0x300
+
+#define ROOM_TABLE 0xbf40
+#define ROOM_NUM_ENTRIES 51
+
+#define HOTSPOT_OVERRIDE_OFFSET 0x2A01
+
+#define SCRIPT_SEGMENT 0x1df00
+#define SCRIPT_SEGMENT_SIZE 0x2c57
+#define SCRIPT2_SEGMENT 0x19c70
+#define SCRIPT2_SEGMENT_SIZE 0x2800
+
+#define HOTSPOT_SCRIPT_LIST 0x57e0
+#define HOTSPOT_SCRIPT_SIZE 0x30
+
+#define MAX_NUM_ANIM_RECORDS 0x200
+#define MAX_NUM_ACTION_RECORDS 0x100
+
+#define ROOM_EXITS_OFFSET 0x2f61
+#define NUM_ROOM_EXITS 50
+#define ROOM_EXIT_JOINS_OFFSET 0xce30
+
+#define MESSAGES_SEGMENT 0x20b60
+#define MESSAGES_SEGMENT_SIZE 0x490
+
+#define MAX_HOTSPOTS 0x100
+#define MAX_DATA_SIZE 0x4000
+
+#define PATHFIND_OFFSET 0x984A
+#define PATHFIND_SIZE (120 * ROOM_NUM_ENTRIES) 
+
+#define HOTSPOT_WALK_TO_OFFSET 0xBC4B
+#define EXIT_COORDINATES_OFFSET 0x1929
+#define EXIT_COORDINATES_NUM_ROOMS 49
+
+#define TABLED_ACTIONS_OFFSET 0x1380
+#define NUM_TABLED_ACTION_BLOCKS 18
+
+#define WALK_AREAS_OFFSET 0x2EB1
+
+#define EXIT_HOTSPOTS_OFFSET 0x2E57
+
+#pragma pack(1)
+
+// Rect currently copied from common/rect.h - if I try directly including it,
+// the link complains about an unresolved external token Common.String.__dtor
+
+struct Rect {
+	int16 top, left;		//!< The point at the top left of the rectangle (part of the rect).
+	int16 bottom, right;	//!< The point at the bottom right of the rectangle (not part of the rect).
+};
+
+struct FileEntry {
+	uint16 id;
+	byte unused;
+	byte sizeExtension;
+	uint16 size;
+	uint16 offset;
+};
+
+struct RoomHeaderEntry {
+	uint16 offset;
+	uint16 roomNumber;
+	uint16 descId;
+	byte unused[3];
+};
+
+struct HotspotHeaderEntry {
+	uint16 offset;
+	uint16 resourceId;
+	uint16 descId, descId2;
+	byte hdrFlags;
+};
+
+struct HotspotResource {
+	uint32 actions;
+	uint16 actionsOffset;
+	uint16 roomNumber;
+	byte scriptLoadFlag;
+	uint16 loadOffset;
+	uint16 unused;
+	uint16 startX;
+	uint16 startY;
+	uint16 width;
+	uint16 height;
+	byte layer;
+	byte flags;
+	uint16 tickProcOffset;
+	uint16 widthCopy;
+	uint16 heightCopy;
+	uint16 yCorrection;
+	uint16 tickTimeout;
+	uint16 animOffset;
+	byte colourOffset;
+	uint16 sequenceOffset;
+	byte unknown4[15];
+	int8 talkX;
+	int8 talkY;
+	byte unused5[11];
+	uint16 delayCtr;
+	uint8 characterMode;
+	uint16 tickSequenceOffset;
+};
+
+struct CurrentActionInput {
+	uint8 action;
+	uint16 dataOffset;
+	uint16 roomNumber;
+};
+
+struct HotspotResourceOutput {
+	uint16 hotspotId;
+	uint16 nameId;
+	uint16 descId;
+	uint16 descId2;
+	uint32 actions;
+	uint16 actionsOffset;
+	uint16 roomNumber;
+	byte layer;
+	byte scriptLoadFlag;
+	uint16 loadOffset;
+	uint16 startX;
+	uint16 startY;
+	uint16 width;
+	uint16 height;
+	uint16 widthCopy;
+	uint16 heightCopy;
+	uint16 yCorrection;
+	int16 walkX;
+	uint16 walkY;
+	int8 talkX;
+	int8 talkY;
+	uint16 colourOffset;
+	uint16 animRecordId;
+	uint16 sequenceOffset;
+	uint16 tickProcOffset;
+	uint16 tickTimeout;
+	uint16 tickSequenceOffset;
+	uint16 npcSchedule;
+	uint16 characterMode;
+	uint16 delayCtr;
+	byte flags;
+	byte hdrFlags;
+};
+
+struct RoomResource {
+	byte unknown1[6];
+	uint16 pixelListOffset;
+	byte numLayers;
+	uint16 layers[4];
+	uint16 sequenceOffset;
+	byte unknown3[5];
+	uint8 walkBoundsIndex;
+	int16 clippingXStart;
+	int16 clippingXEnd;
+};
+
+struct RoomRectIn {
+	uint16 xs, xe;
+	uint16 ys, ye;
+};
+
+struct RoomRectOut {
+	int16 xs, xe;
+	int16 ys, ye;
+};
+
+struct RoomResourceOutput {
+	uint16 roomNumber;
+	uint16 descId;
+	uint16 numLayers;
+	uint16 layers[4];
+	uint16 sequenceOffset;
+	int16 clippingXStart;
+	int16 clippingXEnd;
+	RoomRectOut walkBounds;
+	uint16 numExits;
+};
+
+struct RoomResourceExit1 {
+	int16 xs, xe, ys, ye;
+	uint16 sequenceOffset;
+};
+
+struct RoomResourceExit2 {
+	uint8 newRoom;
+	uint8 direction;
+	int16 newRoomX, newRoomY;
+};
+
+struct HotspotOverride {
+	uint16 hotspotId;
+	uint16 xs, xe, ys, ye;
+};
+
+struct AnimRecord {
+	uint16 animId;
+	uint8 flags;
+	uint8 unused[6];
+	uint16 upOffset;
+	uint16 downOffset;
+	uint16 leftOffset;
+	uint16 rightOffset;
+	uint8 upFrame;
+	uint8 downFrame;
+	uint8 leftFrame;
+	uint8 rightFrame;
+};
+
+struct AnimRecordOutput {
+	uint16 animRecordId;
+	uint16 animId;
+	uint16 flags;
+	uint16 upOffset;
+	uint16 downOffset;
+	uint16 leftOffset;
+	uint16 rightOffset;
+	uint8 upFrame;
+	uint8 downFrame;
+	uint8 leftFrame;
+	uint8 rightFrame;
+};
+
+struct MovementRecord {
+	uint16 frameNumber;
+	int16 xChange;
+	int16 yChange;
+};
+
+struct RoomExitHotspotRecord {
+	int16 xs, xe;
+	int16 ys, ye;
+	uint16 cursorNum;
+	uint16 hotspotId;
+	uint16 destRoomNumber;
+};
+
+struct RoomExitHotspotOutputRecord {
+	uint16 hotspotId;
+	int16 xs, xe;
+	int16 ys, ye;
+	uint16 cursorNum;
+	uint16 destRoomNumber;
+};
+
+struct RoomExitHotspotJoinRecord {
+	uint16 hotspot1Id;
+	byte h1CurrentFrame;
+	byte h1DestFrame;
+	byte h1OpenSound;
+	byte h1CloseSound;
+	uint16 hotspot2Id;
+	byte h2CurrentFrame;
+	byte h2DestFrame;
+	byte h2OpenSound;
+	byte h2CloseSound;
+	byte blocked;
+};
+
+struct HotspotActionSequenceRecord {
+	byte actionNumber;
+	uint16 sequenceOffset;
+};
+
+struct HotspotActionsRecord {
+	uint16 recordId;
+	uint16 offset;
+};
+
+struct RoomExitCoordinateResource {
+	int16 x;
+	int16 y;
+	uint16 roomNumber;
+};
+
+struct HotspotWalkToRecord {
+	uint16 hotspotId;
+	int16 x;
+	uint16 y;
+};
+
+struct RoomExitIndexedHotspotResource {
+	uint8 roomNumber;
+	uint8 hotspotIndex;
+	uint16 hotspotId;
+};
+
+
+#define ROOM_EXIT_COORDINATES_NUM_ENTRIES 6
+#define ROOM_EXIT_COORDINATES_ENTRY_NUM_ROOMS 52
+
+struct RoomExitCoordinateEntryResource {
+	RoomExitCoordinateResource entries[ROOM_EXIT_COORDINATES_NUM_ENTRIES];
+	uint8 roomIndex[ROOM_EXIT_COORDINATES_ENTRY_NUM_ROOMS];
+};
+
+enum CurrentAction {NO_ACTION, START_WALKING, DISPATCH_ACTION, EXEC_HOTSPOT_SCRIPT, 
+	PROCESSING_PATH, WALKING};
+
+extern void read_action_sequence(byte *&data, uint16 &totalSize);
+
+extern uint16 get_sequence_index(uint16 offset, int supportIndex = -1);
+
+enum AccessMode {
+	kFileReadMode = 1,
+	kFileWriteMode = 2
+};
+
+class File {
+private:
+	FILE *f;
+public:
+	bool open(const char *filename, AccessMode mode = kFileReadMode) {
+		f = fopen(filename, (mode == kFileReadMode) ? "rb" : "wb");
+		return (f != NULL);
+	}
+	void close() {
+		fclose(f);
+		f = NULL;
+	}
+	int seek(int32 offset, int whence = SEEK_SET) {
+		return fseek(f, offset, whence);
+	}
+	long read(void *buffer, int len) {
+		return fread(buffer, 1, len, f);
+	}
+	void write(const void *buffer, int len) {
+		fwrite(buffer, 1, len, f);
+	}
+	byte readByte() { 
+		byte v;
+		read(&v, sizeof(byte));
+		return v;
+	}
+	uint16 readWord() {
+		uint16 v;
+		read(&v, sizeof(uint16));
+		return FROM_LE_16(v);
+	}
+	uint16 readLong() {
+		uint32 v;
+		read(&v, sizeof(uint32));
+		return FROM_LE_32(v);
+	}
+	void writeByte(byte v) { 
+		write(&v, sizeof(byte));
+	}
+	void writeWord(uint16 v) { 
+		uint16 vTemp = TO_LE_16(v);
+		write(&vTemp, sizeof(uint16));
+	}
+	void writeLong(uint32 v) { 
+		uint32 vTemp = TO_LE_32(v);
+		write(&vTemp, sizeof(uint32));
+	}
+};
+
+extern File lure_exe;
+
+#endif
diff --git a/tools/create_lure/process_actions.cpp b/tools/create_lure/process_actions.cpp
new file mode 100644
index 0000000000..681d43283f
--- /dev/null
+++ b/tools/create_lure/process_actions.cpp
@@ -0,0 +1,341 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2005-2006 The ScummVM project
+ *
+ * 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "create_lure_dat.h"
+
+enum Action {
+	GET = 1, PUSH = 3, PULL = 4, OPERATE = 5, OPEN = 6,	CLOSE = 7, LOCK = 8,
+	UNLOCK = 9,	USE = 10, GIVE = 11, TALK_TO = 12, TELL = 13, BUY = 14,
+	LOOK = 15, LOOK_AT = 16, LOOK_THROUGH = 17,	ASK = 18, DRINK = 20,
+	STATUS = 21, GO_TO = 22, RETURN = 23, BRIBE = 24, EXAMINE = 25,
+	NPC_SET_ROOM_AND_BLOCKED_OFFSET = 28, NPC_UNKNOWN1 = 29, NPC_EXEC_SCRIPT = 30, 
+	NPC_UNKNOWN2 = 31, NPC_SET_RAND_DEST = 32, NPC_WALKING_CHECK = 33, 
+	NPC_SET_SUPPORT_OFFSET = 34, NPC_SUPPORT_OFFSET_COND = 35, 
+	NPC_DISPATCH_ACTION = 36, NPC_UNKNOWN3 = 37, NPC_UNKNOWN4 = 38, 
+	NPC_START_TALKING = 39, NPC_JUMP_ADDRESS = 40,
+	NONE = 0
+};
+
+struct CurrentActionOutput {
+	uint8 action;
+	uint8 hsAction;
+	uint16 roomNumber;
+	uint16 hotspotId;
+	uint16 usedId;
+};
+
+int numParams[NPC_JUMP_ADDRESS+1] = {0, 
+	1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 2, 0, 1,
+	0, 1, 1, 1, 1, 0, 0, 2, 0, 1, 0, 0, 1, 1, 2, 2, 5, 2, 2, 1};
+
+#ifdef ENGLISH_LURE
+#define NUM_JUMP_OFFSETS 2
+uint16 jumpOffsets[2] = {0x87be, 0x881c};
+#endif
+
+#define MAX_BUFFER_ENTRIES 50
+#define MAX_INSTRUCTION_ENTRIES 300
+#define SCHEDULE_DATA_OFFSET 0x60
+
+struct SupportStructure {
+	uint16 offset;
+	int numInstructions;
+	uint16 instructionOffsets[MAX_INSTRUCTION_ENTRIES];	
+	uint16 resourceOffset;
+};
+
+SupportStructure supportList[MAX_BUFFER_ENTRIES];
+uint16 numSupportEntries = 0;
+
+#define FORWARD_JUMP_ALLOWANCE 0x30
+
+
+uint16 get_sequence_index(uint16 offset, int supportIndex) {
+	int index;
+
+	if (supportIndex != -1) {
+		// Within a sequence, so if an offset is within it, it's a local jump
+		for (index = 0; index < supportList[supportIndex].numInstructions; ++index) {
+			if (supportList[supportIndex].instructionOffsets[index] == offset)
+				return index;
+		}
+	}
+
+	for (int index = 0; index <= numSupportEntries; ++index) {
+		SupportStructure &rec = supportList[index];
+
+		if ((rec.numInstructions > 0) &&
+			(offset >= rec.instructionOffsets[0]) && 
+			(offset <= rec.instructionOffsets[rec.numInstructions - 1])) {
+			// Scan through the entry's insruction list
+			for (int iIndex = 0; iIndex < rec.numInstructions; ++iIndex) {
+				if (rec.instructionOffsets[iIndex] == offset) {
+					return ((index + 1) << 10) | iIndex;
+				}
+			}
+		}
+	}
+
+	return 0xffff;
+}
+
+struct SymbolTableEntry {
+	uint16 *p;
+	bool globalNeeded;
+};
+
+uint16 process_action_sequence_entry(int supportIndex, byte *data, uint16 remainingSize) {
+	SupportStructure &rec = supportList[supportIndex];
+	uint16 startOffset = rec.offset;
+	uint16 maxOffset = 0;
+#ifdef ENGLISH_LURE
+	if (startOffset == 0x7dcb) { startOffset = 0x7d9d; maxOffset = 0x7dcb; }
+	if (startOffset == 0x7248) { startOffset = 0x71ce; maxOffset = 0x7248; }
+	if (startOffset == 0x79a8) { startOffset = 0x785c; maxOffset = 0x79a8; }
+	if (startOffset == 0x6f4f) { startOffset = 0x6e5d; maxOffset = 0x6fe5; }
+	if (startOffset == 0x734a) maxOffset = 0x77a2;
+#endif
+
+	SymbolTableEntry symbolTable[MAX_INSTRUCTION_ENTRIES];
+	uint16 numSymbols = 0;
+	uint16 offset = startOffset;
+	uint16 totalSize = 0;
+	uint16 actionNum = 0;
+	uint16 paramIndex;
+	uint16 params[5];
+	uint16 index;
+	uint16 *pOut = (uint16 *) data;
+
+	lure_exe.seek(DATA_SEGMENT + startOffset);
+	rec.numInstructions = 0;
+
+	for (;;) {
+		if (remainingSize < 10) {
+			printf("Ran out of space to process NPC action sequences\n");
+			exit(1);
+		}
+
+		// Check for end of sequence set with prior instruction
+		if ((actionNum == NPC_SET_SUPPORT_OFFSET) && ((maxOffset == 0) ||
+			(offset > maxOffset)))
+			break;
+
+		// Mark the offset of the next instruction
+		rec.instructionOffsets[rec.numInstructions++] = offset;
+		if (rec.numInstructions == MAX_INSTRUCTION_ENTRIES) {
+			printf("A method exceeded the maximum allowable number of instructions\n");
+			exit(1);
+		}
+
+		// Get in the next action
+		actionNum = lure_exe.readWord();
+
+//		printf("%xh - action=%d", offset, actionNum);
+
+		if (actionNum == 0) {
+			// At end of script block
+//			printf("\n");
+			break;
+		}
+		else if (actionNum > NPC_JUMP_ADDRESS) {
+			// Unknown action code - halt execution
+			printf("%xh - unknown action %d\n", offset, actionNum);
+			exit(1);
+		}
+
+		*pOut++ = TO_LE_16(actionNum);
+
+		// Read in any action parameters
+		for (int paramCtr = 0; paramCtr < numParams[actionNum]; ++paramCtr)
+			params[paramCtr] = lure_exe.readWord();
+
+		switch(actionNum) {
+		case NPC_SET_ROOM_AND_BLOCKED_OFFSET:
+		case NPC_SET_SUPPORT_OFFSET:
+		case NPC_SUPPORT_OFFSET_COND:
+		case NPC_DISPATCH_ACTION:
+			// These instructions have a support record parameter. Store the
+			// offset the parameter will be in the output data so we can come
+			// back at the end and resolve it
+			paramIndex = (actionNum == NPC_SET_SUPPORT_OFFSET) ? 0 : 1;
+			symbolTable[numSymbols].globalNeeded = actionNum == NPC_SET_ROOM_AND_BLOCKED_OFFSET;
+			symbolTable[numSymbols].p = pOut + paramIndex;
+			++numSymbols;
+
+			// Special check for forward references - it's considered to be in
+			// the same block if it's forward within 100h blocks
+			if ((params[paramIndex] > offset) && 
+				(params[paramIndex] < offset + FORWARD_JUMP_ALLOWANCE) &&
+				(params[paramIndex] > maxOffset)) {
+				maxOffset = params[paramIndex];
+			} 
+			break;
+
+		case NPC_JUMP_ADDRESS:
+			// Make sure the address is in the known list
+			index = 0;
+			while ((index < NUM_JUMP_OFFSETS) && (jumpOffsets[index] != params[0]))
+				++index;
+			
+			if (index != NUM_JUMP_OFFSETS)
+				// Replace code offset with an index			
+				params[0] = index;
+			else {
+				printf("Encountered unrecognised NPC code jump point: %xh\n", params[0]);
+				exit(1);
+			}
+			break;
+
+		default:
+			break;
+		}
+
+		// Output parameters
+		for (paramIndex = 0; paramIndex < numParams[actionNum]; ++paramIndex)
+			*pOut++ = TO_LE_16(params[paramIndex]);
+
+		// Increase size
+		totalSize += (numParams[actionNum] + 1) * sizeof(uint16); 
+		offset = startOffset + totalSize;
+		remainingSize -= (numParams[actionNum] + 1) * sizeof(uint16);
+	}
+
+	// Flag an end of the sequence
+	*pOut++ = 0;
+	totalSize += sizeof(uint16);
+
+	// handle post-processing of the symbol list
+
+	for (int symbolCtr = 0; symbolCtr < numSymbols; ++symbolCtr) {
+		if (READ_LE_UINT16(symbolTable[symbolCtr].p) == 0) 
+			// No Id special constant
+			WRITE_LE_UINT16(symbolTable[symbolCtr].p, 0xffff);
+		else {
+			// Handle resolving the constant
+			index = get_sequence_index(READ_LE_UINT16(symbolTable[symbolCtr].p), 
+				symbolTable[symbolCtr].globalNeeded ? -1 : supportIndex);
+//printf("Symbol %xh => %xh\n", *symbolTable[symbolCtr].p, index);
+			if (index != 0xffff) {
+				// Jump found - so replace symbol entry with it 
+				WRITE_LE_UINT16(symbolTable[symbolCtr].p, index);
+			} else {
+				printf("Sequence contained unknown offset %xh\n", 
+					READ_LE_UINT16(symbolTable[symbolCtr].p));
+				exit(1);
+			}
+		}
+	}
+
+	return totalSize;
+}
+
+void process_entry(uint16 offset, byte *data, uint16 &totalSize) {
+	if (get_sequence_index(offset) == 0xffff) {
+		// Process the next entry
+		supportList[numSupportEntries].offset = offset;
+		supportList[numSupportEntries].numInstructions = 0;
+		supportList[numSupportEntries].resourceOffset = totalSize;
+//printf("process_entry index=%d, offset=%xh\n", numSupportEntries + 1, offset);
+		totalSize += process_action_sequence_entry(numSupportEntries, 
+			data + totalSize,  MAX_DATA_SIZE - totalSize);
+
+		++numSupportEntries;
+		if (numSupportEntries == MAX_BUFFER_ENTRIES) {
+			printf("Ran out of buffer space in processing NPC schedules\n");
+			exit(1);
+		}
+	}
+}
+
+void read_action_sequence(byte *&data, uint16 &totalSize) 
+{
+	const uint16 hsOffset = 0x5d98;
+	const uint16 hsStartId = 0x3e8;
+	uint16 hotspotIndex;
+	HotspotHeaderEntry entryHeader;
+	CurrentActionInput action;
+	uint16 *pHeader;
+	int index;
+
+	// Allocate enough space for output sequence list
+	data = (byte *) malloc(MAX_DATA_SIZE);
+
+	// Get a list of offsets used in the script engine
+	uint16 offsetList[NUM_TABLED_ACTION_BLOCKS];
+	lure_exe.seek(DATA_SEGMENT + TABLED_ACTIONS_OFFSET, SEEK_SET);
+	for (index = 0; index < NUM_TABLED_ACTION_BLOCKS; ++index)
+		offsetList[index] = lure_exe.readWord();
+
+	totalSize = SCHEDULE_DATA_OFFSET;
+	numSupportEntries = 0;
+
+	// Handle required initial entries - the Lure engine refers to them directly by
+	// index, so they need to be first, and in that order
+#ifdef ENGLISH_LURE
+	process_entry(0x13c2, data, totalSize);
+	process_entry(0xbb95, data, totalSize);
+	process_entry(0x7060, data, totalSize);
+	process_entry(0x728a, data, totalSize);
+#endif
+
+	// Process the script engine list 
+	
+	for (index = 0; index < NUM_TABLED_ACTION_BLOCKS; ++index) 
+		process_entry(offsetList[index], data, totalSize);
+
+	// Next process each of the character hotspots
+
+	hotspotIndex = 0;
+	for (;;) {
+		lure_exe.seek(DATA_SEGMENT + hsOffset + 
+			hotspotIndex * sizeof(HotspotHeaderEntry));
+		lure_exe.read(&entryHeader, sizeof(HotspotHeaderEntry));
+		if (FROM_LE_16(entryHeader.offset) == 0xffff) break;
+		++hotspotIndex;
+
+		// Move to the action sequence area of the hotspot
+		lure_exe.seek(DATA_SEGMENT + entryHeader.offset + 0x63);
+		lure_exe.read(&action, sizeof(CurrentActionInput));
+		if (FROM_LE_16(action.action) == 2) 
+			process_entry(FROM_LE_16(action.dataOffset), data, totalSize);
+	}
+
+	// Output the list used in the script engine
+
+	pHeader = (uint16 *) data;
+	for (index = 0; index < NUM_TABLED_ACTION_BLOCKS; ++index) 
+		*pHeader++ = TO_LE_16(get_sequence_index(offsetList[index]));
+	*pHeader++ = 0xffff;
+
+	// Output the offsets of each action set
+
+	for (index = 0; index < numSupportEntries; ++index) 
+		*pHeader++ = TO_LE_16(supportList[index].resourceOffset);
+	*pHeader++ = 0xffff;
+
+	if ((int) ((byte *) pHeader - data) > SCHEDULE_DATA_OFFSET) {
+		printf("SCHEDULE_DATA_OFFSET was not high enough\n");
+		exit(1);
+	}
+}