Merge branch 'master' into xeen

1 files changed, 1080 insertions, 0 deletions

diff --git a/devtools/create_titanic/create_titanic_dat.cpp b/devtools/create_titanic/create_titanic_dat.cpp
new file mode 100644
index 0000000000..61e5de1149
--- /dev/null
+++ b/devtools/create_titanic/create_titanic_dat.cpp
@@ -0,0 +1,1080 @@
+/* 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.
+ *
+ */
+
+ // Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+// HACK to allow building with the SDL backend on MinGW
+// see bug #1800764 "TOOLS: MinGW tools building broken"
+#ifdef main
+#undef main
+#endif // main
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "common/language.h"
+#include "common/rect.h"
+#include "winexe_pe.h"
+#include "file.h"
+#include "script_preresponses.h"
+#include "script_quotes.h"
+#include "script_responses.h"
+#include "script_ranges.h"
+#include "script_states.h"
+#include "tag_maps.h"
+
+/**
+ * Format of the access.dat file that will be created:
+ * 4 Bytes - Magic string 'SVTN' to identify valid data file
+ * 2 bytes - Version number
+ *
+ * Following is a series of index entries with the following fields:
+ * 4 bytes - offset in file of entry
+ * 4 bytes - size of entry in the file
+ * ASCIIZ  - name of the resource
+ */
+
+#define VERSION_NUMBER 1
+#define HEADER_SIZE 0xD00
+
+Common::File inputFile, outputFile;
+Common::PEResources res;
+uint headerOffset = 6;
+uint dataOffset = HEADER_SIZE;
+
+#define ENGLISH_10042C_FILESIZE 4099072
+#define ENGLISH_10042B_FILESIZE 4095488
+#define ENGLISH_10042_FILESIZE 4094976
+enum {
+	ENGLISH_10042C_DIFF = 0x401C00,
+	ENGLISH_10042B_DIFF = 0x401400,
+	ENGLISH_10042_DIFF = 0x402000
+};
+enum Version {
+	ENGLISH_10042C = 0,
+	ENGLISH_10042B = 1,
+	ENGLISH_10042 = 2
+};
+Version _version;
+
+const int FILE_DIFF[3] = { 
+	ENGLISH_10042C_DIFF, ENGLISH_10042B_DIFF, ENGLISH_10042_DIFF 
+};
+
+static const char *const ITEM_NAMES[46] = {
+	"LeftArmWith", "LeftArmWithout", "RightArmWith", "RightArmWithout", "BridgeRed",
+	"BridgeYellow", "BridgeBlue", "BridgeGreen", "Parrot", "CentralCore", "BrainGreen",
+	"BrainYellow", "BrainRed", "BrainBlue", "ChickenGreasy", "ChickenPlain", "ChickenPurple",
+	"ChickenRed", "ChickenYellow", "CrushedTV", "Ear", "Ear1", "Eyeball", "Eyeball1",
+	"Feather", "Lemon", "GlassEmpty", "GlassPurple", "GlassRed", "GlassYellow", "Hammer",
+	"Hose", "HoseEnd", "LiftHead", "LongStick", "Magazine", "Mouth", "MusicKey", "Napkin",
+	"Nose", "Perch", "PhonoCylinder", "PhonoCylinder1", "PhonoCylinder2", "PhonoCylinder3",
+	"Photo"
+};
+
+static const char *const ITEM_DESCRIPTIONS[46] = {
+	"The Maitre d'Bot's left arm holding a key", "The Maitre d'Bot's left arm",
+	"The Maitre d'Bot's right arm holding Titania's auditory center",
+	"The Maitre d'Bot's right arm", "Red Fuse", "Yellow Fuse", "Blue Fuse",
+	"Green Fuse", "The Parrot", "Titania's central intelligence core",
+	"Titania's auditory center", "Titania's olfactory center",
+	"Titania's speech center", "Titania's vision center", "rather greasy chicken",
+	"very plain chicken", "chicken smeared with starling pur$e",
+	"chicken covered with tomato sauce", "chicken coated in mustard sauce",
+	"A crushed television set", "Titania's ear", "Titania's ear", "Titania's eye",
+	"Titania's eye", "A parrot feather", "A nice fat juicy lemon",
+	"An empty beer glass", "A beer glass containing pur$ed flock of starlings",
+	"A beer glass containing tomato sauce", "A beer glass containing mustard sauce",
+	"A hammer", "A hose", "The other end of a hose", "The LiftBot's head",
+	"A rather long stick", "A magazine", "Titania's mouth", "A key",
+	"A super-absorbent napkin", "Titania's nose", "A perch", "A phonograph cylinder",
+	"A phonograph cylinder", "A phonograph cylinder", "A phonograph cylinder",
+	"A photograph"
+};
+
+static const char *const ITEM_IDS[40] = {
+	"MaitreD Left Arm", "MaitreD Right Arm", "OlfactoryCentre", "AuditoryCentre",
+	"SpeechCentre", "VisionCentre", "CentralCore", "Perch", "SeasonBridge",
+	"FanBridge", "BeamBridge", "ChickenBridge", "CarryParrot", "Chicken",
+	"CrushedTV", "Feathers", "Lemon", "BeerGlass", "BigHammer", "Ear1", "Ear 2",
+	"Eye1", "Eye2", "Mouth", "Nose", "NoseSpare", "Hose", "DeadHoseSpare",
+	"HoseEnd", "DeadHoseEndSpare", "BrokenLiftbotHead", "LongStick", "Magazine",
+	"Napkin", "Phonograph Cylinder", "Phonograph Cylinder 1", "Phonograph Cylinder 2",
+	"Phonograph Cylinder 3", "Photograph", "Music System Key"
+};
+
+static const char *const ROOM_NAMES[34] = {
+	"1stClassLobby", "1stClassRestaurant", "1stClassState",
+	"2ndClassLobby", "secClassState", "Arboretum", "FrozenArboretum",
+	"Bar", "BilgeRoom", "BilgeRoomWith", "BottomOfWell", "Bridge",
+	"CreatorsChamber", "CreatorsChamberOn", "Dome", "Home", "Lift",
+	"EmbLobby", "MoonEmbLobby", "MusicRoomLobby", "MusicRoom",
+	"ParrotLobby", "Pellerator", "PromenadeDeck", "SculptureChamber",
+	"SecClassLittleLift", "ServiceElevator", "SGTLeisure", "SGTLittleLift",
+	"SgtLobby", "SGTState", "Titania", "TopOfWell", "PlayersRoom"
+};
+
+struct NumberEntry {
+	const char *_text;
+	int _value;
+	uint _flags;
+};
+
+const NumberEntry NUMBERS[76] = {
+	{ "a", 1, 3 },
+	{ "and", 0, 1 },
+	{ "negative", 0, 10 },
+	{ "minus", 0, 10 },
+	{ "below zeor", 0, 8 },
+	{ "degrees below zero", 0, 8 },
+	{ "nil", 0, 2 },
+	{ "zero", 0, 2 },
+	{ "one", 1, 0x12 },
+	{ "two", 2, 0x12 },
+	{ "three", 3, 0x12 },
+	{ "four", 4, 0x12 },
+	{ "five", 5, 0x12 },
+	{ "six", 6, 0x12 },
+	{ "seven", 7, 0x12 },
+	{ "eight", 8, 0x12 },
+	{ "nine", 9, 0x12 },
+	{ "0", 0, 2 },
+	{ "1", 1, 2 },
+	{ "2", 2, 2 },
+	{ "3", 3, 2 },
+	{ "4", 4, 2 },
+	{ "5", 5, 2 },
+	{ "6", 6, 2 },
+	{ "7", 7, 2 },
+	{ "8", 8, 2 },
+	{ "9", 9, 2 },
+	{ "first", 1, 2 },
+	{ "second", 2, 2 },
+	{ "third", 3, 2 },
+	{ "fourth", 4, 2 },
+	{ "fifth", 5, 2 },
+	{ "sixth", 6, 2 },
+	{ "seventh", 7, 2 },
+	{ "eighth", 8, 2 },
+	{ "ninth", 9, 2 },
+	{ "ten", 10, 2 },
+	{ "eleven", 11, 2 },
+	{ "twelve", 12, 2 },
+	{ "thirteen", 13, 2 },
+	{ "fourteen", 14, 2 },
+	{ "fifteen", 15, 2 },
+	{ "sixteen", 16, 2 },
+	{ "seventeen", 17, 2 },
+	{ "eighteen", 18, 2 },
+	{ "nineteen", 19, 2 },
+	{ "tenth", 10, 2 },
+	{ "eleventh", 11, 2 },
+	{ "twelfth", 12, 2 },
+	{ "thirteenth", 13, 2 },
+	{ "fourteenth", 14, 2 },
+	{ "fifteenth", 15, 2 },
+	{ "sixteenth", 16, 2 },
+	{ "seventeenth", 17, 2 },
+	{ "eighteenth", 18, 2 },
+	{ "nineteenth", 19, 2 },
+	{ "twenty", 20, 0x12 },
+	{ "thirty", 30, 0x12 },
+	{ "forty", 40, 0x12 },
+	{ "fourty", 40, 0x12 },
+	{ "fifty", 50, 0x12 },
+	{ "sixty", 60, 0x12 },
+	{ "seventy", 70, 0x12 },
+	{ "eighty", 80, 0x12 },
+	{ "ninety", 90, 0x12 },
+	{ "twentieth", 20, 2 },
+	{ "thirtieth", 30, 2 },
+	{ "fortieth", 40, 2 },
+	{ "fiftieth", 50, 2 },
+	{ "sixtieth", 60, 2 },
+	{ "seventieth", 70, 2 },
+	{ "eightieth", 80, 2 },
+	{ "ninetieth", 90, 2 },
+	{ "hundred", 100, 4 },
+	{ "hundredth", 100, 6 }
+};
+
+struct CommonPhrase {
+	const char *_str;
+	uint _dialogueId;
+	uint _roomNum;
+	uint _val1;
+};
+
+static const CommonPhrase BELLBOT_COMMON_PHRASES[] = {
+	{ "what is wrong with her", 0x30FF9, 0x7B, 0 },
+	{ "what is wrong with titania", 0x30FF9, 0x7B, 0 },
+	{ "something for the weekend", 0x30D8B, 0x00, 0 },
+	{ "other food", 0x30E1D, 0x00, 3 },
+	{ "different food", 0x30E1D, 0x00, 3 },
+	{ "alternative food", 0x30E1D, 0x00, 3 },
+	{ "decent food", 0x30E1D, 0x00, 3 },
+	{ "nice food", 0x30E1D, 0x00, 3 },
+	{ "nicer food", 0x30E1D, 0x00, 3 },
+	{ "make me happy", 0x31011, 0x00, 0 },
+	{ "cheer me up", 0x31011, 0x00, 0 },
+	{ "help me if im unhappy", 0x31011, 0x00, 0 },
+	{ "i obtain a better room", 0x30E8A, 0x00, 3 },
+	{ "i obtain a better room", 0x30E8A, 0x00, 2 },
+	{ "i get a better room", 0x30E8A, 0x00, 3 },
+	{ "i get a better room", 0x30E8A, 0x00, 2 },
+	{ "i want a better room", 0x30E8A, 0x00, 3 },
+	{ "i want a better room", 0x30E8A, 0x00, 2 },
+	{ "i understood", 0x30D75, 0x6D, 0 },
+	{ "i knew", 0x30D75, 0x6D, 0 },
+	{ "i know", 0x30D75, 0x6D, 0 },
+	{ "not stupid", 0x30D75, 0x6D, 0 },
+	{ "cheeky", 0x30D75, 0x6D, 0 },
+	{ "not help", 0x30D6F, 0x6D, 0 },
+	{ "not helpful", 0x30D6F, 0x6D, 0 },
+	{ "dont help", 0x30D6F, 0x6D, 0 },
+	{ "no help", 0x30D6F, 0x6D, 0 },
+	{ "sorry", 0x30D76, 0x6D, 0 },
+	{ "not mean that", 0x30D76, 0x6D, 0 },
+	{ "didnt mean that", 0x30D76, 0x6D, 0 },
+	{ "apologise", 0x30D76, 0x6D, 0 },
+	{ "play golf", 0x313B6, 0x00, 0 },
+	{ "is not the captain meant to go down with the ship", 0x31482, 0x00, 0 },
+	{ "is not the captain supposed to go down with the ship", 0x31482, 0x00, 0 },
+	{ "sauce sticks to the chicken", 0x3156B, 0x00, 0 },
+	{ "sauce gets stuck to the chicken", 0x3156B, 0x00, 0 },
+	{ nullptr, 0, 0, 0 }
+};
+
+struct FrameRange {
+	int _startFrame;
+	int _endFrame;
+};
+
+static const FrameRange BARBOT_FRAME_RANGES[60] = {
+	{ 558, 585 }, { 659, 692 }, { 802, 816 }, { 1941, 1977 }, { 1901, 1941 },
+	{ 810, 816 }, { 857, 865}, { 842, 857 }, { 821, 842 }, { 682, 692 },
+	{ 1977, 2018 }, { 2140, 2170 }, { 2101, 2139 }, { 2018, 2099}, { 1902, 2015 },
+	{ 1811, 1901 }, { 1751, 1810 }, { 1703, 1750 }, { 1681, 1702 }, { 1642, 1702 },
+	{ 1571, 1641 }, { 1499, 1570 }, { 1403, 1463 }, { 1464, 1499 }, { 1288, 1295 },
+	{ 1266, 1287 }, { 1245, 1265 }, { 1208, 1244 }, { 1171, 1207 }, { 1120, 1170 },
+	{ 1092, 1120 }, { 1092, 1092 }, { 1044, 1091 }, { 1011, 1043 }, { 1001, 1010 },
+	{ 985, 1001 }, { 927, 984 }, { 912, 926 }, { 898, 906 }, { 802, 896 },
+	{ 865, 896 }, { 842, 865 }, { 816, 842 }, { 802, 842 }, { 740, 801 },
+	{ 692, 740 }, { 610, 692 }, { 558, 610 }, { 500, 558 }, { 467, 500 },
+	{ 421, 466 }, { 349, 420 }, { 306, 348 }, { 305, 306 }, { 281, 305 },
+	{ 202, 281 }, { 182, 202 }, { 165, 182 }, { 96, 165 }, { 0, 95 }
+};
+
+static const char *const MISSIVEOMAT_MESSAGES[3] = {
+	"Welcome, Leovinus.\n"
+	"\n"
+	"This is your Missive-O-Mat.\n"
+	"\n"
+	"You have received 1827 Electric Missives.\n"
+	"\n"
+	"For your convenience I have deleted:\n"
+	" 453 things that people you don't know thought it would be "
+	"terribly witty to forward to you,\n"
+	" 63 Missives containing double or triple exclamation marks,\n"
+	" 846 Missives from mailing-lists you once thought might be quite "
+	"interesting and now can't figure out how to cancel,\n"
+	" 962 Chain Missives,\n"
+	" 1034 instructions on how to become a millionaire using butter,\n"
+	" 3 Yassaccan Death Threats (slightly down on last week which is"
+	" pleasing news),\n"
+	" and a Missive from your Mother which I have answered reassuringly.\n"
+	"\n"
+	"I have selected the following Missives for your particular attention. "
+	"You will not need to run Fib-Finder to see why.  Something Is Up and I "
+	"suspect those two slippery urchins Brobostigon and Scraliontis are behind it.",
+
+	"Hello Droot.  I have evaluated your recent missives.\n"
+	"Contents break down as follows:\n"
+	"\n"
+	"Good news 49%\n"
+	"Bad news 48%\n"
+	"Indifferent news 4%\n"
+	"Petty mailings and Family Missives 5%\n"
+	"Special Offers from the Blerontin Sand Society 1% (note - there's"
+	" a rather pretty dune for hire on p4)\n"
+	"\n"
+	"In general terms you Thrive.  You continue to Prosper.   Your shares are"
+	" Secure.  Your hair, as always, looks Good.  Carpet 14 needs cleaning.  \n"
+	"\n"
+	"I am pleased to report there have been no further comments about "
+	"foot odor.\n"
+	"\n"
+	"Recommend urgently you sell all fish paste shares as Market jittery.\n"
+	"\n"
+	"As your Great Scheme nears completion I have taken the liberty of"
+	" replying to all non-urgent Missives and list below only communic"
+	"ations with Manager Brobostigon and His Pain in the Ass Loftiness"
+	" Leovinus.  \n"
+	"\n"
+	"Beware - Leovinus grows suspicious.  Don't take your eye off B"
+	"robostigon.  \n"
+	"\n"
+	"Weather for the Launch tomorrow is bright and sunny.  Hazy clouds"
+	" will be turned on at eleven.  I suggest the red suit with the st"
+	"reamers.\n"
+	"\n"
+	"All money transfers will be completed through alias accounts by m"
+	"oonsup.\n"
+	"\n"
+	"Eat well.  Your fish levels are down and you may suffer indecisio"
+	"n flutters mid-morning.\n"
+	"\n"
+	"Here are your Missives...",
+
+	"Hello Antar, this is your Missive-o-Mat.\n"
+	"Not that you need reminding but today is the Glorious Dawning of "
+	"a New Age in Luxury Space Travel.\n"
+	"\n"
+	"Generally my assessment of your position this morning is that you"
+	" are well, albeit not as rich as you would like to be.  I hope yo"
+	"ur interesting collaboration with Mr Scraliontis will soon bear f"
+	"ruit. \n"
+	"\n"
+	"I trust your flatulence has eased during the night.  Such a distr"
+	"essing condition for a man in your position.\n"
+	"\n"
+	"Most of your Missives are routine construction matters which I ha"
+	"ve dealt with and deleted.  All Missives from Mr Scraliontis and "
+	"His Loftiness Leovinus are here."
+};
+
+struct BedheadEntry {
+	const char *_name1;
+	const char *_name2;
+	const char *_name3;
+	const char *_name4;
+	int _startFrame;
+	int _endFrame;
+};
+
+static const BedheadEntry ON_CLOSED[4] = {
+	{ "Closed", "Closed", "Open", "Open", 0, 12 },
+	{ "Open", "Any", "Any", "RestingUTV", 0, 4 },
+	{ "Closed", "Open", "Any", "RestingV", 0, 6 },
+	{ "Closed", "Closed", "Closed", "RestingG", 0, 21 }
+};
+static const BedheadEntry ON_RESTING_TV[2] = {
+	{ "Any", "Closed", "Open", "Open", 6, 12 },
+	{ "Any", "Closed", "Closed", "RestingG", 6, 21 }
+};
+static const BedheadEntry ON_RESTING_UV[2] = {
+	{ "Any", "Any", "Open", "Open", 8, 12 },
+	{ "Any", "Any", "Closed", "RestingG", 8, 21 }
+};
+static const BedheadEntry ON_CLOSED_WRONG[2] = {
+	{ "Any", "Any", "Closed", "OpenWrong", 42, 56 },
+	{ "Any", "Any", "Open", "RestingDWrong", 42, 52 }
+};
+
+static const BedheadEntry OFF_OPEN[3] = {
+	{ "Closed", "Closed", "Open", "Closed", 27, 41 },
+	{ "Any", "Open", "Any", "RestingUV", 27, 29 },
+	{ "Open", "Closed", "Any", "RestingTV", 27, 33 }
+};
+static const BedheadEntry OFF_RESTING_UTV[1] = {
+	{ "Any", "Any", "Any", "Closed", 36, 41 }
+};
+static const BedheadEntry OFF_RESTING_V[1] = {
+	{ "Closed", "Any", "Any", "Closed", 32, 41 }
+};
+static const BedheadEntry OFF_RESTING_G[3] = {
+	{ "Closed", "Closed", "Closed", "Closed", 21, 41 },
+	{ "Any", "Open", "Closed", "RestingUV", 21, 29 },
+	{ "Open", "Closed", "Closed", "RestingTV", 21, 33 }
+};
+static const BedheadEntry OFF_OPEN_WRONG[1] = {
+	{ "Any", "Any", "Any", "ClosedWrong", 56, 70 }
+};
+static const BedheadEntry OFF_RESTING_D_WRONG[1] = {
+	{ "Any", "Any", "Any", "ClosedWrong", 59, 70 }
+};
+
+
+void NORETURN_PRE error(const char *s, ...) {
+	printf("%s\n", s);
+	exit(1);
+}
+
+void writeEntryHeader(const char *name, uint offset, uint size) {
+	assert(headerOffset < HEADER_SIZE);
+	outputFile.seek(headerOffset);
+	outputFile.writeLong(offset);
+	outputFile.writeLong(size);
+	outputFile.writeString(name);
+
+	headerOffset += 8 + strlen(name) + 1;
+}
+
+void writeFinalEntryHeader() {
+	assert(headerOffset <= (HEADER_SIZE - 8));
+	outputFile.seek(headerOffset);
+	outputFile.writeLong(0);
+	outputFile.writeLong(0);
+}
+
+void writeStringArray(const char *name, uint offset, int count) {
+	outputFile.seek(dataOffset);
+
+	inputFile.seek(offset - FILE_DIFF[_version]);
+	uint *offsets = new uint[count];
+	for (int idx = 0; idx < count; ++idx)
+		offsets[idx] = inputFile.readLong();
+
+	// Iterate through reading each string
+	for (int idx = 0; idx < count; ++idx) {
+		if (offsets[idx]) {
+			inputFile.seek(offsets[idx] - FILE_DIFF[_version]);
+			outputFile.writeString(inputFile);
+		} else {
+			outputFile.writeString("");
+		}
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader(name, dataOffset, size);
+	dataOffset += size;
+
+	delete[] offsets;
+}
+
+void writeStringArray(const char *name, const char *const *strings, int count) {
+	outputFile.seek(dataOffset);
+
+	// Iterate through writing each string
+	for (int idx = 0; idx < count; ++idx) {
+		outputFile.writeString(strings[idx]);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader(name, dataOffset, size);
+	dataOffset += size;
+}
+
+Common::WinResourceID getResId(uint id) {
+	return Common::WinResourceID(id);
+}
+
+Common::WinResourceID getResId(const char *id) {
+	if (!strcmp(id, "Bitmap"))
+		return Common::WinResourceID(2);
+
+	return Common::WinResourceID(id);
+}
+
+void writeResource(const char *name, Common::File *file) {
+	outputFile.seek(dataOffset);
+	outputFile.write(*file, file->size());
+
+	writeEntryHeader(name, dataOffset, file->size());
+	dataOffset += file->size();
+	delete file;
+}
+
+void writeResource(const char *sectionStr, uint32 resId) {
+	char nameBuffer[256];
+	sprintf(nameBuffer, "%s/%u", sectionStr, resId);
+	
+	Common::File *file = res.getResource(getResId(sectionStr), resId);
+	assert(file);
+	writeResource(nameBuffer, file);
+}
+
+void writeResource(const char *sectionStr, const char *resId) {
+	char nameBuffer[256];
+	sprintf(nameBuffer, "%s/%s", sectionStr, resId);
+
+	Common::File *file = res.getResource(getResId(sectionStr), 
+		Common::WinResourceID(resId));
+	assert(file);
+	writeResource(nameBuffer, file);
+}
+
+void writeBitmap(const char *name, Common::File *file) {
+	outputFile.seek(dataOffset);
+
+	// Write out the necessary bitmap header so that the ScummVM
+	// BMP decoder can properly handle decoding the bitmaps
+	outputFile.write("BM", 2);
+	outputFile.writeLong(file->size() + 14);	// Filesize
+	outputFile.writeLong(0);					// res1 & res2
+	outputFile.writeLong(0x436);				// image offset
+
+	outputFile.write(*file, file->size());
+
+	writeEntryHeader(name, dataOffset, file->size() + 14);
+	dataOffset += file->size() + 14;
+	delete file;
+}
+
+void writeBitmap(const char *sectionStr, const char *resId) {
+	char nameBuffer[256];
+	sprintf(nameBuffer, "%s/%s", sectionStr, resId);
+
+	Common::File *file = res.getResource(getResId(sectionStr),
+		Common::WinResourceID(resId));
+	assert(file);
+	writeBitmap(nameBuffer, file);
+}
+
+void writeBitmap(const char *sectionStr, uint32 resId) {
+	char nameBuffer[256];
+	sprintf(nameBuffer, "%s/%u", sectionStr, resId);
+
+	Common::File *file = res.getResource(getResId(sectionStr),
+		Common::WinResourceID(resId));
+	assert(file);
+	writeBitmap(nameBuffer, file);
+}
+
+void writeNumbers() {
+	outputFile.seek(dataOffset);
+
+	// Iterate through writing each string
+	for (int idx = 0; idx < 76; ++idx) {
+		outputFile.writeString(NUMBERS[idx]._text);
+		outputFile.writeLong(NUMBERS[idx]._value);
+		outputFile.writeLong(NUMBERS[idx]._flags);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("TEXT/NUMBERS", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeString(uint offset) {
+	inputFile.seek(offset - FILE_DIFF[_version]);
+	char c;
+	do {
+		c = inputFile.readByte();
+		outputFile.writeByte(c);
+	} while (c);
+}
+
+void writeResponseTree() {
+	outputFile.seek(dataOffset);
+	
+	const int OFFSETS[3] = { 0x619520, 0x618340, 0x617380 };
+	for (int idx = 0; idx < 1022; ++idx) {
+		inputFile.seek(OFFSETS[_version] - FILE_DIFF[_version] + idx * 8);
+		uint id = inputFile.readLong();
+		uint offset = inputFile.readLong();
+
+		outputFile.writeLong(id);
+		if (!id) {
+			// An end of list id
+		} else if (offset >= OFFSETS[_version] && offset <= (OFFSETS[_version] + 0x1FF0)) {
+			// Offset to another table
+			outputFile.writeByte(0);
+			outputFile.writeLong((offset - OFFSETS[_version]) / 8);
+		} else {
+			// Offset to ASCIIZ string
+			outputFile.writeByte(1);
+			writeString(offset);
+		}
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("TEXT/TREE", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeSentenceEntries(const char *name, uint tableOffset) {
+	outputFile.seek(dataOffset);
+
+	uint v1, v2, v4, v9, v11, v12, v13;
+	uint offset3, offset5, offset6, offset7, offset8, offset10;
+
+	for (uint idx = 0; ; ++idx) {
+		inputFile.seek(tableOffset - FILE_DIFF[_version] + idx * 0x34);
+		v1 = inputFile.readLong();
+		if (!v1)
+			// Reached end of list
+			break;
+
+		// Read data fields
+		v2 = inputFile.readLong();
+		offset3 = inputFile.readLong();
+		v4 = inputFile.readLong();
+		offset5 = inputFile.readLong();
+		offset6 = inputFile.readLong();
+		offset7 = inputFile.readLong();
+		offset8 = inputFile.readLong();
+		v9 = inputFile.readLong();
+		offset10 = inputFile.readLong();
+		v11 = inputFile.readLong();
+		v12 = inputFile.readLong();
+		v13 = inputFile.readLong();
+
+		outputFile.writeLong(v1);
+		outputFile.writeLong(v2);
+		writeString(offset3);
+		outputFile.writeLong(v1);
+		writeString(offset5);
+		writeString(offset6);
+		writeString(offset7);
+		writeString(offset8);
+		outputFile.writeLong(v9);
+		writeString(offset10);
+		outputFile.writeLong(v11);
+		outputFile.writeLong(v12);
+		outputFile.writeLong(v13);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader(name, dataOffset, size);
+	dataOffset += size;
+}
+
+void writeWords(const char *name, uint tableOffset, int recordCount = 2) {
+	outputFile.seek(dataOffset);
+	int recordSize = recordCount * 4;
+
+	uint val, strOffset;
+	for (uint idx = 0; ; ++idx) {
+		inputFile.seek(tableOffset - FILE_DIFF[_version] + idx * recordSize);
+		val = inputFile.readLong();
+		strOffset = inputFile.readLong();
+
+		if (!val)
+			// Reached end of list
+			break;
+
+		outputFile.writeLong(val);
+		writeString(strOffset);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader(name, dataOffset, size);
+	dataOffset += size;
+}
+
+void writeSentenceMappings(const char *name, uint offset, int numValues) {
+	inputFile.seek(offset - FILE_DIFF[_version]);
+	outputFile.seek(dataOffset);
+
+	uint id;
+	while ((id = inputFile.readLong()) != 0) {
+		outputFile.writeLong(id);
+
+		for (int ctr = 0; ctr < numValues; ++ctr)
+			outputFile.writeLong(inputFile.readLong());
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader(name, dataOffset, size);
+	dataOffset += size;
+}
+
+void writeStarfieldPoints() {
+	outputFile.seek(dataOffset);
+
+	const int OFFSETS[3] = { 0x59DE4C, 0x59DBEC, 0x59CC1C };
+	inputFile.seek(OFFSETS[_version] - FILE_DIFF[_version]);
+	uint size = 876 * 12;
+
+	outputFile.write(inputFile, size);
+	writeEntryHeader("STARFIELD/POINTS", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeStarfieldPoints2() {
+	outputFile.seek(dataOffset);
+
+	const int OFFSETS[3] = { 0x5A2F28, 0x5A2CC8, 0x5A1CF8 };
+	for (int rootCtr = 0; rootCtr < 80; ++rootCtr) {
+		inputFile.seek(OFFSETS[_version] - FILE_DIFF[_version] + rootCtr * 8);
+		uint offset = inputFile.readUint32LE();
+		uint count = inputFile.readUint32LE();
+
+		outputFile.writeLong(count);
+		inputFile.seek(offset - FILE_DIFF[_version]);
+		outputFile.write(inputFile, count * 4 * 4);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	outputFile.write(inputFile, size);
+	writeEntryHeader("STARFIELD/POINTS2", dataOffset, size);
+	dataOffset += size;
+}
+
+void writePhrases(const char *name, const CommonPhrase *phrases) {
+	for (uint idx = 0; phrases->_str; ++idx, ++phrases) {
+		outputFile.seek(dataOffset + idx * 4);
+		outputFile.writeString(phrases->_str);
+		outputFile.writeLong(phrases->_dialogueId);
+		outputFile.writeLong(phrases->_roomNum);
+		outputFile.writeLong(phrases->_val1);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("Phrases/Bellbot", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeBarbotFrameRanges() {
+	outputFile.seek(dataOffset);
+
+	for (int idx = 0; idx < 60; ++idx) {
+		outputFile.writeLong(BARBOT_FRAME_RANGES[idx]._startFrame);
+		outputFile.writeLong(BARBOT_FRAME_RANGES[idx]._endFrame);
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("FRAMES/BARBOT", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeMissiveOMatMessages() {
+	outputFile.seek(dataOffset);
+
+	for (int idx = 0; idx < 3; ++idx)
+		outputFile.writeString(MISSIVEOMAT_MESSAGES[idx]);
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("TEXT/MISSIVEOMAT/WELCOME", dataOffset, size);
+	dataOffset += size;
+
+	static const int MESSAGES[3] = { 0x5A63C0, 0x5A5BA8, 0x5A4A18 };
+	writeStringArray("TEXT/MISSIVEOMAT/MESSAGES", MESSAGES[_version], 58);
+	static const int FROM[3] = { 0x5A61F0, 0x5A59D8, 0x5A4BE8 };
+	writeStringArray("TEXT/MISSIVEOMAT/FROM", FROM[_version], 58);
+	static const int TO[3] = { 0x5A62D8, 0x5A5AC0, 0x5A4B00 };
+	writeStringArray("TEXT/MISSIVEOMAT/TO", TO[_version], 58);
+}
+
+void writeBedheadGroup(const BedheadEntry *data, int count) {
+	for (int idx = 0; idx < count; ++idx, ++data) {
+		outputFile.writeString(data->_name1);
+		outputFile.writeString(data->_name2);
+		outputFile.writeString(data->_name3);
+		outputFile.writeString(data->_name4);
+		outputFile.writeLong(data->_startFrame);
+		outputFile.writeLong(data->_endFrame);
+	}
+}
+
+void writeBedheadData() {
+	outputFile.seek(dataOffset);
+
+	writeBedheadGroup(ON_CLOSED, 4);
+	writeBedheadGroup(ON_RESTING_TV, 2);
+	writeBedheadGroup(ON_RESTING_UV, 2);
+	writeBedheadGroup(ON_CLOSED_WRONG, 2);
+	writeBedheadGroup(OFF_OPEN, 3);
+	writeBedheadGroup(OFF_RESTING_UTV, 1);
+	writeBedheadGroup(OFF_RESTING_V, 1);
+	writeBedheadGroup(OFF_RESTING_G, 3);
+	writeBedheadGroup(OFF_OPEN_WRONG, 1);
+	writeBedheadGroup(OFF_RESTING_D_WRONG, 1);
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("DATA/BEDHEAD", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeParrotLobbyLinkUpdaterEntries() {
+	static const int OFFSETS[3] = { 0x5A5B38, 0x5A5320, 0x5A4360 };
+	static const int COUNTS[5] = { 7, 5, 6, 9, 1 };
+	static const int SKIP[5] = { 36, 36, 40, 36, 0 };
+	uint recordOffset = OFFSETS[_version], linkOffset;
+	byte vals[8];
+
+	outputFile.seek(dataOffset);
+
+	for (int groupNum = 0; groupNum < 4; ++groupNum) {
+		for (int entryNum = 0; entryNum < COUNTS[groupNum];
+				++entryNum, recordOffset += 36) {
+			inputFile.seek(recordOffset - FILE_DIFF[_version]);
+			linkOffset = inputFile.readUint32LE();
+			for (int idx = 0; idx < 8; ++idx)
+				vals[idx] = inputFile.readUint32LE();
+		
+			// Write out the entry
+			inputFile.seek(linkOffset - FILE_DIFF[_version]);
+			outputFile.writeString(inputFile);
+			outputFile.write(vals, 8);
+		}
+
+		// Skip space between groups
+		recordOffset += SKIP[groupNum];
+	}
+
+	uint size = outputFile.size() - dataOffset;
+	writeEntryHeader("DATA/PARROT_LOBBY_LINK_UPDATOR", dataOffset, size);
+	dataOffset += size;
+}
+
+void writeHeader() {
+	// Write out magic string
+	const char *MAGIC_STR = "SVTN";
+	outputFile.write(MAGIC_STR, 4);
+
+	// Write out version number
+	outputFile.writeWord(VERSION_NUMBER);
+}
+
+void writeData() {
+	writeBitmap("Bitmap", "BACKDROP");
+	writeBitmap("Bitmap", "EVILTWIN");
+	writeBitmap("Bitmap", "RESTORED");
+	writeBitmap("Bitmap", "RESTOREF");
+	writeBitmap("Bitmap", "RESTOREU");
+	writeBitmap("Bitmap", "STARTD");
+	writeBitmap("Bitmap", "STARTF");
+	writeBitmap("Bitmap", "STARTU");
+	writeBitmap("Bitmap", "TITANIC");
+	writeBitmap("Bitmap", 133);
+	writeBitmap("Bitmap", 164);
+	writeBitmap("Bitmap", 165);
+
+	writeResource("STFONT", 149);
+	writeResource("STFONT", 151);
+	writeResource("STFONT", 152);
+	writeResource("STFONT", 153);
+
+	writeResource("STARFIELD", 132);
+	writeStarfieldPoints();
+	writeStarfieldPoints2();
+
+	writeResource("TEXT", "STVOCAB.TXT");
+	writeResource("TEXT", "JRQUOTES.TXT");
+	writeResource("TEXT", 155);
+
+	writeStringArray("TEXT/ITEM_DESCRIPTIONS", ITEM_DESCRIPTIONS, 46);
+	writeStringArray("TEXT/ITEM_NAMES", ITEM_NAMES, 46);
+	writeStringArray("TEXT/ITEM_IDS", ITEM_IDS, 40);
+	writeStringArray("TEXT/ROOM_NAMES", ROOM_NAMES, 34);
+
+	const int TEXT_PHRASES[3] = { 0x61D3C8, 0x618340, 0x61B1E0 };
+	const int TEXT_REPLACEMENTS1[3] = { 0x61D9B0, 0x61C788, 0x61B7C8 };
+	const int TEXT_REPLACEMENTS2[3] = { 0x61DD20, 0x61CAF8, 0x61BB38 };
+	const int TEXT_REPLACEMENTS3[3] = { 0x61F5C8, 0x61E3A0, 0x61D3E0 };
+	const int TEXT_PRONOUNS[3] = { 0x631318, 0x6300F8, 0x62F138 };
+	writeStringArray("TEXT/PHRASES", TEXT_PHRASES[_version], 376);
+	writeStringArray("TEXT/REPLACEMENTS1", TEXT_REPLACEMENTS1[_version], 218);
+	writeStringArray("TEXT/REPLACEMENTS2", TEXT_REPLACEMENTS2[_version], 1576);
+	writeStringArray("TEXT/REPLACEMENTS3", TEXT_REPLACEMENTS3[_version], 82);
+	writeStringArray("TEXT/PRONOUNS", TEXT_PRONOUNS[_version], 15);
+
+	const int SENTENCES_DEFAULT[3] = { 0x5C0130, 0x5BEFC8, 0x5BE008 };
+	const int SENTENCES_BARBOT[2][3] = {
+		{ 0x5ABE60, 0x5AACF8, 0x5A9D38 }, { 0x5BD4E8, 0x5BC380, 0x5BB3C0 }
+	};
+	const int SENTENCES_BELLBOT[20][3] = {
+		{ 0x5C2230, 0x5C10C8, 0X5C0108 }, { 0x5D1670, 0x5D0508, 0x5CF548 },
+		{ 0x5D1A80, 0x5D0918, 0x5CF958 }, { 0x5D1AE8, 0x5D0980, 0x5CF9C0 },
+		{ 0x5D1B88, 0x5D0A20, 0x5CFA60 }, { 0x5D2A60, 0x5D18F8, 0x5D0938 },
+		{ 0x5D2CD0, 0x5D1B68, 0x5D0BA8 }, { 0x5D3488, 0x5D2320, 0x5D1360 }, 
+		{ 0x5D3900, 0x5D2798, 0x5D17D8 }, { 0x5D3968, 0x5D2800, 0x5D1840 },
+		{ 0x5D4668, 0x5D3500, 0x5D2540 }, { 0x5D47A0, 0x5D3638, 0x5D2678 },
+		{ 0x5D4EC0, 0x5D3D58, 0x5D2D98 }, { 0x5D5100, 0x5D3F98, 0x5D2FD8 },
+		{ 0x5D5370, 0x5D4208, 0x5D3248 }, { 0x5D5548, 0x5D43E0, 0x5D3420 },
+		{ 0x5D56B8, 0x5D4550, 0x5D3590 }, { 0x5D57C0, 0x5D4658, 0x5D3698 },
+		{ 0x5D5B38, 0x5D49D0, 0x5D3A10 }, { 0x5D61B8, 0x5D5050, 0x5D4090 }
+	};
+	writeSentenceEntries("Sentences/Default", SENTENCES_DEFAULT[_version]);
+	writeSentenceEntries("Sentences/Barbot", SENTENCES_BARBOT[0][_version]);
+	writeSentenceEntries("Sentences/Barbot2", SENTENCES_BARBOT[1][_version]);
+	writeSentenceEntries("Sentences/Bellbot", SENTENCES_BELLBOT[0][_version]);
+	writeSentenceEntries("Sentences/Bellbot/1", SENTENCES_BELLBOT[1][_version]);
+	writeSentenceEntries("Sentences/Bellbot/2", SENTENCES_BELLBOT[2][_version]);
+	writeSentenceEntries("Sentences/Bellbot/3", SENTENCES_BELLBOT[3][_version]);
+	writeSentenceEntries("Sentences/Bellbot/4", SENTENCES_BELLBOT[4][_version]);
+	writeSentenceEntries("Sentences/Bellbot/5", SENTENCES_BELLBOT[5][_version]);
+	writeSentenceEntries("Sentences/Bellbot/6", SENTENCES_BELLBOT[6][_version]);
+	writeSentenceEntries("Sentences/Bellbot/7", SENTENCES_BELLBOT[7][_version]);
+	writeSentenceEntries("Sentences/Bellbot/8", SENTENCES_BELLBOT[8][_version]);
+	writeSentenceEntries("Sentences/Bellbot/9", SENTENCES_BELLBOT[9][_version]);
+	writeSentenceEntries("Sentences/Bellbot/10", SENTENCES_BELLBOT[10][_version]);
+	writeSentenceEntries("Sentences/Bellbot/11", SENTENCES_BELLBOT[11][_version]);
+	writeSentenceEntries("Sentences/Bellbot/12", SENTENCES_BELLBOT[12][_version]);
+	writeSentenceEntries("Sentences/Bellbot/13", SENTENCES_BELLBOT[13][_version]);
+	writeSentenceEntries("Sentences/Bellbot/14", SENTENCES_BELLBOT[14][_version]);
+	writeSentenceEntries("Sentences/Bellbot/15", SENTENCES_BELLBOT[15][_version]);
+	writeSentenceEntries("Sentences/Bellbot/16", SENTENCES_BELLBOT[16][_version]);
+	writeSentenceEntries("Sentences/Bellbot/17", SENTENCES_BELLBOT[17][_version]);
+	writeSentenceEntries("Sentences/Bellbot/18", SENTENCES_BELLBOT[18][_version]);
+	writeSentenceEntries("Sentences/Bellbot/19", SENTENCES_BELLBOT[19][_version]);
+
+	const int SENTENCES_DESKBOT[3][3] = {
+		{ 0x5DCD10, 0x5DBBA8, 0x5DABE8 }, { 0x5E8E18, 0x5E7CB0, 0x5E6CF0 },
+		{ 0x5E8BA8, 0x5E7A40, 0x5E6A80 }
+	};
+	writeSentenceEntries("Sentences/Deskbot", SENTENCES_DESKBOT[0][_version]);
+	writeSentenceEntries("Sentences/Deskbot/2", SENTENCES_DESKBOT[1][_version]);
+	writeSentenceEntries("Sentences/Deskbot/3", SENTENCES_DESKBOT[2][_version]);
+	
+	const int SENTENCES_DOORBOT[12][3] = {
+		{ 0x5EC110, 0x5EAFA8, 0x5E9FE8 }, { 0x5FD930, 0x5FC7C8, 0x5FB808 },
+		{ 0x5FDD0C, 0x5FCBA4, 0x5FBBE4 }, { 0x5FE668, 0x5FD500, 0x5FC540 },
+		{ 0x5FDD40, 0x5FCBD8, 0X5FBC18 }, { 0x5FFF08, 0x5FEDA0, 0x5FDDE0 },
+		{ 0x5FE3C0, 0x5FD258, 0x5FC298 }, { 0x5FF0C8, 0x5FDF60, 0x5FCFA0 },
+		{ 0x5FF780, 0x5FE618, 0x5FD658 }, { 0x5FFAC0, 0x5FE958, 0x5FD998 },
+		{ 0x5FFC30, 0x5FEAC8, 0x5FDB08 }, { 0x6000E0, 0x5FEF78, 0x5FDFB8 }
+	};
+	writeSentenceEntries("Sentences/Doorbot", SENTENCES_DOORBOT[0][_version]);
+	writeSentenceEntries("Sentences/Doorbot/2", SENTENCES_DOORBOT[1][_version]);
+	writeSentenceEntries("Sentences/Doorbot/100", SENTENCES_DOORBOT[2][_version]);
+	writeSentenceEntries("Sentences/Doorbot/101", SENTENCES_DOORBOT[3][_version]);
+	writeSentenceEntries("Sentences/Doorbot/102", SENTENCES_DOORBOT[4][_version]);
+	writeSentenceEntries("Sentences/Doorbot/107", SENTENCES_DOORBOT[5][_version]);
+	writeSentenceEntries("Sentences/Doorbot/110", SENTENCES_DOORBOT[6][_version]);
+	writeSentenceEntries("Sentences/Doorbot/111", SENTENCES_DOORBOT[7][_version]);
+	writeSentenceEntries("Sentences/Doorbot/124", SENTENCES_DOORBOT[8][_version]);
+	writeSentenceEntries("Sentences/Doorbot/129", SENTENCES_DOORBOT[9][_version]);
+	writeSentenceEntries("Sentences/Doorbot/131", SENTENCES_DOORBOT[10][_version]);
+	writeSentenceEntries("Sentences/Doorbot/132", SENTENCES_DOORBOT[11][_version]);
+
+	const int SENTENCES_LIFTBOT[3] = { 0x6026B0, 0x601548, 0x600588 };
+	const int SENTENCES_MAITRED[2][3] = {
+		{ 0x60CFD8, 0x60BE70, 0x60AEB0 }, { 0x614288, 0x613120, 0x612160 }
+	};
+	const int SENTENCES_PARROT[3] = { 0x615858, 0x6146F0, 0x613730 };
+	const int SENTENCES_SUCCUBUS[3] = { 0x616698, 0x615530, 0x614570 };
+	const int MAPPINGS_BARBOT[3] = { 0x5B28A0, 0x5B173E, 0x5B0778 };
+	const int MAPPINGS_BELLBOT[3] = { 0x5CD830, 0x5CC6C8, 0x5CB708 };
+	const int MAPPINGS_DESKBOT[3] = { 0x5E2BB8, 0x5E1A50, 0x5E0A90 };
+	const int MAPPINGS_DOORBOT[3] = { 0x5F7950, 0x5F67E8, 0x5F5828 };
+	const int MAPPINGS_LIFTBOT[3] = { 0x608660, 0x6074F8, 0x606538 };
+	const int MAPPINGS_MAITRED[3] = { 0x6125C8, 0x611460, 0x6104A0 };
+	const int MAPPINGS_PARROT[3] = { 0x615B68, 0x614A00, 0x613A40 };
+	const int MAPPINGS_SUCCUBUS[3] = { 0x6189F0, 0x617888, 0x6168C8 };
+	const int WORDS_BARBOT[3] = { 0x5BE2E0, 0x5BD178, 0x5BC1B8 };
+	const int WORDS_BELLBOT[3] = { 0x5D8230, 0x5D70C8, 0x5D6108 };
+	const int WORDS_DESKBOT[3] = { 0x5EAAA8, 0x5E9940, 0x5E8980 };
+	const int WORDS_DOORBOT[3] = { 0x601098, 0x5FFF30, 0x5FEF70 };
+	const int WORDS_LIFTBOT[3] = { 0x60C788, 0x60B620, 0x60A660 };
+	writeSentenceEntries("Sentences/Liftbot", SENTENCES_LIFTBOT[_version]);
+	writeSentenceEntries("Sentences/MaitreD", SENTENCES_MAITRED[0][_version]);
+	writeSentenceEntries("Sentences/MaitreD/1", SENTENCES_MAITRED[1][_version]);
+	writeSentenceEntries("Sentences/Parrot", SENTENCES_PARROT[_version]);
+	writeSentenceEntries("Sentences/SuccUBus", SENTENCES_SUCCUBUS[_version]);
+	writeSentenceMappings("Mappings/Barbot", MAPPINGS_BARBOT[_version], 8);
+	writeSentenceMappings("Mappings/Bellbot", MAPPINGS_BELLBOT[_version], 1);
+	writeSentenceMappings("Mappings/Deskbot", MAPPINGS_DESKBOT[_version], 4);
+	writeSentenceMappings("Mappings/Doorbot", MAPPINGS_DOORBOT[_version], 4);
+	writeSentenceMappings("Mappings/Liftbot", MAPPINGS_LIFTBOT[_version], 4);
+	writeSentenceMappings("Mappings/MaitreD", MAPPINGS_MAITRED[_version], 1);
+	writeSentenceMappings("Mappings/Parrot", MAPPINGS_PARROT[_version], 1);
+	writeSentenceMappings("Mappings/SuccUBus", MAPPINGS_SUCCUBUS[_version], 1);
+	writeWords("Words/Barbot", WORDS_BARBOT[_version]);
+	writeWords("Words/Bellbot", WORDS_BELLBOT[_version]);
+	writeWords("Words/Deskbot", WORDS_DESKBOT[_version]);
+	writeWords("Words/Doorbot", WORDS_DOORBOT[_version], 3);
+	writeWords("Words/Liftbot", WORDS_LIFTBOT[_version]);
+	writePhrases("Phrases/Bellbot", BELLBOT_COMMON_PHRASES);
+
+	writeResponseTree();
+	writeNumbers();
+	writeAllScriptQuotes();
+	writeAllScriptResponses();
+	writeAllScriptRanges();
+
+	writeAllTagMappings();
+	writeAllUpdateStates();
+	writeAllScriptPreResponses();
+	writeBarbotFrameRanges();
+	writeMissiveOMatMessages();
+	writeBedheadData();
+	writeParrotLobbyLinkUpdaterEntries();
+}
+
+void createScriptMap() {
+	Common::File inFile;
+	char line[80];
+	char c[2];
+	c[0] = c[1] = '\0';
+	int counter = 0;
+
+	inFile.open("d:\\temp\\map.txt");
+	printf("static const TagMapping xxxx_ID_MAP[] = {\n");
+
+	do {
+		strcpy(line, "");
+
+		while (!inFile.eof()) {
+			c[0] = inFile.readByte();
+			if (c[0] == '\n')
+				c[0] = ' ';
+			else if (c[0] == '\r')
+				continue;
+			strcat(line, c);
+			if (inFile.eof() || strlen(line) == (2 * 9))
+				break;
+		}
+
+		int v1, v2;
+		sscanf(line, "%x %x", &v1, &v2);
+
+		if (counter != 0 && (counter % 3) == 0)
+			printf("\r\n");
+		if ((counter % 3) == 0)
+			printf("\t");
+
+		printf("{ 0x%.5x, 0x%.5x }, ", v1, v2);
+		++counter;
+	} while (!inFile.eof());
+
+	printf("};\r\n");
+	inFile.close();
+}
+
+int main(int argc, char *argv[]) {
+	if (argc != 3) {
+		printf("Format: %s ST.exe titanic.dat\n", argv[0]);
+		exit(0);
+	}
+
+	if (!inputFile.open(argv[1])) {
+		error("Could not open input file");
+	}
+	res.loadFromEXE(argv[1]);
+
+	if (inputFile.size() == ENGLISH_10042C_FILESIZE)
+		_version = ENGLISH_10042C;
+	else if (inputFile.size() == ENGLISH_10042B_FILESIZE)
+		_version = ENGLISH_10042B;
+	else if (inputFile.size() == ENGLISH_10042_FILESIZE)
+		_version = ENGLISH_10042;
+	else {
+		printf("Unknown version of ST.exe specified");
+		exit(0);
+	}
+
+	if (!outputFile.open(argv[2], Common::kFileWriteMode)) {
+		error("Could not open output file");
+	}
+
+	writeHeader();
+	writeData();
+	writeFinalEntryHeader();
+
+	inputFile.close();
+	outputFile.close();
+	return 0;
+}