- Got rid of hardcoded filename list for kyra.dat

- Synced static resource definitions between KYRA main codebase and create_kyradat
- Rebuilt kyra.dat

svn-id: r46047

9 files changed, 1123 insertions, 1087 deletions

diff --git a/dists/engine-data/kyra.dat b/dists/engine-data/kyra.dat
index fdb7652868..513ff2da5f 100644
--- a/dists/engine-data/kyra.dat
+++ b/dists/engine-data/kyra.dat
diff --git a/engines/kyra/resource.h b/engines/kyra/resource.h
index 504d3deac4..f8a2c1c4ca 100644
--- a/engines/kyra/resource.h
+++ b/engines/kyra/resource.h
@@ -102,6 +102,239 @@ protected:
 enum KyraResources {
 	kLoadAll = -1,
 
+	// This list has to match orderwise (and thus value wise) the static data list of "tools/create_kyradat/create_kyradat.h"!
+	k1ForestSeq,
+	k1KallakWritingSeq,
+	k1KyrandiaLogoSeq,
+	k1KallakMalcolmSeq,
+	k1MalcolmTreeSeq,
+	k1WestwoodLogoSeq,
+
+	k1Demo1Seq,
+	k1Demo2Seq,
+	k1Demo3Seq,
+	k1Demo4Seq,
+
+	k1AmuleteAnimSeq,
+
+	k1OutroReunionSeq,
+
+	k1IntroCPSStrings,
+	k1IntroCOLStrings,
+	k1IntroWSAStrings,
+	k1IntroStrings,
+
+	k1OutroHomeString,
+
+	k1RoomFilenames,
+	k1RoomList,
+
+	k1CharacterImageFilenames,
+
+	k1ItemNames,
+	k1TakenStrings,
+	k1PlacedStrings,
+	k1DroppedStrings,
+	k1NoDropStrings,
+
+	k1PutDownString,
+	k1WaitAmuletString,
+	k1BlackJewelString,
+	k1PoisonGoneString,
+	k1HealingTipString,
+	k1WispJewelStrings,
+	k1MagicJewelStrings,
+
+	k1ThePoisonStrings,
+	k1FluteStrings,
+
+	k1FlaskFullString,
+	k1FullFlaskString,
+
+	k1VeryCleverString,
+	k1NewGameString,
+
+	k1DefaultShapes,
+	k1Healing1Shapes,
+	k1Healing2Shapes,
+	k1PoisonDeathShapes,
+	k1FluteShapes,
+	k1Winter1Shapes,
+	k1Winter2Shapes,
+	k1Winter3Shapes,
+	k1DrinkShapes,
+	k1WispShapes,
+	k1MagicAnimShapes,
+	k1BranStoneShapes,
+
+	k1SpecialPalette1,
+	k1SpecialPalette2,
+	k1SpecialPalette3,
+	k1SpecialPalette4,
+	k1SpecialPalette5,
+	k1SpecialPalette6,
+	k1SpecialPalette7,
+	k1SpecialPalette8,
+	k1SpecialPalette9,
+	k1SpecialPalette10,
+	k1SpecialPalette11,
+	k1SpecialPalette12,
+	k1SpecialPalette13,
+	k1SpecialPalette14,
+	k1SpecialPalette15,
+	k1SpecialPalette16,
+	k1SpecialPalette17,
+	k1SpecialPalette18,
+	k1SpecialPalette19,
+	k1SpecialPalette20,
+	k1SpecialPalette21,
+	k1SpecialPalette22,
+	k1SpecialPalette23,
+	k1SpecialPalette24,
+	k1SpecialPalette25,
+	k1SpecialPalette26,
+	k1SpecialPalette27,
+	k1SpecialPalette28,
+	k1SpecialPalette29,
+	k1SpecialPalette30,
+	k1SpecialPalette31,
+	k1SpecialPalette32,
+	k1SpecialPalette33,
+
+	k1GUIStrings,
+	k1ConfigStrings,
+
+	k1AudioTracks,
+	k1AudioTracksIntro,
+
+	k1CreditsStrings,
+
+	k1TownsSFXwdTable,
+	k1TownsSFXbtTable,
+	k1TownsCDATable,
+
+	k1PC98StoryStrings,
+	k1PC98IntroSfx,
+
+	k1AmigaIntroSFXTable,
+	k1AmigaGameSFXTable,
+
+	k2SeqplayPakFiles,
+	k2SeqplayCredits,
+	k2SeqplayCreditsSpecial,
+	k2SeqplayStrings,
+	k2SeqplaySfxFiles,
+	k2SeqplayTlkFiles,
+	k2SeqplaySeqData,
+	k2SeqplayIntroTracks,
+	k2SeqplayFinaleTracks,
+	k2SeqplayIntroCDA,
+	k2SeqplayFinaleCDA,
+	k2SeqplayShapeAnimData,
+
+	k2IngamePakFiles,
+	k2IngameSfxFiles,
+	k2IngameSfxIndex,
+	k2IngameTracks,
+	k2IngameCDA,
+	k2IngameTalkObjIndex,
+	k2IngameTimJpStrings,
+	k2IngameShapeAnimData,
+	k2IngameTlkDemoStrings,
+
+	k3MainMenuStrings,
+	k3MusicFiles,
+	k3ScoreTable,
+	k3SfxFiles,
+	k3SfxMap,
+	k3ItemAnimData,
+	k3ItemMagicTable,
+	k3ItemStringMap,
+
+#ifdef ENABLE_LOL
+	kLolIngamePakFiles,
+	kLolCharacterDefs,
+	kLolIngameSfxFiles,
+	kLolIngameSfxIndex,
+	kLolMusicTrackMap,
+	kLolIngameGMSfxIndex,
+	kLolIngameMT32SfxIndex,
+	kLolIngamePcSpkSfxIndex,
+	kLolSpellProperties,
+	kLolGameShapeMap,
+	kLolSceneItemOffs,
+	kLolCharInvIndex,
+	kLolCharInvDefs,
+	kLolCharDefsMan,
+	kLolCharDefsWoman,
+	kLolCharDefsKieran,
+	kLolCharDefsAkshel,
+	kLolExpRequirements,
+	kLolMonsterModifiers,
+	kLolMonsterShiftOffsets,
+	kLolMonsterDirFlags,
+	kLolMonsterScaleY,
+	kLolMonsterScaleX,
+	kLolMonsterScaleWH,
+	kLolFlyingObjectShp,
+	kLolInventoryDesc,
+
+	kLolLevelShpList,
+	kLolLevelDatList,
+	kLolCompassDefs,
+	kLolItemPrices,
+	kLolStashSetup,
+
+	kLolDscUnk1,
+	kLolDscShapeIndex,
+	kLolDscOvlMap,
+	kLolDscScaleWidthData,
+	kLolDscScaleHeightData,
+	kLolDscX,
+	kLolDscY,
+	kLolDscTileIndex,
+	kLolDscUnk2,
+	kLolDscDoorShapeIndex,
+	kLolDscDimData1,
+	kLolDscDimData2,
+	kLolDscBlockMap,
+	kLolDscDimMap,
+	kLolDscDoor1,
+	kLolDscDoorScale,
+	kLolDscDoor4,
+	kLolDscDoorX,
+	kLolDscDoorY,
+	kLolDscOvlIndex,
+	kLolDscBlockIndex,
+
+	kLolScrollXTop,
+	kLolScrollYTop,
+	kLolScrollXBottom,
+	kLolScrollYBottom,
+
+	kLolButtonDefs,
+	kLolButtonList1,
+	kLolButtonList2,
+	kLolButtonList3,
+	kLolButtonList4,
+	kLolButtonList5,
+	kLolButtonList6,
+	kLolButtonList7,
+	kLolButtonList8,
+
+	kLolLegendData,
+	kLolMapCursorOvl,
+	kLolMapStringId,
+
+	kLolSpellbookAnim,
+	kLolSpellbookCoords,
+	kLolHealShapeFrames,
+	kLolLightningDefs,
+	kLolFireballCoords,
+
+	kLolCredits,
+
+	kLolHistory,
 	k1ForestSeq,
 	k1KallakWritingSeq,
 	k1KyrandiaLogoSeq,
@@ -347,7 +580,7 @@ class StaticResource {
 public:
 	static const Common::String staticDataFilename() { return "KYRA.DAT"; }
 
-	StaticResource(KyraEngine_v1 *vm) : _vm(vm), _resList(), _fileLoader(0), _builtIn(0), _filenameTable(0) {}
+	StaticResource(KyraEngine_v1 *vm) : _vm(vm), _resList(), _fileLoader(0), _builtIn(0), _dataTable(0) {}
 	~StaticResource() { deinit(); }
 
 	bool loadStaticResourceFile();
@@ -390,27 +623,25 @@ private:
 
 	bool checkResList(int id, int &type, const void *&ptr, int &size);
 	const void *checkForBuiltin(int id, int &type, int &size);
-	const FilenameTable *searchFile(int id);
 	const FileType *getFiletype(int type);
 	const void *getData(int id, int requesttype, int &size);
 
-	bool loadLanguageTable(const char *filename, void *&ptr, int &size);
-	bool loadStringTable(const char *filename, void *&ptr, int &size);
-	bool loadRawData(const char *filename, void *&ptr, int &size);
-	bool loadShapeTable(const char *filename, void *&ptr, int &size);
-	bool loadAmigaSfxTable(const char *filename, void *&ptr, int &size);
-	bool loadRoomTable(const char *filename, void *&ptr, int &size);
-	bool loadHofSequenceData(const char *filename, void *&ptr, int &size);
-	bool loadShapeAnimData_v1(const char *filename, void *&ptr, int &size);
-	bool loadShapeAnimData_v2(const char *filename, void *&ptr, int &size);
+	bool loadStringTable(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadRawData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadShapeTable(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadAmigaSfxTable(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadRoomTable(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadHofSequenceData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadShapeAnimData_v1(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadShapeAnimData_v2(Common::SeekableReadStream &stream, void *&ptr, int &size);
 #ifdef ENABLE_LOL
-	bool loadCharData(const char *filename, void *&ptr, int &size);
-	bool loadSpellData(const char *filename, void *&ptr, int &size);
-	bool loadCompassData(const char *filename, void *&ptr, int &size);
-	bool loadFlyingObjectData(const char *filename, void *&ptr, int &size);
-	bool loadRawDataBe16(const char *filename, void *&ptr, int &size);
-	bool loadRawDataBe32(const char *filename, void *&ptr, int &size);
-	bool loadButtonDefs(const char *filename, void *&ptr, int &size);
+	bool loadCharData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadSpellData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadCompassData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadFlyingObjectData(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadRawDataBe16(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadRawDataBe32(Common::SeekableReadStream &stream, void *&ptr, int &size);
+	bool loadButtonDefs(Common::SeekableReadStream &stream, void *&ptr, int &size);
 #endif // ENABLE_LOL
 
 	void freeRawData(void *&ptr, int &size);
@@ -435,24 +666,23 @@ private:
 	Common::SeekableReadStream *getFile(const char *name);
 
 	enum ResTypes {
-		kLanguageList,
-		kStringList,
-		kRoomList,
-		kShapeList,
-		kRawData,
-		kAmigaSfxTable,
-
-		k2SeqData,
-		k2ShpAnimDataV1,
-		k2ShpAnimDataV2,
-
-		kLolCharData,
-		kLolSpellData,
-		kLolCompassData,
-		kLolFlightShpData,
-		kLolRawDataBe16,
-		kLolRawDataBe32,
-		kLolButtonData
+		kStringList = 0,
+		kRawData = 1,
+		kRoomList = 2,
+		kShapeList = 3,
+		kAmigaSfxTable = 4,
+
+		k2SeqData = 5,
+		k2ShpAnimDataV1 = 6,
+		k2ShpAnimDataV2 = 7,
+
+		kLolCharData = 8,
+		kLolSpellData = 9,
+		kLolCompassData = 10,
+		kLolFlightShpData = 11,
+		kLolButtonData = 12,
+		kLolRawDataBe16 = 13,
+		kLolRawDataBe32 = 14
 	};
 
 	struct BuiltinRes {
@@ -462,15 +692,9 @@ private:
 		const void *data;
 	};
 
-	struct FilenameTable {
-		int id;
-		int type;
-		const char *filename;
-	};
-
 	struct FileType {
 		int type;
-		typedef bool (StaticResource::*LoadFunc)(const char *filename, void *&ptr, int &size);
+		typedef bool (StaticResource::*LoadFunc)(Common::SeekableReadStream &stream, void *&ptr, int &size);
 		typedef void (StaticResource::*FreeFunc)(void *&ptr, int &size);
 
 		LoadFunc load;
@@ -488,7 +712,7 @@ private:
 
 	const FileType *_fileLoader;
 	const BuiltinRes *_builtIn;
-	const FilenameTable *_filenameTable;
+	const int *_dataTable;
 };
 
 } // End of namespace Kyra
diff --git a/engines/kyra/staticres.cpp b/engines/kyra/staticres.cpp
index 4fd77a6b9c..137d021ff8 100644
--- a/engines/kyra/staticres.cpp
+++ b/engines/kyra/staticres.cpp
@@ -45,7 +45,7 @@
 
 namespace Kyra {
 
-#define RESFILE_VERSION 65
+#define RESFILE_VERSION 66
 
 namespace {
 bool checkKyraDat(Common::SeekableReadStream *file) {
@@ -69,21 +69,6 @@ bool checkKyraDat(Common::SeekableReadStream *file) {
 	return true;
 }
 
-struct LanguageTypes {
-	Common::Language lang;
-	const char *ext;
-};
-
-const LanguageTypes languages[] = {
-	{ Common::EN_ANY, "ENG" },
-	{ Common::FR_FRA, "FRE" },
-	{ Common::DE_DEU, "GER" },
-	{ Common::ES_ESP, "SPA" },
-	{ Common::IT_ITA, "ITA" },
-	{ Common::JA_JPN, "JPN" },
-	{ Common::UNK_LANG, 0 }
-};
-
 struct IndexTable {
 	int type;
 	int value;
@@ -105,7 +90,7 @@ byte getGameID(const GameFlags &flags) {
 	return Common::find(iGameTable, iGameTable + ARRAYSIZE(iGameTable) - 1, flags.gameID)->value;
 }
 
-/*const IndexTable iLanguageTable[] = {
+const IndexTable iLanguageTable[] = {
 	{ Common::EN_ANY, 0 },
 	{ Common::FR_FRA, 1 },
 	{ Common::DE_DEU, 2 },
@@ -117,7 +102,7 @@ byte getGameID(const GameFlags &flags) {
 
 byte getLanguageID(const GameFlags &flags) {
 	return Common::find(iLanguageTable, iLanguageTable + ARRAYSIZE(iLanguageTable) - 1, flags.lang)->value;
-}*/
+}
 
 const IndexTable iPlatformTable[] = {
 	{ Common::kPlatformPC, 0 },
@@ -235,7 +220,6 @@ bool StaticResource::tryKyraDatLoad() {
 bool StaticResource::init() {
 #define proc(x) &StaticResource::x
 	static const FileType fileTypeTable[] = {
-		{ kLanguageList, proc(loadLanguageTable), proc(freeStringTable) },
 		{ kStringList, proc(loadStringTable), proc(freeStringTable) },
 		{ StaticResource::kRoomList, proc(loadRoomTable), proc(freeRoomTable) },
 		{ kShapeList, proc(loadShapeTable), proc(freeShapeTable) },
@@ -262,289 +246,287 @@ bool StaticResource::init() {
 	_fileLoader = fileTypeTable;
 
 	// Kyrandia 1 Filenames
-	static const FilenameTable kyra1StaticRes[] = {
+	static const int kyra1StaticRes[] = {
 		// INTRO / OUTRO sequences
-		{ k1ForestSeq, kRawData, "FOREST.SEQ" },
-		{ k1KallakWritingSeq, kRawData, "KALLAK-WRITING.SEQ" },
-		{ k1KyrandiaLogoSeq, kRawData, "KYRANDIA-LOGO.SEQ" },
-		{ k1KallakMalcolmSeq, kRawData, "KALLAK-MALCOLM.SEQ" },
-		{ k1MalcolmTreeSeq, kRawData, "MALCOLM-TREE.SEQ" },
-		{ k1WestwoodLogoSeq, kRawData, "WESTWOOD-LOGO.SEQ" },
-		{ k1Demo1Seq, kRawData, "DEMO1.SEQ" },
-		{ k1Demo2Seq, kRawData, "DEMO2.SEQ" },
-		{ k1Demo3Seq, kRawData, "DEMO3.SEQ" },
-		{ k1Demo4Seq, kRawData, "DEMO4.SEQ" },
-		{ k1OutroReunionSeq, kRawData, "REUNION.SEQ" },
+		k1ForestSeq,
+		k1KallakWritingSeq,
+		k1KyrandiaLogoSeq,
+		k1KallakMalcolmSeq,
+		k1MalcolmTreeSeq,
+		k1WestwoodLogoSeq,
+		k1Demo1Seq,
+		k1Demo2Seq,
+		k1Demo3Seq,
+		k1Demo4Seq,
+		k1OutroReunionSeq,
 
 		// INTRO / OUTRO strings
-		{ k1IntroCPSStrings, kStringList, "INTRO-CPS.TXT" },
-		{ k1IntroCOLStrings, kStringList, "INTRO-COL.TXT" },
-		{ k1IntroWSAStrings, kStringList, "INTRO-WSA.TXT" },
-		{ k1IntroStrings, kLanguageList, "INTRO-STRINGS." },
-		{ k1OutroHomeString, kLanguageList, "HOME." },
+		k1IntroCPSStrings,
+		k1IntroCOLStrings,
+		k1IntroWSAStrings,
+		k1IntroStrings,
+		k1OutroHomeString,
 
 		// INGAME strings
-		{ k1ItemNames, kLanguageList, "ITEMLIST." },
-		{ k1TakenStrings, kLanguageList, "TAKEN." },
-		{ k1PlacedStrings, kLanguageList, "PLACED." },
-		{ k1DroppedStrings, kLanguageList, "DROPPED." },
-		{ k1NoDropStrings, kLanguageList, "NODROP." },
-		{ k1PutDownString, kLanguageList, "PUTDOWN." },
-		{ k1WaitAmuletString, kLanguageList, "WAITAMUL." },
-		{ k1BlackJewelString, kLanguageList, "BLACKJEWEL." },
-		{ k1PoisonGoneString, kLanguageList, "POISONGONE." },
-		{ k1HealingTipString, kLanguageList, "HEALINGTIP." },
-		{ k1ThePoisonStrings, kLanguageList, "THEPOISON." },
-		{ k1FluteStrings, kLanguageList, "FLUTE." },
-		{ k1WispJewelStrings, kLanguageList, "WISPJEWEL." },
-		{ k1MagicJewelStrings, kLanguageList, "MAGICJEWEL." },
-		{ k1FlaskFullString, kLanguageList, "FLASKFULL." },
-		{ k1FullFlaskString, kLanguageList, "FULLFLASK." },
-		{ k1VeryCleverString, kLanguageList, "VERYCLEVER." },
-		{ k1NewGameString, kLanguageList, "NEWGAME." },
+		k1ItemNames,
+		k1TakenStrings,
+		k1PlacedStrings,
+		k1DroppedStrings,
+		k1NoDropStrings,
+		k1PutDownString,
+		k1WaitAmuletString,
+		k1BlackJewelString,
+		k1PoisonGoneString,
+		k1HealingTipString,
+		k1ThePoisonStrings,
+		k1FluteStrings,
+		k1WispJewelStrings,
+		k1MagicJewelStrings,
+		k1FlaskFullString,
+		k1FullFlaskString,
+		k1VeryCleverString,
+		k1NewGameString,
 
 		// GUI strings table
-		{ k1GUIStrings, kLanguageList, "GUISTRINGS." },
-		{ k1ConfigStrings, kLanguageList, "CONFIGSTRINGS." },
+		k1GUIStrings,
+		k1ConfigStrings,
 
 		// ROOM table/filenames
-		{ k1RoomList, kRoomList, "ROOM-TABLE.ROOM" },
-		{ k1RoomFilenames, kStringList, "ROOM-FILENAMES.TXT" },
+		k1RoomList,
+		k1RoomFilenames,
 
 		// SHAPE tables
-		{ k1DefaultShapes, kShapeList, "SHAPES-DEFAULT.SHP" },
-		{ k1Healing1Shapes, kShapeList, "HEALING.SHP" },
-		{ k1Healing2Shapes, kShapeList, "HEALING2.SHP" },
-		{ k1PoisonDeathShapes, kShapeList, "POISONDEATH.SHP" },
-		{ k1FluteShapes, kShapeList, "FLUTE.SHP" },
-		{ k1Winter1Shapes, kShapeList, "WINTER1.SHP" },
-		{ k1Winter2Shapes, kShapeList, "WINTER2.SHP" },
-		{ k1Winter3Shapes, kShapeList, "WINTER3.SHP" },
-		{ k1DrinkShapes, kShapeList, "DRINK.SHP" },
-		{ k1WispShapes, kShapeList, "WISP.SHP" },
-		{ k1MagicAnimShapes, kShapeList, "MAGICANIM.SHP" },
-		{ k1BranStoneShapes, kShapeList, "BRANSTONE.SHP" },
+		k1DefaultShapes,
+		k1Healing1Shapes,
+		k1Healing2Shapes,
+		k1PoisonDeathShapes,
+		k1FluteShapes,
+		k1Winter1Shapes,
+		k1Winter2Shapes,
+		k1Winter3Shapes,
+		k1DrinkShapes,
+		k1WispShapes,
+		k1MagicAnimShapes,
+		k1BranStoneShapes,
 
 		// IMAGE filename table
-		{ k1CharacterImageFilenames, kStringList, "CHAR-IMAGE.TXT" },
+		k1CharacterImageFilenames,
 
 		// AMULET anim
-		{ k1AmuleteAnimSeq, kRawData, "AMULETEANIM.SEQ" },
+		k1AmuleteAnimSeq,
 
 		// PALETTE table
-		{ k1SpecialPalette1, kRawData, "PALTABLE1.PAL" },
-		{ k1SpecialPalette2, kRawData, "PALTABLE2.PAL" },
-		{ k1SpecialPalette3, kRawData, "PALTABLE3.PAL" },
-		{ k1SpecialPalette4, kRawData, "PALTABLE4.PAL" },
-		{ k1SpecialPalette5, kRawData, "PALTABLE5.PAL" },
-		{ k1SpecialPalette6, kRawData, "PALTABLE6.PAL" },
-		{ k1SpecialPalette7, kRawData, "PALTABLE7.PAL" },
-		{ k1SpecialPalette8, kRawData, "PALTABLE8.PAL" },
-		{ k1SpecialPalette9, kRawData, "PALTABLE9.PAL" },
-		{ k1SpecialPalette10, kRawData, "PALTABLE10.PAL" },
-		{ k1SpecialPalette11, kRawData, "PALTABLE11.PAL" },
-		{ k1SpecialPalette12, kRawData, "PALTABLE12.PAL" },
-		{ k1SpecialPalette13, kRawData, "PALTABLE13.PAL" },
-		{ k1SpecialPalette14, kRawData, "PALTABLE14.PAL" },
-		{ k1SpecialPalette15, kRawData, "PALTABLE15.PAL" },
-		{ k1SpecialPalette16, kRawData, "PALTABLE16.PAL" },
-		{ k1SpecialPalette17, kRawData, "PALTABLE17.PAL" },
-		{ k1SpecialPalette18, kRawData, "PALTABLE18.PAL" },
-		{ k1SpecialPalette19, kRawData, "PALTABLE19.PAL" },
-		{ k1SpecialPalette20, kRawData, "PALTABLE20.PAL" },
-		{ k1SpecialPalette21, kRawData, "PALTABLE21.PAL" },
-		{ k1SpecialPalette22, kRawData, "PALTABLE22.PAL" },
-		{ k1SpecialPalette23, kRawData, "PALTABLE23.PAL" },
-		{ k1SpecialPalette24, kRawData, "PALTABLE24.PAL" },
-		{ k1SpecialPalette25, kRawData, "PALTABLE25.PAL" },
-		{ k1SpecialPalette26, kRawData, "PALTABLE26.PAL" },
-		{ k1SpecialPalette27, kRawData, "PALTABLE27.PAL" },
-		{ k1SpecialPalette28, kRawData, "PALTABLE28.PAL" },
-		{ k1SpecialPalette29, kRawData, "PALTABLE29.PAL" },
-		{ k1SpecialPalette30, kRawData, "PALTABLE30.PAL" },
-		{ k1SpecialPalette31, kRawData, "PALTABLE31.PAL" },
-		{ k1SpecialPalette32, kRawData, "PALTABLE32.PAL" },
-		{ k1SpecialPalette33, kRawData, "PALTABLE33.PAL" },
+		k1SpecialPalette1,
+		k1SpecialPalette2,
+		k1SpecialPalette3,
+		k1SpecialPalette4,
+		k1SpecialPalette5,
+		k1SpecialPalette6,
+		k1SpecialPalette7,
+		k1SpecialPalette8,
+		k1SpecialPalette9,
+		k1SpecialPalette10,
+		k1SpecialPalette11,
+		k1SpecialPalette12,
+		k1SpecialPalette13,
+		k1SpecialPalette14,
+		k1SpecialPalette15,
+		k1SpecialPalette16,
+		k1SpecialPalette17,
+		k1SpecialPalette18,
+		k1SpecialPalette19,
+		k1SpecialPalette20,
+		k1SpecialPalette21,
+		k1SpecialPalette22,
+		k1SpecialPalette23,
+		k1SpecialPalette24,
+		k1SpecialPalette25,
+		k1SpecialPalette26,
+		k1SpecialPalette27,
+		k1SpecialPalette28,
+		k1SpecialPalette29,
+		k1SpecialPalette30,
+		k1SpecialPalette31,
+		k1SpecialPalette32,
+		k1SpecialPalette33,
 
 		// AUDIO files
-		{ k1AudioTracks, kStringList, "TRACKS.TXT" },
-		{ k1AudioTracksIntro, kStringList, "TRACKSINT.TXT" },
+		k1AudioTracks,
+		k1AudioTracksIntro,
 
 		// FM-TOWNS specific
-		{ k1TownsSFXwdTable, kRawData, "SFXWDTABLE" },
-		{ k1TownsSFXbtTable, kRawData, "SFXBTTABLE" },
-		{ k1TownsCDATable, kRawData, "CDATABLE" },
+		k1TownsSFXwdTable,
+		k1TownsSFXbtTable,
+		k1TownsCDATable,
 
 		// PC98 specific
-		{ k1PC98StoryStrings, kLanguageList, "INTROSTORY." },
-		{ k1PC98IntroSfx, kRawData, "INTROSFX" },
+		k1PC98StoryStrings,
+		k1PC98IntroSfx,
 
 		// CREDITS (used in FM-TOWNS and AMIGA)
-		{ k1CreditsStrings, kRawData, "CREDITS" },
+		k1CreditsStrings,
 
 		// AMIGA specific
-		{ k1AmigaIntroSFXTable, kAmigaSfxTable, "SFXINTRO" },
-		{ k1AmigaGameSFXTable, kAmigaSfxTable, "SFXGAME" },
+		k1AmigaIntroSFXTable,
+		k1AmigaGameSFXTable,
 
-		{ 0, 0, 0 }
+		-1
 	};
 
-	static const FilenameTable kyra2StaticRes[] = {
+	static const int kyra2StaticRes[] = {
 		// Sequence Player
-		{ k2SeqplayPakFiles, kStringList, "S_PAKFILES.TXT" },
-		{ k2SeqplayCredits, kRawData, "S_CREDITS.TXT" },
-		{ k2SeqplayCreditsSpecial, kStringList, "S_CREDITS2.TXT" },
-		{ k2SeqplayStrings, kLanguageList, "S_STRINGS." },
-		{ k2SeqplaySfxFiles, kStringList, "S_SFXFILES.TXT" },
-		{ k2SeqplayTlkFiles, kLanguageList, "S_TLKFILES." },
-		{ k2SeqplaySeqData, k2SeqData, "S_DATA.SEQ" },
-		{ k2SeqplayIntroTracks, kStringList, "S_INTRO.TRA" },
-		{ k2SeqplayFinaleTracks, kStringList, "S_FINALE.TRA" },
-		{ k2SeqplayIntroCDA, kRawData, "S_INTRO.CDA" },
-		{ k2SeqplayFinaleCDA, kRawData, "S_FINALE.CDA" },
-		{ k2SeqplayShapeAnimData, k2ShpAnimDataV1, "S_DEMO.SHP" },
+		k2SeqplayPakFiles,
+		k2SeqplayCredits,
+		k2SeqplayCreditsSpecial,
+		k2SeqplayStrings,
+		k2SeqplaySfxFiles,
+		k2SeqplayTlkFiles,
+		k2SeqplaySeqData,
+		k2SeqplayIntroTracks,
+		k2SeqplayFinaleTracks,
+		k2SeqplayIntroCDA,
+		k2SeqplayFinaleCDA,
+		k2SeqplayShapeAnimData,
 
 		// Ingame
-		{ k2IngamePakFiles, kStringList, "I_PAKFILES.TXT" },
-		{ k2IngameSfxFiles, kStringList, "I_SFXFILES.TRA" },
-		{ k2IngameSfxIndex, kRawData, "I_SFXINDEX.MAP" },
-		{ k2IngameTracks, kStringList, "I_TRACKS.TRA" },
-		{ k2IngameCDA, kRawData, "I_TRACKS.CDA" },
-		{ k2IngameTalkObjIndex, kRawData, "I_TALKOBJECTS.MAP" },
-		{ k2IngameTimJpStrings, kStringList, "I_TIMJPSTR.TXT" },
-		{ k2IngameShapeAnimData, k2ShpAnimDataV2, "I_INVANIM.SHP" },
-		{ k2IngameTlkDemoStrings, kLanguageList, "I_TLKDEMO.TXT." },
-
-		{ 0, 0, 0 }
+		k2IngamePakFiles,
+		k2IngameSfxFiles,
+		k2IngameSfxIndex,
+		k2IngameTracks,
+		k2IngameCDA,
+		k2IngameTalkObjIndex,
+		k2IngameTimJpStrings,
+		k2IngameShapeAnimData,
+		k2IngameTlkDemoStrings,
+
+		-1
 	};
 
-	static const FilenameTable kyra3StaticRes[] = {
-		{ k3MainMenuStrings, kStringList, "MAINMENU.TXT" },
-		{ k3MusicFiles, kStringList, "SCORE.TRA" },
-		{ k3ScoreTable, kRawData, "SCORE.MAP" },
-		{ k3SfxFiles, kStringList, "SFXFILES.TRA" },
-		{ k3SfxMap, kRawData, "SFXINDEX.MAP" },
-		{ k3ItemAnimData, k2ShpAnimDataV2, "INVANIM.SHP" },
-		{ k3ItemMagicTable, kRawData, "ITEMMAGIC.MAP" },
-		{ k3ItemStringMap, kRawData, "ITEMSTRINGS.MAP" },
-
-		{ 0, 0, 0 }
+	static const int kyra3StaticRes[] = {
+		k3MainMenuStrings,
+		k3MusicFiles,
+		k3ScoreTable,
+		k3SfxFiles,
+		k3SfxMap,
+		k3ItemAnimData,
+		k3ItemMagicTable,
+		k3ItemStringMap,
+
+		-1
 	};
 
 #ifdef ENABLE_LOL
-	static const FilenameTable kLolStaticRes[] = {
+	static const int kLolStaticRes[] = {
 		// Demo Sequence Player
-		{ k2SeqplayPakFiles, kStringList, "S_PAKFILES.TXT" },
-		{ k2SeqplayStrings, kLanguageList, "S_STRINGS." },
-		{ k2SeqplaySfxFiles, kStringList, "S_SFXFILES.TXT" },
-		{ k2SeqplaySeqData, k2SeqData, "S_DATA.SEQ" },
-		{ k2SeqplayIntroTracks, kStringList, "S_INTRO.TRA" },
+		k2SeqplayPakFiles,
+		k2SeqplayStrings,
+		k2SeqplaySfxFiles,
+		k2SeqplaySeqData,
+		k2SeqplayIntroTracks,
 
 		// Ingame
-		{ kLolIngamePakFiles, kStringList, "PAKFILES.TXT" },
-
-		{ kLolCharacterDefs, kLolCharData, "CHARACTER.DEF" },
-		{ kLolIngameSfxFiles, kStringList, "SFXFILES.TRA" },
-		{ kLolIngameSfxIndex, kRawData, "SFXINDEX.MAP" },
-		{ kLolMusicTrackMap, kRawData, "MUSIC.MAP" },
-		{ kLolIngameGMSfxIndex, kRawData, "SFX_GM.MAP" },
-		{ kLolIngameMT32SfxIndex, kRawData, "SFX_MT32.MAP" },
-		{ kLolIngamePcSpkSfxIndex, kRawData, "SFX_PCS.MAP" },
-		{ kLolSpellProperties, kLolSpellData, "SPELLS.DEF" },
-		{ kLolGameShapeMap, kRawData, "GAMESHP.MAP" },
-		{ kLolSceneItemOffs, kRawData, "ITEMOFFS.DEF" },
-		{ kLolCharInvIndex, kRawData, "CHARINV.MAP" },
-		{ kLolCharInvDefs, kRawData, "CHARINV.DEF" },
-		{ kLolCharDefsMan, kLolRawDataBe16, "CHMAN.DEF" },
-		{ kLolCharDefsWoman, kLolRawDataBe16, "CHWOMAN.DEF" },
-		{ kLolCharDefsKieran, kLolRawDataBe16, "CHKIERAN.DEF" },
-		//{ kLolCharDefsUnk, kLolRawDataBe16, "CHUNK.DEF" },
-		{ kLolCharDefsAkshel, kLolRawDataBe16, "CHAKSHEL.DEF" },
-		{ kLolExpRequirements, kLolRawDataBe32, "EXPERIENCE.DEF" },
-		{ kLolMonsterModifiers, kLolRawDataBe16, "MONSTMOD.DEF" },
-		{ kLolMonsterShiftOffsets, kRawData, "MONSTLVL.DEF" },
-		{ kLolMonsterDirFlags, kRawData, "MONSTDIR.DEF" },
-		{ kLolMonsterScaleY, kRawData, "MONSTZY.DEF" },
-		{ kLolMonsterScaleX, kRawData, "MONSTZX.DEF" },
-		{ kLolMonsterScaleWH, kLolRawDataBe16, "MONSTSCL.DEF" },
-		{ kLolFlyingObjectShp, kLolFlightShpData, "THRWNSHP.DEF" },
-		{ kLolInventoryDesc, kLolRawDataBe16, "INVDESC.DEF" },
-
-		{ kLolLevelShpList, kStringList, "SHPFILES.TXT" },
-		{ kLolLevelDatList, kStringList, "DATFILES.TXT" },
-		{ kLolCompassDefs, kLolCompassData, "COMPASS.DEF" },
-		{ kLolItemPrices, kLolRawDataBe16, "ITEMCOST.DEF" },
-		{ kLolStashSetup, kRawData, "MONEYSTS.DEF" },
-
-		{ kLolDscUnk1, kRawData, "DSCSHPU1.DEF" },
-		{ kLolDscShapeIndex, kRawData, "DSCSHPI1.DEF" },
-		{ kLolDscOvlMap, kRawData, "DSCSHPI2.DEF" },
-		{ kLolDscScaleWidthData, kLolRawDataBe16, "DSCSHPW.DEF" },
-		{ kLolDscScaleHeightData, kLolRawDataBe16, "DSCSHPH.DEF" },
-		{ kLolDscX, kLolRawDataBe16, "DSCSHPX.DEF" },
-		{ kLolDscY, kRawData, "DSCSHPY.DEF" },
-		{ kLolDscTileIndex, kRawData, "DSCSHPT.DEF" },
-		{ kLolDscUnk2, kRawData, "DSCSHPU2.DEF" },
-		{ kLolDscDoorShapeIndex, kRawData, "DSCDOOR.DEF" },
-		{ kLolDscDimData1, kRawData, "DSCDIM1.DEF" },
-		{ kLolDscDimData2, kRawData, "DSCDIM2.DEF" },
-		{ kLolDscBlockMap, kRawData, "DSCBLOCK1.DEF" },
-		{ kLolDscDimMap, kRawData, "DSCDIM.DEF" },
-		{ kLolDscDoorScale, kLolRawDataBe16, "DSCDOOR3.DEF" },
-		{ kLolDscDoor4, kLolRawDataBe16, "DSCDOOR4.DEF" },
-		{ kLolDscOvlIndex, kRawData, "DSCBLOCK2.DEF" },
-		{ kLolDscBlockIndex, kRawData, "DSCBLOCKX.DEF" },
-		{ kLolDscDoor1, kRawData, "DSCDOOR1.DEF" },
-		{ kLolDscDoorX, kLolRawDataBe16, "DSCDOORX.DEF" },
-		{ kLolDscDoorY, kLolRawDataBe16, "DSCDOORY.DEF" },
-
-		{ kLolScrollXTop, kRawData, "SCROLLXT.DEF" },
-		{ kLolScrollYTop, kRawData, "SCROLLYT.DEF" },
-		{ kLolScrollXBottom, kRawData, "SCROLLXB.DEF" },
-		{ kLolScrollYBottom, kRawData, "SCROLLYB.DEF" },
-
-		{ kLolButtonDefs, kLolButtonData, "BUTTONS.DEF" },
-		{ kLolButtonList1, kLolRawDataBe16, "BUTTON1.LST" },
-		{ kLolButtonList2, kLolRawDataBe16, "BUTTON2.LST" },
-		{ kLolButtonList3, kLolRawDataBe16, "BUTTON3.LST" },
-		{ kLolButtonList4, kLolRawDataBe16, "BUTTON4.LST" },
-		{ kLolButtonList5, kLolRawDataBe16, "BUTTON5.LST" },
-		{ kLolButtonList6, kLolRawDataBe16, "BUTTON6.LST" },
-		{ kLolButtonList7, kLolRawDataBe16, "BUTTON7.LST" },
-		{ kLolButtonList8, kLolRawDataBe16, "BUTTON84.LST" },
-
-		{ kLolLegendData, kRawData, "MAPLGND.DEF" },
-		{ kLolMapCursorOvl, kRawData, "MAPCURSOR.PAL" },
-		{ kLolMapStringId, kLolRawDataBe16, "MAPSTRID.LST" },
-		//{ kLolMapPal, kRawData, "MAP.PAL" },
-
-		{ kLolSpellbookAnim, kRawData, "MBOOKA.DEF" },
-		{ kLolSpellbookCoords, kRawData, "MBOOKC.DEF" },
-		{ kLolHealShapeFrames, kRawData, "MHEAL.SHP" },
-		{ kLolLightningDefs, kRawData, "MLGHTNG.DEF" },
-		{ kLolFireballCoords, kLolRawDataBe16, "MFIREBLL.DEF" },
-
-		{ kLolCredits, kRawData, "LOLCREDITS" },
-
-		{ kLolHistory, kRawData, "HISTORY.FLS" },
-
-		{ 0, 0, 0 }
+		kLolIngamePakFiles,
+
+		kLolCharacterDefs,
+		kLolIngameSfxFiles,
+		kLolIngameSfxIndex,
+		kLolMusicTrackMap,
+		kLolIngameGMSfxIndex,
+		kLolIngameMT32SfxIndex,
+		kLolIngamePcSpkSfxIndex,
+		kLolSpellProperties,
+		kLolGameShapeMap,
+		kLolSceneItemOffs,
+		kLolCharInvIndex,
+		kLolCharInvDefs,
+		kLolCharDefsMan,
+		kLolCharDefsWoman,
+		kLolCharDefsKieran,
+		kLolCharDefsAkshel,
+		kLolExpRequirements,
+		kLolMonsterModifiers,
+		kLolMonsterShiftOffsets,
+		kLolMonsterDirFlags,
+		kLolMonsterScaleY,
+		kLolMonsterScaleX,
+		kLolMonsterScaleWH,
+		kLolFlyingObjectShp,
+		kLolInventoryDesc,
+
+		kLolLevelShpList,
+		kLolLevelDatList,
+		kLolCompassDefs,
+		kLolItemPrices,
+		kLolStashSetup,
+
+		kLolDscUnk1,
+		kLolDscShapeIndex,
+		kLolDscOvlMap,
+		kLolDscScaleWidthData,
+		kLolDscScaleHeightData,
+		kLolDscX,
+		kLolDscY,
+		kLolDscTileIndex,
+		kLolDscUnk2,
+		kLolDscDoorShapeIndex,
+		kLolDscDimData1,
+		kLolDscDimData2,
+		kLolDscBlockMap,
+		kLolDscDimMap,
+		kLolDscDoorScale,
+		kLolDscDoor4,
+		kLolDscOvlIndex,
+		kLolDscBlockIndex,
+		kLolDscDoor1,
+		kLolDscDoorX,
+		kLolDscDoorY,
+
+		kLolScrollXTop,
+		kLolScrollYTop,
+		kLolScrollXBottom,
+		kLolScrollYBottom,
+
+		kLolButtonDefs,
+		kLolButtonList1,
+		kLolButtonList2,
+		kLolButtonList3,
+		kLolButtonList4,
+		kLolButtonList5,
+		kLolButtonList6,
+		kLolButtonList7,
+		kLolButtonList8,
+
+		kLolLegendData,
+		kLolMapCursorOvl,
+		kLolMapStringId,
+
+		kLolSpellbookAnim,
+		kLolSpellbookCoords,
+		kLolHealShapeFrames,
+		kLolLightningDefs,
+		kLolFireballCoords,
+
+		kLolCredits,
+
+		kLolHistory,
+
+		-1
 	};
 #endif // ENABLE_LOL
 
 	if (_vm->game() == GI_KYRA1) {
 		_builtIn = 0;
-		_filenameTable = kyra1StaticRes;
+		_dataTable = kyra1StaticRes;
 	} else if (_vm->game() == GI_KYRA2) {
 		_builtIn = 0;
-		_filenameTable = kyra2StaticRes;
+		_dataTable = kyra2StaticRes;
 	} else if (_vm->game() == GI_KYRA3) {
 		_builtIn = 0;
-		_filenameTable = kyra3StaticRes;
+		_dataTable = kyra3StaticRes;
 #ifdef ENABLE_LOL
 	} else if (_vm->game() == GI_LOL) {
 		_builtIn = 0;
-		_filenameTable = kLolStaticRes;
+		_dataTable = kLolStaticRes;
 #endif // ENABLE_LOL
 	} else {
 		error("StaticResource: Unknown game ID");
@@ -558,10 +540,7 @@ void StaticResource::deinit() {
 }
 
 const char * const *StaticResource::loadStrings(int id, int &strings) {
-	const char * const *temp = (const char * const *)getData(id, kStringList, strings);
-	if (temp)
-		return temp;
-	return (const char * const *)getData(id, kLanguageList, strings);
+	return (const char * const *)getData(id, kStringList, strings);
 }
 
 const uint8 *StaticResource::loadRawData(int id, int &size) {
@@ -624,10 +603,11 @@ const ButtonDef *StaticResource::loadButtonDefs(int id, int &entries) {
 
 bool StaticResource::prefetchId(int id) {
 	if (id == -1) {
-		for (int i = 0; _filenameTable[i].filename; ++i)
-			prefetchId(_filenameTable[i].id);
+		for (int i = 0; _dataTable[i] != -1; ++i)
+			prefetchId(_dataTable[i]);
 		return true;
 	}
+
 	const void *ptr = 0;
 	int type = -1, size = -1;
 
@@ -637,18 +617,52 @@ bool StaticResource::prefetchId(int id) {
 	if (checkForBuiltin(id, type, size))
 		return true;
 
-	const FilenameTable *filename = searchFile(id);
-	if (!filename)
+	const GameFlags &flags = _vm->gameFlags();
+	byte game = getGameID(flags);
+	byte platform = getPlatformID(flags);
+	byte special = getSpecialID(flags);
+	byte lang = getLanguageID(flags);
+
+	Common::ArchiveMemberList fileCandidates;
+
+	const Common::String filenamePattern = Common::String::printf("%01X%01X%01X??%03X", game, platform, special, id);
+	const Common::String langFilenamePattern = filenamePattern + Common::String::printf("%01X", lang);
+
+	// We assume the order of "fileCandidates" never changes across these calls. This means:
+	// The filenames matching "filenamePattern" will be added after the ones matching
+	// "langFilenamePattern".
+	_vm->resource()->listFiles(langFilenamePattern.c_str(), fileCandidates);
+	_vm->resource()->listFiles(filenamePattern.c_str(), fileCandidates);
+
+	if (fileCandidates.empty())
+		return false;
+
+	// First entry in the list should be the one we want
+	Common::ArchiveMemberPtr file = *fileCandidates.begin();
+	fileCandidates.clear();
+
+	unsigned int rType = (unsigned int)-1;
+	if (sscanf(file->getDisplayName().c_str(), "%*01X%*01X%*01X%02X%*03X", &rType) != 1) {
+		warning("Failed to parse filename from kyra.dat: \"%s\"", file->getDisplayName().c_str());
 		return false;
-	const FileType *filetype = getFiletype(filename->type);
+	}
+
+	const FileType *filetype = getFiletype(rType);
 	if (!filetype)
 		return false;
 
 	ResData data;
 	data.id = id;
-	data.type = filetype->type;
-	if (!(this->*(filetype->load))(filename->filename, data.data, data.size))
+	data.type = rType;
+	Common::SeekableReadStream *fileStream = file->createReadStream();
+	if (!fileStream)
+		return false;
+
+	if (!(this->*(filetype->load))(*fileStream, data.data, data.size)) {
+		delete fileStream;
 		return false;
+	}
+	delete fileStream;
 	_resList.push_back(data);
 
 	return true;
@@ -697,18 +711,6 @@ const void *StaticResource::checkForBuiltin(int id, int &type, int &size) {
 	return 0;
 }
 
-const StaticResource::FilenameTable *StaticResource::searchFile(int id) {
-	if (!_filenameTable)
-		return 0;
-
-	for (int i = 0; _filenameTable[i].filename; ++i) {
-		if (_filenameTable[i].id == id)
-			return &_filenameTable[i];
-	}
-
-	return 0;
-}
-
 const StaticResource::FileType *StaticResource::getFiletype(int type) {
 	if (!_fileLoader)
 		return 0;
@@ -750,125 +752,82 @@ const void *StaticResource::getData(int id, int requesttype, int &size) {
 	return 0;
 }
 
-bool StaticResource::loadLanguageTable(const char *filename, void *&ptr, int &size) {
-	static Common::String file;
-	for (int i = 0; languages[i].ext; ++i) {
-		if (languages[i].lang != _vm->gameFlags().lang)
-			continue;
-
-		file = filename;
-		file += languages[i].ext;
-		if (loadStringTable(file.c_str(), ptr, size))
-			return true;
-	}
-
-	return false;
-}
-
-bool StaticResource::loadStringTable(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-	if (!file)
-		return false;
-
-	uint32 count = file->readUint32BE();
+bool StaticResource::loadStringTable(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	uint32 count = stream.readUint32BE();
 	size = count;
-	char **output = new char*[count];
+	char **output = new char *[count];
 	assert(output);
 
 	for (uint32 i = 0; i < count; ++i) {
 		Common::String string;
 		char c = 0;
-		while ((c = (char)file->readByte()) != 0)
+		while ((c = (char)stream.readByte()) != 0)
 			string += c;
 
 		output[i] = new char[string.size()+1];
 		strcpy(output[i], string.c_str());
 	}
 
-	delete file;
 	ptr = output;
-
 	return true;
 }
 
-bool StaticResource::loadRawData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-	if (!file)
-		return false;
-
-	ptr = new uint8[file->size()];
-	file->read(ptr, file->size());
-	size = file->size();
-	delete file;
-
+bool StaticResource::loadRawData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	ptr = new uint8[stream.size()];
+	stream.read(ptr, stream.size());
+	size = stream.size();
 	return true;
 }
 
-bool StaticResource::loadShapeTable(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-	if (!file)
-		return false;
-
-	uint32 count = file->readUint32BE();
+bool StaticResource::loadShapeTable(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	uint32 count = stream.readUint32BE();
 	size = count;
 	Shape *loadTo = new Shape[count];
 	assert(loadTo);
 
 	for (uint32 i = 0; i < count; ++i) {
-		loadTo[i].imageIndex = file->readByte();
-		loadTo[i].x = file->readByte();
-		loadTo[i].y = file->readByte();
-		loadTo[i].w = file->readByte();
-		loadTo[i].h = file->readByte();
-		loadTo[i].xOffset = file->readSByte();
-		loadTo[i].yOffset = file->readSByte();
+		loadTo[i].imageIndex = stream.readByte();
+		loadTo[i].x = stream.readByte();
+		loadTo[i].y = stream.readByte();
+		loadTo[i].w = stream.readByte();
+		loadTo[i].h = stream.readByte();
+		loadTo[i].xOffset = stream.readSByte();
+		loadTo[i].yOffset = stream.readSByte();
 	}
 
-	delete file;
 	ptr = loadTo;
-
 	return true;
 }
 
-bool StaticResource::loadAmigaSfxTable(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-	if (!file)
-		return false;
-
-	size = file->readUint32BE();
+bool StaticResource::loadAmigaSfxTable(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.readUint32BE();
 	AmigaSfxTable *loadTo = new AmigaSfxTable[size];
 	assert(loadTo);
 
 	for (int i = 0; i < size; ++i) {
-		loadTo[i].note = file->readByte();
-		loadTo[i].patch = file->readByte();
-		loadTo[i].duration = file->readUint16BE();
-		loadTo[i].volume = file->readByte();
-		loadTo[i].pan = file->readByte();
+		loadTo[i].note = stream.readByte();
+		loadTo[i].patch = stream.readByte();
+		loadTo[i].duration = stream.readUint16BE();
+		loadTo[i].volume = stream.readByte();
+		loadTo[i].pan = stream.readByte();
 	}
 
-	delete file;
 	ptr = loadTo;
-
 	return true;
 }
 
-bool StaticResource::loadRoomTable(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-	if (!file)
-		return false;
-
-	uint32 count = file->readUint32BE();
+bool StaticResource::loadRoomTable(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	uint32 count = stream.readUint32BE();
 	size = count;
 	Room *loadTo = new Room[count];
 	assert(loadTo);
 
 	for (uint32 i = 0; i < count; ++i) {
-		loadTo[i].nameIndex = file->readByte();
-		loadTo[i].northExit = file->readUint16BE();
-		loadTo[i].eastExit = file->readUint16BE();
-		loadTo[i].southExit = file->readUint16BE();
-		loadTo[i].westExit = file->readUint16BE();
+		loadTo[i].nameIndex = stream.readByte();
+		loadTo[i].northExit = stream.readUint16BE();
+		loadTo[i].eastExit = stream.readUint16BE();
+		loadTo[i].southExit = stream.readUint16BE();
+		loadTo[i].westExit = stream.readUint16BE();
 		memset(&loadTo[i].itemsTable[0], 0xFF, sizeof(byte)*6);
 		memset(&loadTo[i].itemsTable[6], 0, sizeof(byte)*6);
 		memset(loadTo[i].itemsXPos, 0, sizeof(uint16)*12);
@@ -876,74 +835,67 @@ bool StaticResource::loadRoomTable(const char *filename, void *&ptr, int &size)
 		memset(loadTo[i].needInit, 0, sizeof(loadTo[i].needInit));
 	}
 
-	delete file;
 	ptr = loadTo;
-
 	return true;
 }
 
-bool StaticResource::loadHofSequenceData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	int numSeq = file->readUint16BE();
+bool StaticResource::loadHofSequenceData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	int numSeq = stream.readUint16BE();
 	uint32 offset = 2;
 	Sequence *tmp_s = new Sequence[numSeq];
 
 	size = sizeof(HofSeqData) + numSeq * (sizeof(Sequence) + 28);
 
 	for (int i = 0; i < numSeq; i++) {
-		file->seek(offset, SEEK_SET); offset += 2;
-		file->seek(file->readUint16BE(), SEEK_SET);
+		stream.seek(offset, SEEK_SET); offset += 2;
+		stream.seek(stream.readUint16BE(), SEEK_SET);
 
-		tmp_s[i].flags = file->readUint16BE();
+		tmp_s[i].flags = stream.readUint16BE();
 		tmp_s[i].wsaFile = new char[14];
-		file->read(const_cast<char*>(tmp_s[i].wsaFile), 14);
+		stream.read(const_cast<char*>(tmp_s[i].wsaFile), 14);
 		tmp_s[i].cpsFile = new char[14];
-		file->read(const_cast<char*>(tmp_s[i].cpsFile), 14);
-		tmp_s[i].startupCommand = file->readByte();
-		tmp_s[i].finalCommand = file->readByte();
-		tmp_s[i].stringIndex1 = file->readUint16BE();
-		tmp_s[i].stringIndex2 = file->readUint16BE();
-		tmp_s[i].startFrame = file->readUint16BE();
-		tmp_s[i].numFrames = file->readUint16BE();
-		tmp_s[i].frameDelay = file->readUint16BE();
-		tmp_s[i].xPos = file->readUint16BE();
-		tmp_s[i].yPos = file->readUint16BE();
-		tmp_s[i].duration = file->readUint16BE();
+		stream.read(const_cast<char*>(tmp_s[i].cpsFile), 14);
+		tmp_s[i].startupCommand = stream.readByte();
+		tmp_s[i].finalCommand = stream.readByte();
+		tmp_s[i].stringIndex1 = stream.readUint16BE();
+		tmp_s[i].stringIndex2 = stream.readUint16BE();
+		tmp_s[i].startFrame = stream.readUint16BE();
+		tmp_s[i].numFrames = stream.readUint16BE();
+		tmp_s[i].frameDelay = stream.readUint16BE();
+		tmp_s[i].xPos = stream.readUint16BE();
+		tmp_s[i].yPos = stream.readUint16BE();
+		tmp_s[i].duration = stream.readUint16BE();
 	}
 
-	file->seek(offset, SEEK_SET); offset += 2;
-	int numSeqN = file->readUint16BE();
+	stream.seek(offset, SEEK_SET); offset += 2;
+	int numSeqN = stream.readUint16BE();
 	NestedSequence *tmp_n = new NestedSequence[numSeqN];
 	size += (numSeqN * (sizeof(NestedSequence) + 14));
 
 	for (int i = 0; i < numSeqN; i++) {
-		file->seek(offset, SEEK_SET); offset += 2;
-		file->seek(file->readUint16BE(), SEEK_SET);
+		stream.seek(offset, SEEK_SET); offset += 2;
+		stream.seek(stream.readUint16BE(), SEEK_SET);
 
-		tmp_n[i].flags = file->readUint16BE();
+		tmp_n[i].flags = stream.readUint16BE();
 		tmp_n[i].wsaFile = new char[14];
-		file->read(const_cast<char*>(tmp_n[i].wsaFile), 14);
-		tmp_n[i].startframe = file->readUint16BE();
-		tmp_n[i].endFrame = file->readUint16BE();
-		tmp_n[i].frameDelay = file->readUint16BE();
-		tmp_n[i].x = file->readUint16BE();
-		tmp_n[i].y = file->readUint16BE();
-		uint16 ctrlOffs = file->readUint16BE();
-		tmp_n[i].startupCommand = file->readUint16BE();
-		tmp_n[i].finalCommand = file->readUint16BE();
+		stream.read(const_cast<char*>(tmp_n[i].wsaFile), 14);
+		tmp_n[i].startframe = stream.readUint16BE();
+		tmp_n[i].endFrame = stream.readUint16BE();
+		tmp_n[i].frameDelay = stream.readUint16BE();
+		tmp_n[i].x = stream.readUint16BE();
+		tmp_n[i].y = stream.readUint16BE();
+		uint16 ctrlOffs = stream.readUint16BE();
+		tmp_n[i].startupCommand = stream.readUint16BE();
+		tmp_n[i].finalCommand = stream.readUint16BE();
 
 		if (ctrlOffs) {
-			file->seek(ctrlOffs, SEEK_SET);
-			int num_c = file->readByte();
+			stream.seek(ctrlOffs, SEEK_SET);
+			int num_c = stream.readByte();
 			FrameControl *tmp_f = new FrameControl[num_c];
 
 			for (int ii = 0; ii < num_c; ii++) {
-				tmp_f[ii].index = file->readUint16BE();
-				tmp_f[ii].delay = file->readUint16BE();
+				tmp_f[ii].index = stream.readUint16BE();
+				tmp_f[ii].delay = stream.readUint16BE();
 			}
 
 			tmp_n[i].wsaControl = (const FrameControl *)tmp_f;
@@ -954,8 +906,6 @@ bool StaticResource::loadHofSequenceData(const char *filename, void *&ptr, int &
 		}
 	}
 
-	delete file;
-
 	HofSeqData *loadTo = new HofSeqData;
 	assert(loadTo);
 
@@ -965,252 +915,196 @@ bool StaticResource::loadHofSequenceData(const char *filename, void *&ptr, int &
 	loadTo->numSeqn = numSeqN;
 
 	ptr = loadTo;
-
 	return true;
 }
 
-bool StaticResource::loadShapeAnimData_v1(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->readByte();
+bool StaticResource::loadShapeAnimData_v1(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.readByte();
 	ItemAnimData_v1 *loadTo = new ItemAnimData_v1[size];
 	assert(loadTo);
 
 	for (int i = 0; i < size; i++) {
-		loadTo[i].itemIndex = file->readSint16BE();
-		loadTo[i].y = file->readUint16BE();
+		loadTo[i].itemIndex = stream.readSint16BE();
+		loadTo[i].y = stream.readUint16BE();
 		uint16 *tmp_f = new uint16[20];
 		for (int ii = 0; ii < 20; ii++)
-			tmp_f[ii] = file->readUint16BE();
+			tmp_f[ii] = stream.readUint16BE();
 		loadTo[i].frames = tmp_f;
 	}
 
-	delete file;
 	ptr = loadTo;
-
 	return true;
 }
 
-bool StaticResource::loadShapeAnimData_v2(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->readByte();
+bool StaticResource::loadShapeAnimData_v2(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.readByte();
 	ItemAnimData_v2 *loadTo = new ItemAnimData_v2[size];
 	assert(loadTo);
 
 	for (int i = 0; i < size; i++) {
-		loadTo[i].itemIndex = file->readSint16BE();
-		loadTo[i].numFrames = file->readByte();
+		loadTo[i].itemIndex = stream.readSint16BE();
+		loadTo[i].numFrames = stream.readByte();
 		FrameControl *tmp_f = new FrameControl[loadTo[i].numFrames];
 		for (int ii = 0; ii < loadTo[i].numFrames; ii++) {
-			tmp_f[ii].index = file->readUint16BE();
-			tmp_f[ii].delay = file->readUint16BE();
+			tmp_f[ii].index = stream.readUint16BE();
+			tmp_f[ii].delay = stream.readUint16BE();
 		}
 		loadTo[i].frames = tmp_f;
 	}
 
-	delete file;
 	ptr = loadTo;
 	return true;
 }
 
 #ifdef ENABLE_LOL
-bool StaticResource::loadCharData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() / 130;
+bool StaticResource::loadCharData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() / 130;
 	LoLCharacter *charData = new LoLCharacter[size];
 
 	for (int i = 0; i < size; i++) {
 		LoLCharacter *t = &charData[i];
 
-		t->flags = file->readUint16LE();
-		file->read(t->name, 11);
-		t->raceClassSex = file->readByte();
-		t->id = file->readSint16LE();
-		t->curFaceFrame = file->readByte();
-		t->defaultFaceFrame = file->readByte();
-		t->screamSfx = file->readByte();
-		file->readUint32LE();
+		t->flags = stream.readUint16LE();
+		stream.read(t->name, 11);
+		t->raceClassSex = stream.readByte();
+		t->id = stream.readSint16LE();
+		t->curFaceFrame = stream.readByte();
+		t->defaultFaceFrame = stream.readByte();
+		t->screamSfx = stream.readByte();
+		stream.readUint32LE();
 		for (int ii = 0; ii < 8; ii++)
-			t->itemsMight[ii] = file->readUint16LE();
+			t->itemsMight[ii] = stream.readUint16LE();
 		for (int ii = 0; ii < 8; ii++)
-			t->protectionAgainstItems[ii] = file->readUint16LE();
-		t->itemProtection = file->readUint16LE();
-		t->hitPointsCur = file->readSint16LE();
-		t->hitPointsMax = file->readUint16LE();
-		t->magicPointsCur = file->readSint16LE();
-		t->magicPointsMax = file->readUint16LE();
-		t->field_41 = file->readByte();
-		t->damageSuffered = file->readUint16LE();
-		t->weaponHit = file->readUint16LE();
-		t->totalMightModifier = file->readUint16LE();
-		t->totalProtectionModifier = file->readUint16LE();
-		t->might = file->readUint16LE();
-		t->protection = file->readUint16LE();
-		t->nextAnimUpdateCountdown = file->readSint16LE();
+			t->protectionAgainstItems[ii] = stream.readUint16LE();
+		t->itemProtection = stream.readUint16LE();
+		t->hitPointsCur = stream.readSint16LE();
+		t->hitPointsMax = stream.readUint16LE();
+		t->magicPointsCur = stream.readSint16LE();
+		t->magicPointsMax = stream.readUint16LE();
+		t->field_41 = stream.readByte();
+		t->damageSuffered = stream.readUint16LE();
+		t->weaponHit = stream.readUint16LE();
+		t->totalMightModifier = stream.readUint16LE();
+		t->totalProtectionModifier = stream.readUint16LE();
+		t->might = stream.readUint16LE();
+		t->protection = stream.readUint16LE();
+		t->nextAnimUpdateCountdown = stream.readSint16LE();
 		for (int ii = 0; ii < 11; ii++)
-			t->items[ii] = file->readUint16LE();
+			t->items[ii] = stream.readUint16LE();
 		for (int ii = 0; ii < 3; ii++)
-			t->skillLevels[ii] = file->readByte();
+			t->skillLevels[ii] = stream.readByte();
 		for (int ii = 0; ii < 3; ii++)
-			t->skillModifiers[ii] = file->readByte();
+			t->skillModifiers[ii] = stream.readByte();
 		for (int ii = 0; ii < 3; ii++)
-			t->experiencePts[ii] = file->readUint32LE();
+			t->experiencePts[ii] = stream.readUint32LE();
 		for (int ii = 0; ii < 5; ii++)
-			t->characterUpdateEvents[ii] = file->readByte();
+			t->characterUpdateEvents[ii] = stream.readByte();
 		for (int ii = 0; ii < 5; ii++)
-			t->characterUpdateDelay[ii] = file->readByte();
+			t->characterUpdateDelay[ii] = stream.readByte();
 	};
 
-	delete file;
 	ptr = charData;
 	return true;
 }
 
-bool StaticResource::loadSpellData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() / 28;
+bool StaticResource::loadSpellData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() / 28;
 	SpellProperty *spellData = new SpellProperty[size];
 
 	for (int i = 0; i < size; i++) {
 		SpellProperty *t = &spellData[i];
 
-		t->spellNameCode = file->readUint16LE();
+		t->spellNameCode = stream.readUint16LE();
 		for (int ii = 0; ii < 4; ii++)
-			t->mpRequired[ii] = file->readUint16LE();
-		t->field_a = file->readUint16LE();
-		t->field_c = file->readUint16LE();
+			t->mpRequired[ii] = stream.readUint16LE();
+		t->field_a = stream.readUint16LE();
+		t->field_c = stream.readUint16LE();
 		for (int ii = 0; ii < 4; ii++)
-			t->hpRequired[ii] = file->readUint16LE();
-		t->field_16 = file->readUint16LE();
-		t->field_18 = file->readUint16LE();
-		t->flags = file->readUint16LE();
+			t->hpRequired[ii] = stream.readUint16LE();
+		t->field_16 = stream.readUint16LE();
+		t->field_18 = stream.readUint16LE();
+		t->flags = stream.readUint16LE();
 	};
 
-	delete file;
 	ptr = spellData;
 	return true;
 }
 
-bool StaticResource::loadCompassData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() / 4;
+bool StaticResource::loadCompassData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() / 4;
 	CompassDef *defs = new CompassDef[size];
 
 	for (int i = 0; i < size; i++) {
 		CompassDef *t = &defs[i];
-		t->shapeIndex = file->readByte();
-		t->x = file->readByte();
-		t->y = file->readByte();
-		t->flags = file->readByte();
+		t->shapeIndex = stream.readByte();
+		t->x = stream.readByte();
+		t->y = stream.readByte();
+		t->flags = stream.readByte();
 	};
 
 
-	delete file;
 	ptr = defs;
 	return true;
 }
 
-bool StaticResource::loadFlyingObjectData(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() / 5;
+bool StaticResource::loadFlyingObjectData(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() / 5;
 	FlyingObjectShape *defs = new FlyingObjectShape[size];
 
 	for (int i = 0; i < size; i++) {
 		FlyingObjectShape *t = &defs[i];
-		t->shapeFront = file->readByte();
-		t->shapeBack = file->readByte();
-		t->shapeLeft = file->readByte();
-		t->drawFlags = file->readByte();
-		t->flipFlags = file->readByte();
+		t->shapeFront = stream.readByte();
+		t->shapeBack = stream.readByte();
+		t->shapeLeft = stream.readByte();
+		t->drawFlags = stream.readByte();
+		t->flipFlags = stream.readByte();
 	};
 
-	delete file;
 	ptr = defs;
 	return true;
 }
 
-bool StaticResource::loadRawDataBe16(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() >> 1;
+bool StaticResource::loadRawDataBe16(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() >> 1;
 
 	uint16 *r = new uint16[size];
 
 	for (int i = 0; i < size; i++)
-		r[i] = file->readUint16BE();
+		r[i] = stream.readUint16BE();
 
-	delete file;
 	ptr = r;
 	return true;
 }
 
-bool StaticResource::loadRawDataBe32(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() >> 2;
+bool StaticResource::loadRawDataBe32(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() >> 2;
 
 	uint32 *r = new uint32[size];
 
 	for (int i = 0; i < size; i++)
-		r[i] = file->readUint32BE();
+		r[i] = stream.readUint32BE();
 
-	delete file;
 	ptr = r;
 	return true;
 }
 
-bool StaticResource::loadButtonDefs(const char *filename, void *&ptr, int &size) {
-	Common::SeekableReadStream *file = getFile(filename);
-
-	if (!file)
-		return false;
-
-	size = file->size() / 18;
+bool StaticResource::loadButtonDefs(Common::SeekableReadStream &stream, void *&ptr, int &size) {
+	size = stream.size() / 18;
 
 	ButtonDef *r = new ButtonDef[size];
 
 	for (int i = 0; i < size; i++) {
-		r[i].buttonflags = file->readUint16BE();
-		r[i].keyCode = file->readUint16BE();
-		r[i].keyCode2 = file->readUint16BE();
-		r[i].x = file->readSint16BE();
-		r[i].y = file->readSint16BE();
-		r[i].w = file->readUint16BE();
-		r[i].h = file->readUint16BE();
-		r[i].index = file->readUint16BE();
-		r[i].screenDim = file->readUint16BE();
+		r[i].buttonflags = stream.readUint16BE();
+		r[i].keyCode = stream.readUint16BE();
+		r[i].keyCode2 = stream.readUint16BE();
+		r[i].x = stream.readSint16BE();
+		r[i].y = stream.readSint16BE();
+		r[i].w = stream.readUint16BE();
+		r[i].h = stream.readUint16BE();
+		r[i].index = stream.readUint16BE();
+		r[i].screenDim = stream.readUint16BE();
 	}
 
-	delete file;
 	ptr = r;
 	return true;
 }
diff --git a/tools/create_kyradat/create_kyradat.cpp b/tools/create_kyradat/create_kyradat.cpp
index edf62955c9..6160e1ca81 100644
--- a/tools/create_kyradat/create_kyradat.cpp
+++ b/tools/create_kyradat/create_kyradat.cpp
@@ -42,261 +42,257 @@
 #include <map>
 
 enum {
-	kKyraDatVersion = 65
+	kKyraDatVersion = 66
 };
 
 const ExtractFilename extractFilenames[] = {
 	// INTRO / OUTRO sequences
-	{ k1ForestSeq, kTypeRawData, "FOREST.SEQ" },
-	{ k1KallakWritingSeq, kTypeRawData, "KALLAK-WRITING.SEQ" },
-	{ k1KyrandiaLogoSeq, kTypeRawData, "KYRANDIA-LOGO.SEQ" },
-	{ k1KallakMalcolmSeq, kTypeRawData, "KALLAK-MALCOLM.SEQ" },
-	{ k1MalcolmTreeSeq, kTypeRawData, "MALCOLM-TREE.SEQ" },
-	{ k1WestwoodLogoSeq, kTypeRawData, "WESTWOOD-LOGO.SEQ" },
-	{ k1Demo1Seq, kTypeRawData, "DEMO1.SEQ" },
-	{ k1Demo2Seq, kTypeRawData, "DEMO2.SEQ" },
-	{ k1Demo3Seq, kTypeRawData, "DEMO3.SEQ" },
-	{ k1Demo4Seq, kTypeRawData, "DEMO4.SEQ" },
-	{ k1OutroReunionSeq, kTypeRawData, "REUNION.SEQ" },
+	{ k1ForestSeq, kTypeRawData, false },
+	{ k1KallakWritingSeq, kTypeRawData, false },
+	{ k1KyrandiaLogoSeq, kTypeRawData, false },
+	{ k1KallakMalcolmSeq, kTypeRawData, false },
+	{ k1MalcolmTreeSeq, kTypeRawData, false },
+	{ k1WestwoodLogoSeq, kTypeRawData, false },
+	{ k1Demo1Seq, kTypeRawData, false },
+	{ k1Demo2Seq, kTypeRawData, false },
+	{ k1Demo3Seq, kTypeRawData, false },
+	{ k1Demo4Seq, kTypeRawData, false },
+	{ k1OutroReunionSeq, kTypeRawData, false },
 
 	// INTRO / OUTRO strings
-	{ k1IntroCPSStrings, kTypeStringList, "INTRO-CPS.TXT" },
-	{ k1IntroCOLStrings, kTypeStringList, "INTRO-COL.TXT" },
-	{ k1IntroWSAStrings, kTypeStringList, "INTRO-WSA.TXT" },
-	{ k1IntroStrings, kTypeLanguageList, "INTRO-STRINGS" },
-	{ k1OutroHomeString, kTypeLanguageList, "HOME" },
+	{ k1IntroCPSStrings, kTypeStringList, false },
+	{ k1IntroCOLStrings, kTypeStringList, false },
+	{ k1IntroWSAStrings, kTypeStringList, false },
+	{ k1IntroStrings, kTypeStringList, true },
+	{ k1OutroHomeString, kTypeStringList, true },
 
 	// INGAME strings
-	{ k1ItemNames, kTypeLanguageList, "ITEMLIST" },
-	{ k1TakenStrings, kTypeLanguageList, "TAKEN" },
-	{ k1PlacedStrings, kTypeLanguageList, "PLACED" },
-	{ k1DroppedStrings, kTypeLanguageList, "DROPPED" },
-	{ k1NoDropStrings, kTypeLanguageList, "NODROP" },
-	{ k1PutDownString, kTypeLanguageList, "PUTDOWN" },
-	{ k1WaitAmuletString, kTypeLanguageList, "WAITAMUL" },
-	{ k1BlackJewelString, kTypeLanguageList, "BLACKJEWEL" },
-	{ k1PoisonGoneString, kTypeLanguageList, "POISONGONE" },
-	{ k1HealingTipString, kTypeLanguageList, "HEALINGTIP" },
-	{ k1ThePoisonStrings, kTypeLanguageList, "THEPOISON" },
-	{ k1FluteStrings, kTypeLanguageList, "FLUTE" },
-	{ k1WispJewelStrings, kTypeLanguageList, "WISPJEWEL" },
-	{ k1MagicJewelStrings, kTypeLanguageList, "MAGICJEWEL" },
-	{ k1FlaskFullString, kTypeLanguageList, "FLASKFULL" },
-	{ k1FullFlaskString, kTypeLanguageList, "FULLFLASK" },
-	{ k1VeryCleverString, kTypeLanguageList, "VERYCLEVER" },
-	{ k1NewGameString, kTypeLanguageList, "NEWGAME" },
+	{ k1ItemNames, kTypeStringList, true },
+	{ k1TakenStrings, kTypeStringList, true },
+	{ k1PlacedStrings, kTypeStringList, true },
+	{ k1DroppedStrings, kTypeStringList, true },
+	{ k1NoDropStrings, kTypeStringList, true },
+	{ k1PutDownString, kTypeStringList, true },
+	{ k1WaitAmuletString, kTypeStringList, true },
+	{ k1BlackJewelString, kTypeStringList, true },
+	{ k1PoisonGoneString, kTypeStringList, true },
+	{ k1HealingTipString, kTypeStringList, true },
+	{ k1ThePoisonStrings, kTypeStringList, true },
+	{ k1FluteStrings, kTypeStringList, true },
+	{ k1WispJewelStrings, kTypeStringList, true },
+	{ k1MagicJewelStrings, kTypeStringList, true },
+	{ k1FlaskFullString, kTypeStringList, true },
+	{ k1FullFlaskString, kTypeStringList, true },
+	{ k1VeryCleverString, kTypeStringList, true },
+	{ k1NewGameString, kTypeStringList, true },
 
 	// GUI strings table
-	{ k1GUIStrings, kTypeLanguageList, "GUISTRINGS" },
-	{ k1ConfigStrings, kTypeLanguageList, "CONFIGSTRINGS" },
+	{ k1GUIStrings, kTypeStringList, true },
+	{ k1ConfigStrings, kTypeStringList, true },
 
 	// ROOM table/filenames
-	{ k1RoomList, kTypeRoomList, "ROOM-TABLE.ROOM" },
-	{ k1RoomFilenames, kTypeStringList, "ROOM-FILENAMES.TXT" },
+	{ k1RoomList, kTypeRoomList, false },
+	{ k1RoomFilenames, kTypeStringList, false },
 
 	// SHAPE tables
-	{ k1DefaultShapes, kTypeShapeList, "SHAPES-DEFAULT.SHP" },
-	{ k1Healing1Shapes, kTypeShapeList, "HEALING.SHP" },
-	{ k1Healing2Shapes, kTypeShapeList, "HEALING2.SHP" },
-	{ k1PoisonDeathShapes, kTypeShapeList, "POISONDEATH.SHP" },
-	{ k1FluteShapes, kTypeShapeList, "FLUTE.SHP" },
-	{ k1Winter1Shapes, kTypeShapeList, "WINTER1.SHP" },
-	{ k1Winter2Shapes, kTypeShapeList, "WINTER2.SHP" },
-	{ k1Winter3Shapes, kTypeShapeList, "WINTER3.SHP" },
-	{ k1DrinkShapes, kTypeShapeList, "DRINK.SHP" },
-	{ k1WispShapes, kTypeShapeList, "WISP.SHP" },
-	{ k1MagicAnimShapes, kTypeShapeList, "MAGICANIM.SHP" },
-	{ k1BranStoneShapes, kTypeShapeList, "BRANSTONE.SHP" },
+	{ k1DefaultShapes, kTypeShapeList, false },
+	{ k1Healing1Shapes, kTypeShapeList, false },
+	{ k1Healing2Shapes, kTypeShapeList, false },
+	{ k1PoisonDeathShapes, kTypeShapeList, false },
+	{ k1FluteShapes, kTypeShapeList, false },
+	{ k1Winter1Shapes, kTypeShapeList, false },
+	{ k1Winter2Shapes, kTypeShapeList, false },
+	{ k1Winter3Shapes, kTypeShapeList, false },
+	{ k1DrinkShapes, kTypeShapeList, false },
+	{ k1WispShapes, kTypeShapeList, false },
+	{ k1MagicAnimShapes, kTypeShapeList, false },
+	{ k1BranStoneShapes, kTypeShapeList, false },
 
 	// IMAGE filename table
-	{ k1CharacterImageFilenames, kTypeStringList, "CHAR-IMAGE.TXT" },
+	{ k1CharacterImageFilenames, kTypeStringList, false },
 
 	// AUDIO filename table
-	{ k1AudioTracks, kTypeStringList, "TRACKS.TXT" },
-	{ k1AudioTracksIntro, kTypeStringList, "TRACKSINT.TXT" },
+	{ k1AudioTracks, kTypeStringList, false },
+	{ k1AudioTracksIntro, kTypeStringList, false },
 
 	// AMULET anim
-	{ k1AmuleteAnimSeq, kTypeRawData, "AMULETEANIM.SEQ" },
+	{ k1AmuleteAnimSeq, kTypeRawData, false },
 
 	// PALETTE table
-	{ k1SpecialPalette1, kTypeRawData, "PALTABLE1.PAL" },
-	{ k1SpecialPalette2, kTypeRawData, "PALTABLE2.PAL" },
-	{ k1SpecialPalette3, kTypeRawData, "PALTABLE3.PAL" },
-	{ k1SpecialPalette4, kTypeRawData, "PALTABLE4.PAL" },
-	{ k1SpecialPalette5, kTypeRawData, "PALTABLE5.PAL" },
-	{ k1SpecialPalette6, kTypeRawData, "PALTABLE6.PAL" },
-	{ k1SpecialPalette7, kTypeRawData, "PALTABLE7.PAL" },
-	{ k1SpecialPalette8, kTypeRawData, "PALTABLE8.PAL" },
-	{ k1SpecialPalette9, kTypeRawData, "PALTABLE9.PAL" },
-	{ k1SpecialPalette10, kTypeRawData, "PALTABLE10.PAL" },
-	{ k1SpecialPalette11, kTypeRawData, "PALTABLE11.PAL" },
-	{ k1SpecialPalette12, kTypeRawData, "PALTABLE12.PAL" },
-	{ k1SpecialPalette13, kTypeRawData, "PALTABLE13.PAL" },
-	{ k1SpecialPalette14, kTypeRawData, "PALTABLE14.PAL" },
-	{ k1SpecialPalette15, kTypeRawData, "PALTABLE15.PAL" },
-	{ k1SpecialPalette16, kTypeRawData, "PALTABLE16.PAL" },
-	{ k1SpecialPalette17, kTypeRawData, "PALTABLE17.PAL" },
-	{ k1SpecialPalette18, kTypeRawData, "PALTABLE18.PAL" },
-	{ k1SpecialPalette19, kTypeRawData, "PALTABLE19.PAL" },
-	{ k1SpecialPalette20, kTypeRawData, "PALTABLE20.PAL" },
-	{ k1SpecialPalette21, kTypeRawData, "PALTABLE21.PAL" },
-	{ k1SpecialPalette22, kTypeRawData, "PALTABLE22.PAL" },
-	{ k1SpecialPalette23, kTypeRawData, "PALTABLE23.PAL" },
-	{ k1SpecialPalette24, kTypeRawData, "PALTABLE24.PAL" },
-	{ k1SpecialPalette25, kTypeRawData, "PALTABLE25.PAL" },
-	{ k1SpecialPalette26, kTypeRawData, "PALTABLE26.PAL" },
-	{ k1SpecialPalette27, kTypeRawData, "PALTABLE27.PAL" },
-	{ k1SpecialPalette28, kTypeRawData, "PALTABLE28.PAL" },
-	{ k1SpecialPalette29, kTypeRawData, "PALTABLE29.PAL" },
-	{ k1SpecialPalette30, kTypeRawData, "PALTABLE30.PAL" },
-	{ k1SpecialPalette31, kTypeRawData, "PALTABLE31.PAL" },
-	{ k1SpecialPalette32, kTypeRawData, "PALTABLE32.PAL" },
-	{ k1SpecialPalette33, kTypeRawData, "PALTABLE33.PAL" },
+	{ k1SpecialPalette1, kTypeRawData, false },
+	{ k1SpecialPalette2, kTypeRawData, false },
+	{ k1SpecialPalette3, kTypeRawData, false },
+	{ k1SpecialPalette4, kTypeRawData, false },
+	{ k1SpecialPalette5, kTypeRawData, false },
+	{ k1SpecialPalette6, kTypeRawData, false },
+	{ k1SpecialPalette7, kTypeRawData, false },
+	{ k1SpecialPalette8, kTypeRawData, false },
+	{ k1SpecialPalette9, kTypeRawData, false },
+	{ k1SpecialPalette10, kTypeRawData, false },
+	{ k1SpecialPalette11, kTypeRawData, false },
+	{ k1SpecialPalette12, kTypeRawData, false },
+	{ k1SpecialPalette13, kTypeRawData, false },
+	{ k1SpecialPalette14, kTypeRawData, false },
+	{ k1SpecialPalette15, kTypeRawData, false },
+	{ k1SpecialPalette16, kTypeRawData, false },
+	{ k1SpecialPalette17, kTypeRawData, false },
+	{ k1SpecialPalette18, kTypeRawData, false },
+	{ k1SpecialPalette19, kTypeRawData, false },
+	{ k1SpecialPalette20, kTypeRawData, false },
+	{ k1SpecialPalette21, kTypeRawData, false },
+	{ k1SpecialPalette22, kTypeRawData, false },
+	{ k1SpecialPalette23, kTypeRawData, false },
+	{ k1SpecialPalette24, kTypeRawData, false },
+	{ k1SpecialPalette25, kTypeRawData, false },
+	{ k1SpecialPalette26, kTypeRawData, false },
+	{ k1SpecialPalette27, kTypeRawData, false },
+	{ k1SpecialPalette28, kTypeRawData, false },
+	{ k1SpecialPalette29, kTypeRawData, false },
+	{ k1SpecialPalette30, kTypeRawData, false },
+	{ k1SpecialPalette31, kTypeRawData, false },
+	{ k1SpecialPalette32, kTypeRawData, false },
+	{ k1SpecialPalette33, kTypeRawData, false },
 
 	// CREDITS (used in FM-TOWNS and AMIGA)
-	{ k1CreditsStrings, kTypeRawData, "CREDITS" },
+	{ k1CreditsStrings, kTypeRawData, false },
 
 	// FM-TOWNS specific
-	{ k1TOWNSSfxWDTable, kTypeTownsWDSfxTable, "SFXWDTABLE" },
-	{ k1TOWNSSfxBTTable, kTypeRawData, "SFXBTTABLE" },
-	{ k1TOWNSCDATable, kTypeRawData, "CDATABLE" },
+	{ k1TownsSFXwdTable, kTypeTownsWDSfxTable, false },
+	{ k1TownsSFXbtTable, kTypeRawData, false },
+	{ k1TownsCDATable, kTypeRawData, false },
 
 	// PC98 specific
-	{ k1PC98StoryStrings, kTypeLanguageList, "INTROSTORY" },
-	{ k1PC98IntroSfx, kTypeRawData, "INTROSFX" },
+	{ k1PC98StoryStrings, kTypeStringList, true },
+	{ k1PC98IntroSfx, kTypeRawData, false },
 
 	// AMIGA specific
-	{ k1AmigaIntroSFXTable, kTypeAmigaSfxTable, "SFXINTRO" },
-	{ k1AmigaGameSFXTable, kTypeAmigaSfxTable, "SFXGAME" },
+	{ k1AmigaIntroSFXTable, kTypeAmigaSfxTable, false },
+	{ k1AmigaGameSFXTable, kTypeAmigaSfxTable, false },
 
 	// HAND OF FATE
 
 	// Sequence Player
-	{ k2SeqplayPakFiles, kTypeStringList, "S_PAKFILES.TXT" },
-	{ k2SeqplayCredits, kTypeRawData, "S_CREDITS.TXT" },
-	{ k2SeqplayCreditsSpecial, kTypeStringList, "S_CREDITS2.TXT" },
-	{ k2SeqplayStrings, kTypeLanguageList, "S_STRINGS" },
-	{ k2SeqplaySfxFiles, k2TypeSoundList, "S_SFXFILES.TXT" },
-	{ k2SeqplayTlkFiles, k2TypeLangSoundList, "S_TLKFILES" },
-	{ k2SeqplaySeqData, k2TypeSeqData, "S_DATA.SEQ" },
-	{ k2SeqplayIntroTracks, kTypeStringList, "S_INTRO.TRA" },
-	{ k2SeqplayFinaleTracks, kTypeStringList, "S_FINALE.TRA" },
-	{ k2SeqplayIntroCDA, kTypeRawData, "S_INTRO.CDA" },
-	{ k2SeqplayFinaleCDA, kTypeRawData, "S_FINALE.CDA" },
-	{ k2SeqplayShapeAnimData, k2TypeShpDataV1, "S_DEMO.SHP" },
+	{ k2SeqplayPakFiles, kTypeStringList, false },
+	{ k2SeqplayCredits, kTypeRawData, false },
+	{ k2SeqplayCreditsSpecial, kTypeStringList, false },
+	{ k2SeqplayStrings, kTypeStringList, true },
+	{ k2SeqplaySfxFiles, k2TypeSoundList, false },
+	{ k2SeqplayTlkFiles, k2TypeLangSoundList, true },
+	{ k2SeqplaySeqData, k2TypeSeqData, false },
+	{ k2SeqplayIntroTracks, kTypeStringList, false },
+	{ k2SeqplayFinaleTracks, kTypeStringList, false },
+	{ k2SeqplayIntroCDA, kTypeRawData, false },
+	{ k2SeqplayFinaleCDA, kTypeRawData, false },
+	{ k2SeqplayShapeAnimData, k2TypeShpDataV1, false },
 
 	// Ingame
-	{ k2IngamePakFiles, kTypeStringList, "I_PAKFILES.TXT" },
-	{ k2IngameSfxFiles, k2TypeSize10StringList, "I_SFXFILES.TRA" },
-	{ k2IngameSfxFilesTns, k2TypeSoundList, "I_SFXFILES.TRA" },
-	{ k2IngameSfxIndex, kTypeRawData, "I_SFXINDEX.MAP" },
-	{ k2IngameTracks, kTypeStringList, "I_TRACKS.TRA" },
-	{ k2IngameCDA, kTypeRawData, "I_TRACKS.CDA" },
-	{ k2IngameTalkObjIndex, kTypeRawData, "I_TALKOBJECTS.MAP" },
-	{ k2IngameTimJpStrings, kTypeStringList, "I_TIMJPSTR.TXT" },
-	{ k2IngameItemAnimData, k2TypeShpDataV2, "I_INVANIM.SHP" },
-	{ k2IngameTlkDemoStrings, kTypeLanguageList, "I_TLKDEMO.TXT" },
+	{ k2IngamePakFiles, kTypeStringList, false },
+	{ k2IngameSfxFiles, k2TypeSize10StringList, false },
+	{ k2IngameSfxIndex, kTypeRawData, false },
+	{ k2IngameTracks, kTypeStringList, false },
+	{ k2IngameCDA, kTypeRawData, false },
+	{ k2IngameTalkObjIndex, kTypeRawData, false },
+	{ k2IngameTimJpStrings, kTypeStringList, false },
+	{ k2IngameShapeAnimData, k2TypeShpDataV2, false },
+	{ k2IngameTlkDemoStrings, kTypeStringList, true },
 
 
 	// MALCOLM'S REVENGE
-	{ k3MainMenuStrings, kTypeStringList, "MAINMENU.TXT" },
-	{ k3MusicFiles, k2TypeSoundList, "SCORE.TRA" },
-	{ k3ScoreTable, kTypeRawData, "SCORE.MAP" },
-	{ k3SfxFiles, k2TypeSfxList, "SFXFILES.TRA" },
-	{ k3SfxMap, k3TypeRaw16to8, "SFXINDEX.MAP" },
-	{ k3ItemAnimData, k3TypeShpData, "INVANIM.SHP" },
-	{ k3ItemMagicTable, k3TypeRaw16to8, "ITEMMAGIC.MAP" },
-	{ k3ItemStringMap, kTypeRawData, "ITEMSTRINGS.MAP" },
+	{ k3MainMenuStrings, kTypeStringList, false },
+	{ k3MusicFiles, k2TypeSoundList, false },
+	{ k3ScoreTable, kTypeRawData, false },
+	{ k3SfxFiles, k2TypeSfxList, false },
+	{ k3SfxMap, k3TypeRaw16to8, false },
+	{ k3ItemAnimData, k3TypeShpData, false },
+	{ k3ItemMagicTable, k3TypeRaw16to8, false },
+	{ k3ItemStringMap, kTypeRawData, false },
 
 	// LANDS OF LORE
 
-	// Demo Sequence Player
-	{ kLolSeqplayIntroTracks, k2TypeSoundList, "S_INTRO.TRA" },
-
 	// Ingame
-	{ kLolIngamePakFiles, kTypeStringList, "PAKFILES.TXT" },
-
-	{ kLolCharacterDefs, kTypeRawData, "CHARACTER.DEF" },
-	{ kLolIngameSfxFiles, k2TypeSfxList, "SFXFILES.TRA" },
-	{ kLolIngameSfxIndex, kTypeRawData, "SFXINDEX.MAP" },
-	{ kLolMusicTrackMap, kTypeRawData, "MUSIC.MAP" },
-	{ kLolGMSfxIndex, kTypeRawData, "SFX_GM.MAP" },
-	{ kLolMT32SfxIndex, kTypeRawData, "SFX_MT32.MAP" },
-	{ kLolPcSpkSfxIndex, kTypeRawData, "SFX_PCS.MAP" },
-	{ kLolSpellProperties, kTypeRawData, "SPELLS.DEF" },
-	{ kLolGameShapeMap, kTypeRawData, "GAMESHP.MAP" },
-	{ kLolSceneItemOffs, kTypeRawData, "ITEMOFFS.DEF" },
-	{ kLolCharInvIndex, k3TypeRaw16to8, "CHARINV.MAP" },
-	{ kLolCharInvDefs, kTypeRawData, "CHARINV.DEF" },
-	{ kLolCharDefsMan, kLolTypeRaw16, "CHMAN.DEF" },
-	{ kLolCharDefsWoman, kLolTypeRaw16, "CHWOMAN.DEF" },
-	{ kLolCharDefsKieran, kLolTypeRaw16, "CHKIERAN.DEF" },
-	{ kLolCharDefsAkshel, kLolTypeRaw16, "CHAKSHEL.DEF" },
-	{ kLolExpRequirements, kLolTypeRaw32, "EXPERIENCE.DEF" },
-	{ kLolMonsterModifiers, kLolTypeRaw16, "MONSTMOD.DEF" },
-	{ kLolMonsterLevelOffsets, kTypeRawData, "MONSTLVL.DEF" },
-	{ kLolMonsterDirFlags, kTypeRawData, "MONSTDIR.DEF" },
-	{ kLolMonsterScaleY, kTypeRawData, "MONSTZY.DEF" },
-	{ kLolMonsterScaleX, kTypeRawData, "MONSTZX.DEF" },
-	{ kLolMonsterScaleWH, kLolTypeRaw16, "MONSTSCL.DEF" },
-	{ kLolFlyingItemShp, k3TypeRaw16to8, "THRWNSHP.DEF" },
-	{ kLolInventoryDesc, kLolTypeRaw16, "INVDESC.DEF" },
-	{ kLolLevelShpList, kTypeStringList, "SHPFILES.TXT" },
-	{ kLolLevelDatList, kTypeStringList, "DATFILES.TXT" },
-	{ kLolCompassDefs, k3TypeRaw16to8, "COMPASS.DEF" },
-	{ kLolItemPrices, kLolTypeRaw16, "ITEMCOST.DEF" },
-	{ kLolStashSetup, kTypeRawData, "MONEYSTS.DEF" },
-
-	{ kLolDscUnk1, kTypeRawData, "DSCSHPU1.DEF" },
-	{ kLolDscShapeIndex1, kTypeRawData, "DSCSHPI1.DEF" },
-	{ kLolDscShapeIndex2, kTypeRawData, "DSCSHPI2.DEF" },
-	{ kLolDscScaleWidthData, kLolTypeRaw16, "DSCSHPW.DEF" },
-	{ kLolDscScaleHeightData, kLolTypeRaw16, "DSCSHPH.DEF" },
-	{ kLolDscX, kLolTypeRaw16, "DSCSHPX.DEF" },
-	{ kLolDscY, kTypeRawData, "DSCSHPY.DEF" },
-	{ kLolDscTileIndex, kTypeRawData, "DSCSHPT.DEF" },
-	{ kLolDscUnk2, kTypeRawData, "DSCSHPU2.DEF" },
-	{ kLolDscDoorShapeIndex, kTypeRawData, "DSCDOOR.DEF" },
-	{ kLolDscDimData1, kTypeRawData, "DSCDIM1.DEF" },
-	{ kLolDscDimData2, kTypeRawData, "DSCDIM2.DEF" },
-	{ kLolDscBlockMap, kTypeRawData, "DSCBLOCK1.DEF" },
-	{ kLolDscDimMap, kTypeRawData, "DSCDIM.DEF" },
-	{ kLolDscDoorScale, kLolTypeRaw16, "DSCDOOR3.DEF" },
-	{ kLolDscShapeOvlIndex, k3TypeRaw16to8, "DSCBLOCK2.DEF" },
-	{ kLolDscBlockIndex, kTypeRawData, "DSCBLOCKX.DEF" },
-	{ kLolDscDoor4, kLolTypeRaw16, "DSCDOOR4.DEF" },
-	{ kLolDscDoor1, kTypeRawData, "DSCDOOR1.DEF" },
-	{ kLolDscDoorX, kLolTypeRaw16, "DSCDOORX.DEF" },
-	{ kLolDscDoorY, kLolTypeRaw16, "DSCDOORY.DEF" },
-
-	{ kLolScrollXTop, k3TypeRaw16to8, "SCROLLXT.DEF" },
-	{ kLolScrollYTop, k3TypeRaw16to8, "SCROLLYT.DEF" },
-	{ kLolScrollXBottom, k3TypeRaw16to8, "SCROLLXB.DEF" },
-	{ kLolScrollYBottom, k3TypeRaw16to8, "SCROLLYB.DEF" },
-
-	{ kLolButtonDefs, kLolTypeButtonDef, "BUTTONS.DEF" },
-	{ kLolButtonList1, kLolTypeRaw16, "BUTTON1.LST" },
-	{ kLolButtonList2, kLolTypeRaw16, "BUTTON2.LST" },
-	{ kLolButtonList3, kLolTypeRaw16, "BUTTON3.LST" },
-	{ kLolButtonList4, kLolTypeRaw16, "BUTTON4.LST" },
-	{ kLolButtonList5, kLolTypeRaw16, "BUTTON5.LST" },
-	{ kLolButtonList6, kLolTypeRaw16, "BUTTON6.LST" },
-	{ kLolButtonList7, kLolTypeRaw16, "BUTTON7.LST" },
-	{ kLolButtonList8, kLolTypeRaw16, "BUTTON84.LST" },
-
-	{ kLolLegendData, kTypeRawData, "MAPLGND.DEF" },
-	{ kLolMapCursorOvl, kTypeRawData, "MAPCURSOR.PAL" },
-	{ kLolMapStringId, kLolTypeRaw16, "MAPSTRID.LST" },
-
-	{ kLolSpellbookAnim, k3TypeRaw16to8, "MBOOKA.DEF" },
-	{ kLolSpellbookCoords, k3TypeRaw16to8, "MBOOKC.DEF" },
-	{ kLolHealShapeFrames, kTypeRawData, "MHEAL.SHP" },
-	{ kLolLightningDefs, kTypeRawData, "MLGHTNG.DEF" },
-	{ kLolFireballCoords, kLolTypeRaw16, "MFIREBLL.DEF" },
-
-	{ kLolCredits, kTypeRawData, "LOLCREDITS" },
-
-	{ kLolHistory, kTypeRawData, "HISTORY.FLS" },
+	{ kLolIngamePakFiles, kTypeStringList, false },
+
+	{ kLolCharacterDefs, kLolTypeCharData, false },
+	{ kLolIngameSfxFiles, k2TypeSfxList, false },
+	{ kLolIngameSfxIndex, kTypeRawData, false },
+	{ kLolMusicTrackMap, kTypeRawData, false },
+	{ kLolIngameGMSfxIndex, kTypeRawData, false },
+	{ kLolIngameMT32SfxIndex, kTypeRawData, false },
+	{ kLolIngamePcSpkSfxIndex, kTypeRawData, false },
+	{ kLolSpellProperties, kLolTypeSpellData, false },
+	{ kLolGameShapeMap, kTypeRawData, false },
+	{ kLolSceneItemOffs, kTypeRawData, false },
+	{ kLolCharInvIndex, k3TypeRaw16to8, false },
+	{ kLolCharInvDefs, kTypeRawData, false },
+	{ kLolCharDefsMan, kLolTypeRaw16, false },
+	{ kLolCharDefsWoman, kLolTypeRaw16, false },
+	{ kLolCharDefsKieran, kLolTypeRaw16, false },
+	{ kLolCharDefsAkshel, kLolTypeRaw16, false },
+	{ kLolExpRequirements, kLolTypeRaw32, false },
+	{ kLolMonsterModifiers, kLolTypeRaw16, false },
+	{ kLolMonsterShiftOffsets, kTypeRawData, false },
+	{ kLolMonsterDirFlags, kTypeRawData, false },
+	{ kLolMonsterScaleY, kTypeRawData, false },
+	{ kLolMonsterScaleX, kTypeRawData, false },
+	{ kLolMonsterScaleWH, kLolTypeRaw16, false },
+	{ kLolFlyingObjectShp, kLolTypeFlightShpData, false },
+	{ kLolInventoryDesc, kLolTypeRaw16, false },
+	{ kLolLevelShpList, kTypeStringList, false },
+	{ kLolLevelDatList, kTypeStringList, false },
+	{ kLolCompassDefs, kLolTypeCompassData, false },
+	{ kLolItemPrices, kLolTypeRaw16, false },
+	{ kLolStashSetup, kTypeRawData, false },
+
+	{ kLolDscUnk1, kTypeRawData, false },
+	{ kLolDscShapeIndex, kTypeRawData, false },
+	{ kLolDscOvlMap, kTypeRawData, false },
+	{ kLolDscScaleWidthData, kLolTypeRaw16, false },
+	{ kLolDscScaleHeightData, kLolTypeRaw16, false },
+	{ kLolDscX, kLolTypeRaw16, false },
+	{ kLolDscY, kTypeRawData, false },
+	{ kLolDscTileIndex, kTypeRawData, false },
+	{ kLolDscUnk2, kTypeRawData, false },
+	{ kLolDscDoorShapeIndex, kTypeRawData, false },
+	{ kLolDscDimData1, kTypeRawData, false },
+	{ kLolDscDimData2, kTypeRawData, false },
+	{ kLolDscBlockMap, kTypeRawData, false },
+	{ kLolDscDimMap, kTypeRawData, false },
+	{ kLolDscDoorScale, kLolTypeRaw16, false },
+	{ kLolDscOvlIndex, k3TypeRaw16to8, false },
+	{ kLolDscBlockIndex, kTypeRawData, false },
+	{ kLolDscDoor4, kLolTypeRaw16, false },
+	{ kLolDscDoor1, kTypeRawData, false },
+	{ kLolDscDoorX, kLolTypeRaw16, false },
+	{ kLolDscDoorY, kLolTypeRaw16, false },
+
+	{ kLolScrollXTop, k3TypeRaw16to8, false },
+	{ kLolScrollYTop, k3TypeRaw16to8, false },
+	{ kLolScrollXBottom, k3TypeRaw16to8, false },
+	{ kLolScrollYBottom, k3TypeRaw16to8, false },
+
+	{ kLolButtonDefs, kLolTypeButtonDef, false },
+	{ kLolButtonList1, kLolTypeRaw16, false },
+	{ kLolButtonList2, kLolTypeRaw16, false },
+	{ kLolButtonList3, kLolTypeRaw16, false },
+	{ kLolButtonList4, kLolTypeRaw16, false },
+	{ kLolButtonList5, kLolTypeRaw16, false },
+	{ kLolButtonList6, kLolTypeRaw16, false },
+	{ kLolButtonList7, kLolTypeRaw16, false },
+	{ kLolButtonList8, kLolTypeRaw16, false },
+
+	{ kLolLegendData, kTypeRawData, false },
+	{ kLolMapCursorOvl, kTypeRawData, false },
+	{ kLolMapStringId, kLolTypeRaw16, false },
+
+	{ kLolSpellbookAnim, k3TypeRaw16to8, false },
+	{ kLolSpellbookCoords, k3TypeRaw16to8, false },
+	{ kLolHealShapeFrames, kTypeRawData, false },
+	{ kLolLightningDefs, kTypeRawData, false },
+	{ kLolFireballCoords, kLolTypeRaw16, false },
+
+	{ kLolCredits, kTypeRawData, false },
+
+	{ kLolHistory, kTypeRawData, false },
 
 	{ -1, 0, 0 }
 };
@@ -309,59 +305,16 @@ const ExtractFilename *getFilenameDesc(const int id) {
 	return 0;
 }
 
-// filename processing
-
-bool getFilename(char *dstFilename, const ExtractInformation *info, const int id) {
-	const ExtractFilename *i = getFilenameDesc(id);
-
-	if (!i)
+bool isLangSpecific(const int id) {
+	const ExtractFilename *desc = getFilenameDesc(id);
+	if (!desc)
 		return false;
-
-	const ExtractType *type = findExtractType(i->type);
-	type->createFilename(dstFilename, info, i->filename);
-	return true;
+	return desc->langSpecific;
 }
 
 // misc tables
 
-const SpecialExtension specialTable[] = {
-	{ kTalkieVersion, "CD" },
-	{ kDemoVersion, "DEM" },
-	{ kTalkieDemoVersion, "CD.DEM" },
-
-	{ -1, 0 }
-};
-
-const Language languageTable[] = {
-	{ EN_ANY, "ENG" },
-	{ DE_DEU, "GER" },
-	{ FR_FRA, "FRE" },
-	{ IT_ITA, "ITA" },
-	{ ES_ESP, "SPA" },
-	{ JA_JPN, "JPN" },
-	{ -1, 0 }
-};
-
-const PlatformExtension platformTable[] = {
-	{ kPlatformAmiga, "AMG" },
-	{ kPlatformFMTowns, "TNS" },
-	{ kPlatformPC98, "98" },
-
-	{ -1, 0 }
-};
-
-// index generation
-
-struct IndexTable {
-	int type;
-	int value;
-
-	bool operator==(int t) const {
-		return (type == t);
-	}
-};
-
-const IndexTable iGameTable[] = {
+const TypeTable gameTable[] = {
 	{ kKyra1, 0 },
 	{ kKyra2, 1 },
 	{ kKyra3, 2 },
@@ -370,10 +323,10 @@ const IndexTable iGameTable[] = {
 };
 
 byte getGameID(int game) {
-	return std::find(iGameTable, iGameTable + ARRAYSIZE(iGameTable) - 1, game)->value;
+	return std::find(gameTable, gameTable + ARRAYSIZE(gameTable), game)->value;
 }
 
-/*const IndexTable iLanguageTable[] = {
+const TypeTable languageTable[] = {
 	{ EN_ANY, 0 },
 	{ FR_FRA, 1 },
 	{ DE_DEU, 2 },
@@ -384,10 +337,10 @@ byte getGameID(int game) {
 };
 
 byte getLanguageID(int lang) {
-	return std::find(iLanguageTable, iLanguageTable + ARRAYSIZE(iLanguageTable) - 1, lang)->value;
-}*/
+	return std::find(languageTable, languageTable + ARRAYSIZE(languageTable), lang)->value;
+}
 
-const IndexTable iPlatformTable[] = {
+const TypeTable platformTable[] = {
 	{ kPlatformPC, 0 },
 	{ kPlatformAmiga, 1 },
 	{ kPlatformFMTowns, 2 },
@@ -397,10 +350,10 @@ const IndexTable iPlatformTable[] = {
 };
 
 byte getPlatformID(int platform) {
-	return std::find(iPlatformTable, iPlatformTable + ARRAYSIZE(iPlatformTable) - 1, platform)->value;
+	return std::find(platformTable, platformTable + ARRAYSIZE(platformTable), platform)->value;
 }
 
-const IndexTable iSpecialTable[] = {
+const TypeTable specialTable[] = {
 	{ kNoSpecial, 0 },
 	{ kTalkieVersion, 1 },
 	{ kDemoVersion, 2 },
@@ -409,9 +362,27 @@ const IndexTable iSpecialTable[] = {
 };
 
 byte getSpecialID(int special) {
-	return std::find(iSpecialTable, iSpecialTable + ARRAYSIZE(iSpecialTable) - 1, special)->value;
+	return std::find(specialTable, specialTable + ARRAYSIZE(specialTable), special)->value;
 }
 
+// filename processing
+
+bool getFilename(char *dstFilename, const ExtractInformation *info, const int id) {
+	const ExtractFilename *i = getFilenameDesc(id);
+
+	if (!i)
+		return false;
+
+	// GAME, PLATFORM, SPECIAL, TYPE, ID[, LANG]
+	if (i->langSpecific)
+		sprintf(dstFilename, "%01X%01X%01X%02X%03X%01X", getGameID(info->game), getPlatformID(info->platform), getSpecialID(info->special), getTypeID(i->type), id, getLanguageID(info->lang));
+	else
+		sprintf(dstFilename, "%01X%01X%01X%02X%03X", getGameID(info->game), getPlatformID(info->platform), getSpecialID(info->special), getTypeID(i->type), id);
+	return true;
+}
+
+// index generation
+
 typedef uint16 GameDef;
 
 GameDef createGameDef(const ExtractInformation *eI) {
@@ -910,12 +881,12 @@ const char *getIdString(const int id) {
 		return "k1GUIStrings";
 	case k1ConfigStrings:
 		return "k1ConfigStrings";
-	case k1TOWNSSfxWDTable:
-		return "k1TOWNSSfxWDTable";
-	case k1TOWNSSfxBTTable:
-		return "k1TOWNSSfxBTTable";
-	case k1TOWNSCDATable:
-		return "k1TOWNSCDATable";
+	case k1TownsSFXwdTable:
+		return "k1TownsSFXwdTable";
+	case k1TownsSFXbtTable:
+		return "k1TownsSFXbtTable";
+	case k1TownsCDATable:
+		return "k1TownsCDATable";
 	case k1PC98StoryStrings:
 		return "k1PC98StoryStrings";
 	case k1PC98IntroSfx:
@@ -954,8 +925,6 @@ const char *getIdString(const int id) {
 		return "k2IngamePakFiles";
 	case k2IngameSfxFiles:
 		return "k2IngameSfxFiles";
-	case k2IngameSfxFilesTns:
-		return "k2IngameSfxFilesTns";
 	case k2IngameSfxIndex:
 		return "k2IngameSfxIndex";
 	case k2IngameTracks:
@@ -966,8 +935,8 @@ const char *getIdString(const int id) {
 		return "k2IngameTalkObjIndex";
 	case k2IngameTimJpStrings:
 		return "k2IngameTimJpStrings";
-	case k2IngameItemAnimData:
-		return "k2IngameItemAnimData";
+	case k2IngameShapeAnimData:
+		return "k2IngameShapeAnimData";
 	case k2IngameTlkDemoStrings:
 		return "k2IngameTlkDemoStrings";
 	case k3MainMenuStrings:
@@ -986,8 +955,6 @@ const char *getIdString(const int id) {
 		return "k3ItemMagicTable";
 	case k3ItemStringMap:
 		return "k3ItemStringMap";
-	case kLolSeqplayIntroTracks:
-		return "kLolSeqplayIntroTracks";
 	case kLolIngamePakFiles:
 		return "kLolIngamePakFiles";
 	case kLolCharacterDefs:
@@ -998,12 +965,12 @@ const char *getIdString(const int id) {
 		return "kLolIngameSfxIndex";
 	case kLolMusicTrackMap:
 		return "kLolMusicTrackMap";
-	case kLolGMSfxIndex:
-		return "kLolGMSfxIndex";
-	case kLolMT32SfxIndex:
-		return "kLolMT32SfxIndex";
-	case kLolPcSpkSfxIndex:
-		return "kLolPcSpkSfxIndex";
+	case kLolIngameGMSfxIndex:
+		return "kLolIngameGMSfxIndex";
+	case kLolIngameMT32SfxIndex:
+		return "kLolIngameMT32SfxIndex";
+	case kLolIngamePcSpkSfxIndex:
+		return "kLolIngamePcSpkSfxIndex";
 	case kLolSpellProperties:
 		return "kLolSpellProperties";
 	case kLolGameShapeMap:
@@ -1026,8 +993,8 @@ const char *getIdString(const int id) {
 		return "kLolExpRequirements";
 	case kLolMonsterModifiers:
 		return "kLolMonsterModifiers";
-	case kLolMonsterLevelOffsets:
-		return "kLolMonsterLevelOffsets";
+	case kLolMonsterShiftOffsets:
+		return "kLolMonsterShiftOffsets";
 	case kLolMonsterDirFlags:
 		return "kLolMonsterDirFlags";
 	case kLolMonsterScaleY:
@@ -1036,8 +1003,8 @@ const char *getIdString(const int id) {
 		return "kLolMonsterScaleX";
 	case kLolMonsterScaleWH:
 		return "kLolMonsterScaleWH";
-	case kLolFlyingItemShp:
-		return "kLolFlyingItemShp";
+	case kLolFlyingObjectShp:
+		return "kLolFlyingObjectShp";
 	case kLolInventoryDesc:
 		return "kLolInventoryDesc";
 	case kLolLevelShpList:
@@ -1052,10 +1019,10 @@ const char *getIdString(const int id) {
 		return "kLolStashSetup";
 	case kLolDscUnk1:
 		return "kLolDscUnk1";
-	case kLolDscShapeIndex1:
-		return "kLolDscShapeIndex1";
-	case kLolDscShapeIndex2:
-		return "kLolDscShapeIndex2";
+	case kLolDscShapeIndex:
+		return "kLolDscShapeIndex";
+	case kLolDscOvlMap:
+		return "kLolDscOvlMap";
 	case kLolDscScaleWidthData:
 		return "kLolDscScaleWidthData";
 	case kLolDscScaleHeightData:
@@ -1078,8 +1045,8 @@ const char *getIdString(const int id) {
 		return "kLolDscBlockMap";
 	case kLolDscDimMap:
 		return "kLolDscDimMap";
-	case kLolDscShapeOvlIndex:
-		return "kLolDscShapeOvlIndex";
+	case kLolDscOvlIndex:
+		return "kLolDscOvlIndex";
 	case kLolDscBlockIndex:
 		return "kLolDscBlockIndex";
 	case kLolDscDoor1:
@@ -1183,25 +1150,25 @@ bool process(PAKFile &out, const Game *g, const byte *data, const uint32 size) {
 		const ExtractFilename *fDesc = getFilenameDesc(id);
 
 		if (!fDesc) {
-			fprintf(stderr, "ERROR: couldn't find file description for id %d\n", id);
+			fprintf(stderr, "ERROR: couldn't find file description for id %d/%s\n", id, getIdString(id));
 			return false;
 		}
 
-		if (isLangSpecific(fDesc->type))
+		if (fDesc->langSpecific)
 			extractInfo.lang = i->second.desc.lang;
 		else
 			extractInfo.lang = UNK_LANG;
 
 		filename[0] = 0;
 		if (!getFilename(filename, &extractInfo, id)) {
-			fprintf(stderr, "ERROR: couldn't get filename for id %d\n", id);
+			fprintf(stderr, "ERROR: couldn't get filename for id %d/%s\n", id, getIdString(id));
 			return false;
 		}
 
 		const ExtractType *tDesc = findExtractType(fDesc->type);
 
 		if (!tDesc) {
-			fprintf(stderr, "ERROR: couldn't find type description for id %d\n", id);
+			fprintf(stderr, "ERROR: couldn't find type description for id %d/%s (%d)\n", id, getIdString(id), fDesc->type);
 			return false;
 		}
 
@@ -1210,7 +1177,7 @@ bool process(PAKFile &out, const Game *g, const byte *data, const uint32 size) {
 			continue;
 
 		if (!tDesc->extract(out, &extractInfo, data + i->second.offset, i->second.desc.hint.size, filename, id)) {
-			fprintf(stderr, "ERROR: couldn't extract id %d\n", id);
+			fprintf(stderr, "ERROR: couldn't extract id %d/%s\n", id, getIdString(id));
 			return false;
 		}
 	}
@@ -1368,11 +1335,7 @@ bool getExtractionData(const Game *g, Search &search, ExtractMap &map) {
 			continue;
 		}
 
-		const ExtractFilename *fDesc = getFilenameDesc(*entry);
-		if (!fDesc)
-			continue;
-
-		if (isLangSpecific(fDesc->type)) {
+		if (isLangSpecific(*entry)) {
 			for (int i = 0; i < 3; ++i) {
 				if (g->lang[i] == -1)
 					continue;
diff --git a/tools/create_kyradat/create_kyradat.h b/tools/create_kyradat/create_kyradat.h
index 2689fdddbf..93e03d40b6 100644
--- a/tools/create_kyradat/create_kyradat.h
+++ b/tools/create_kyradat/create_kyradat.h
@@ -25,20 +25,7 @@
 
 #include "util.h"
 
-struct Language {
-	int lang;
-	const char *ext;
-};
-
-extern const Language languageTable[];
-
-struct PlatformExtension {
-	int platform;
-	const char *ext;
-};
-
-extern const PlatformExtension platformTable[];
-
+// This list has to match orderwise (and thus value wise) the static data list of "engines/kyra/resource.h"!
 enum kExtractID {
 	k1ForestSeq = 0,
 	k1KallakWritingSeq,
@@ -68,9 +55,6 @@ enum kExtractID {
 
 	k1CharacterImageFilenames,
 
-	k1AudioTracks,
-	k1AudioTracksIntro,
-
 	k1ItemNames,
 	k1TakenStrings,
 	k1PlacedStrings,
@@ -144,23 +128,28 @@ enum kExtractID {
 	k1GUIStrings,
 	k1ConfigStrings,
 
-	k1TOWNSSfxWDTable,
-	k1TOWNSSfxBTTable,
-	k1TOWNSCDATable,
+	k1AudioTracks,
+	k1AudioTracksIntro,
+
+	k1CreditsStrings,
+
+	k1TownsSFXwdTable,
+	k1TownsSFXbtTable,
+	k1TownsCDATable,
+
 	k1PC98StoryStrings,
 	k1PC98IntroSfx,
-	k1CreditsStrings,
 
 	k1AmigaIntroSFXTable,
 	k1AmigaGameSFXTable,
 
 	k2SeqplayPakFiles,
+	k2SeqplayCredits,
+	k2SeqplayCreditsSpecial,
 	k2SeqplayStrings,
 	k2SeqplaySfxFiles,
 	k2SeqplayTlkFiles,
 	k2SeqplaySeqData,
-	k2SeqplayCredits,
-	k2SeqplayCreditsSpecial,
 	k2SeqplayIntroTracks,
 	k2SeqplayFinaleTracks,
 	k2SeqplayIntroCDA,
@@ -169,13 +158,12 @@ enum kExtractID {
 
 	k2IngamePakFiles,
 	k2IngameSfxFiles,
-	k2IngameSfxFilesTns,
 	k2IngameSfxIndex,
 	k2IngameTracks,
 	k2IngameCDA,
 	k2IngameTalkObjIndex,
 	k2IngameTimJpStrings,
-	k2IngameItemAnimData,
+	k2IngameShapeAnimData,
 	k2IngameTlkDemoStrings,
 
 	k3MainMenuStrings,
@@ -187,17 +175,14 @@ enum kExtractID {
 	k3ItemMagicTable,
 	k3ItemStringMap,
 
-	kLolSeqplayIntroTracks,
-
 	kLolIngamePakFiles,
-
 	kLolCharacterDefs,
 	kLolIngameSfxFiles,
 	kLolIngameSfxIndex,
 	kLolMusicTrackMap,
-	kLolGMSfxIndex,
-	kLolMT32SfxIndex,
-	kLolPcSpkSfxIndex,
+	kLolIngameGMSfxIndex,
+	kLolIngameMT32SfxIndex,
+	kLolIngamePcSpkSfxIndex,
 	kLolSpellProperties,
 	kLolGameShapeMap,
 	kLolSceneItemOffs,
@@ -209,12 +194,12 @@ enum kExtractID {
 	kLolCharDefsAkshel,
 	kLolExpRequirements,
 	kLolMonsterModifiers,
-	kLolMonsterLevelOffsets,
+	kLolMonsterShiftOffsets,
 	kLolMonsterDirFlags,
 	kLolMonsterScaleY,
 	kLolMonsterScaleX,
 	kLolMonsterScaleWH,
-	kLolFlyingItemShp,
+	kLolFlyingObjectShp,
 	kLolInventoryDesc,
 
 	kLolLevelShpList,
@@ -224,8 +209,8 @@ enum kExtractID {
 	kLolStashSetup,
 
 	kLolDscUnk1,
-	kLolDscShapeIndex1,
-	kLolDscShapeIndex2,
+	kLolDscShapeIndex,
+	kLolDscOvlMap,
 	kLolDscScaleWidthData,
 	kLolDscScaleHeightData,
 	kLolDscX,
@@ -237,13 +222,13 @@ enum kExtractID {
 	kLolDscDimData2,
 	kLolDscBlockMap,
 	kLolDscDimMap,
-	kLolDscShapeOvlIndex,
-	kLolDscBlockIndex,
 	kLolDscDoor1,
 	kLolDscDoorScale,
 	kLolDscDoor4,
 	kLolDscDoorX,
 	kLolDscDoorY,
+	kLolDscOvlIndex,
+	kLolDscBlockIndex,
 
 	kLolScrollXTop,
 	kLolScrollYTop,
@@ -280,7 +265,7 @@ enum kExtractID {
 struct ExtractFilename {
 	int id;
 	int type;
-	const char *filename;
+	bool langSpecific;
 };
 
 enum kSpecial {
@@ -290,18 +275,11 @@ enum kSpecial {
 	kTalkieDemoVersion
 };
 
-struct SpecialExtension {
-	int special;
-	const char *ext;
-};
-
-extern const SpecialExtension specialTable[];
-
 enum kGame {
 	kKyra1 = 0,
-	kKyra2 = 1,
-	kKyra3 = 2,
-	kLol = 4
+	kKyra2,
+	kKyra3,
+	kLol
 };
 
 struct Game {
@@ -319,4 +297,13 @@ extern const Game * const gameDescs[];
 
 const int *getNeedList(const Game *g);
 
+struct TypeTable {
+	int type;
+	int value;
+
+	bool operator==(int t) const {
+		return (type == t);
+	}
+};
+
 #endif
diff --git a/tools/create_kyradat/extract.cpp b/tools/create_kyradat/extract.cpp
index 6755541418..2f3c7f9bca 100644
--- a/tools/create_kyradat/extract.cpp
+++ b/tools/create_kyradat/extract.cpp
@@ -23,12 +23,9 @@
 
 #include "extract.h"
 
-namespace {
-
-// Filename creation
+#include <algorithm>
 
-void createFilename(char *dstFilename, const ExtractInformation *info, const char *filename);
-void createLangFilename(char *dstFilename, const ExtractInformation *info, const char *filename);
+namespace {
 
 // Extraction function prototypes 
 
@@ -55,82 +52,62 @@ bool extractLolButtonDefs(PAKFile &out, const ExtractInformation *info, const by
 // Extraction type table
 
 const ExtractType extractTypeTable[] = {
-	{ kTypeLanguageList, extractStrings, createLangFilename },
-	{ kTypeStringList, extractStrings, createFilename },
-	{ kTypeRoomList, extractRooms, createFilename },
-	{ kTypeShapeList, extractShapes, createFilename },
-	{ kTypeRawData, extractRaw, createFilename },
-	{ kTypeAmigaSfxTable, extractAmigaSfx, createFilename },
-	{ kTypeTownsWDSfxTable, extractWdSfx, createFilename },
-
-	{ k2TypeSeqData, extractHofSeqData, createFilename },
-	{ k2TypeShpDataV1, extractHofShapeAnimDataV1, createFilename },
-	{ k2TypeShpDataV2, extractHofShapeAnimDataV2, createFilename },
-	{ k2TypeSoundList, extractStringsWoSuffix, createFilename },
-	{ k2TypeLangSoundList, extractStringsWoSuffix, createLangFilename },
-	{ k2TypeSize10StringList, extractStrings10, createFilename },
-	{ k2TypeSfxList, extractPaddedStrings, createFilename },
-	{ k3TypeRaw16to8, extractRaw16to8, createFilename },
-	{ k3TypeShpData, extractMrShapeAnimData, createFilename },
-
-	{ kLolTypeRaw16, extractRaw16, createFilename },
-	{ kLolTypeRaw32, extractRaw32, createFilename },
-	{ kLolTypeButtonDef, extractLolButtonDefs, createFilename },
-
-	{ -1, 0, 0}
+	{ kTypeStringList, extractStrings },
+	{ kTypeRoomList, extractRooms },
+	{ kTypeShapeList, extractShapes },
+	{ kTypeRawData, extractRaw },
+	{ kTypeAmigaSfxTable, extractAmigaSfx },
+	{ kTypeTownsWDSfxTable, extractWdSfx },
+
+	{ k2TypeSeqData, extractHofSeqData },
+	{ k2TypeShpDataV1, extractHofShapeAnimDataV1 },
+	{ k2TypeShpDataV2, extractHofShapeAnimDataV2 },
+	{ k2TypeSoundList, extractStringsWoSuffix },
+	{ k2TypeLangSoundList, extractStringsWoSuffix },
+	{ k2TypeSize10StringList, extractStrings10 },
+	{ k2TypeSfxList, extractPaddedStrings },
+	{ k3TypeRaw16to8, extractRaw16to8 },
+	{ k3TypeShpData, extractMrShapeAnimData },
+
+	{ kLolTypeCharData, extractRaw },
+	{ kLolTypeSpellData, extractRaw },
+	{ kLolTypeCompassData, extractRaw16to8 },
+	{ kLolTypeFlightShpData, extractRaw16to8 },
+	{ kLolTypeRaw16, extractRaw16 },
+	{ kLolTypeRaw32, extractRaw32 },
+	{ kLolTypeButtonDef, extractLolButtonDefs },
+
+	{ -1, 0 }
 };
 
-void createFilename(char *dstFilename, const ExtractInformation *info, const char *filename) {
-	strcpy(dstFilename, filename);
-
-	static const char *gidExtensions[] = { "", ".K2", ".K3", 0, ".LOL" };
-	strcat(dstFilename, gidExtensions[info->game]);
-
-	for (const SpecialExtension *specialE = specialTable; specialE->special != -1; ++specialE) {
-		if (specialE->special == info->special) {
-			strcat(dstFilename, ".");
-			strcat(dstFilename, specialE->ext);
-			break;
-		}
-	}
-
-	for (const PlatformExtension *platformE = platformTable; platformE->platform != -1; ++platformE) {
-		if (platformE->platform == info->platform) {
-			strcat(dstFilename, ".");
-			strcat(dstFilename, platformE->ext);
-		}
-	}
-}
-
-void createLangFilename(char *dstFilename, const ExtractInformation *info, const char *filename) {
-	strcpy(dstFilename, filename);
-
-	for (const Language *langE = languageTable; langE->lang != -1; ++langE) {
-		if (langE->lang == info->lang) {
-			strcat(dstFilename, ".");
-			strcat(dstFilename, langE->ext);
-			break;
-		}
-	}
-
-	static const char *gidExtensions[] = { "", ".K2", ".K3", 0, ".LOL" };
-	strcat(dstFilename, gidExtensions[info->game]);
-
-	for (const SpecialExtension *specialE = specialTable; specialE->special != -1; ++specialE) {
-		if (specialE->special == info->special) {
-			strcat(dstFilename, ".");
-			strcat(dstFilename, specialE->ext);
-			break;
-		}
-	}
-
-	for (const PlatformExtension *platformE = platformTable; platformE->platform != -1; ++platformE) {
-		if (platformE->platform == info->platform) {
-			strcat(dstFilename, ".");
-			strcat(dstFilename, platformE->ext);
-		}
-	}
-}
+// TODO: Clean up the mess of data types we have... it seems some special types
+// we have (even in the main KYRA code, is just raw data access, but used specially
+// to have a nice wrapper from inside StaticResource...).
+const TypeTable typeTable[] = {
+	{ kTypeStringList, 0 },
+	{ kTypeRawData, 1 },
+	{ kTypeRoomList, 2 },
+	{ kTypeShapeList, 3 },
+	{ kTypeAmigaSfxTable, 4 },
+	{ kTypeTownsWDSfxTable, 1 },
+	{ k2TypeSeqData, 5 },
+	{ k2TypeShpDataV1, 6 },
+	{ k2TypeShpDataV2, 7 },
+	{ k2TypeSoundList, 0 },
+	{ k2TypeLangSoundList, 0 },
+	{ k2TypeSize10StringList, 0 },
+	{ k2TypeSfxList, 0 },
+	{ k3TypeRaw16to8, 1 },
+	{ k3TypeShpData, 7 },
+	{ kLolTypeRaw16, 15 },
+	{ kLolTypeRaw32, 16 },
+	{ kLolTypeButtonDef, 14 },
+	{ kLolTypeCharData, 10 },
+	{ kLolTypeSpellData, 11 },
+	{ kLolTypeCompassData, 12 },
+	{ kLolTypeFlightShpData, 13 },
+	{ -1, 0 }
+};
 
 } // end of anonymous namespace
 
@@ -144,15 +121,9 @@ const ExtractType *findExtractType(const int type) {
 	return 0;
 }
 
-// TODO: Get rid of this....
-bool isLangSpecific(const int type) {
-	const ExtractType *ext = findExtractType(type);
-	if (!ext)
-		return false;
-
-	return (ext->createFilename == createLangFilename);
+byte getTypeID(int type) {
+	return std::find(typeTable, typeTable + ARRAYSIZE(typeTable), type)->value;
 }
-
 // Extractor implementation
 
 namespace {
@@ -179,6 +150,10 @@ bool extractStrings(PAKFile &out, const ExtractInformation *info, const byte *da
 	} else if (info->platform == kPlatformPC) {
 		if (id == k2IngamePakFiles)
 			fmtPatch = 4;
+
+		// HACK
+		if (id == k2SeqplayIntroTracks && info->game == kLol)
+			return extractStringsWoSuffix(out, info, data, size, filename, id);
 	}
 
 	uint32 entries = 0;
@@ -332,6 +307,10 @@ bool extractStrings(PAKFile &out, const ExtractInformation *info, const byte *da
 }
 
 bool extractStrings10(PAKFile &out, const ExtractInformation *info, const byte *data, const uint32 size, const char *filename, int id) {
+	// HACK...
+	if (info->platform == kPlatformFMTowns && id == k2IngameSfxFiles)
+		return extractStringsWoSuffix(out, info, data, size, filename, id);
+
 	const int strSize = 10;
 	uint32 entries = (size + (strSize - 1)) / strSize;
 
diff --git a/tools/create_kyradat/extract.h b/tools/create_kyradat/extract.h
index e6ff444c13..190edce5ac 100644
--- a/tools/create_kyradat/extract.h
+++ b/tools/create_kyradat/extract.h
@@ -28,8 +28,7 @@
 #include "util.h"
 
 enum kExtractType {
-	kTypeLanguageList = 0,
-	kTypeStringList,
+	kTypeStringList = 0,
 	kTypeRoomList,
 	kTypeShapeList,
 	kTypeRawData,
@@ -49,7 +48,11 @@ enum kExtractType {
 
 	kLolTypeRaw16,
 	kLolTypeRaw32,
-	kLolTypeButtonDef
+	kLolTypeButtonDef,
+	kLolTypeCharData,
+	kLolTypeSpellData,
+	kLolTypeCompassData,
+	kLolTypeFlightShpData
 };
 
 struct ExtractInformation {
@@ -62,11 +65,10 @@ struct ExtractInformation {
 struct ExtractType {
 	int type;
 	bool (*extract)(PAKFile &out, const ExtractInformation *info, const byte *data, const uint32 size, const char *filename, int id);
-	void (*createFilename)(char *dstFilename, const ExtractInformation *info, const char *filename);
 };
 
 const ExtractType *findExtractType(const int type);
-bool isLangSpecific(const int type);
+byte getTypeID(int type);
 
 #endif
 
diff --git a/tools/create_kyradat/games.cpp b/tools/create_kyradat/games.cpp
index e8a40ca02f..44de387409 100644
--- a/tools/create_kyradat/games.cpp
+++ b/tools/create_kyradat/games.cpp
@@ -405,9 +405,9 @@ const int kyra1TownsNeed[] = {
 	k1NewGameString,
 	k1ConfigStrings,
 
-	k1TOWNSSfxWDTable,
-	k1TOWNSSfxBTTable,
-	k1TOWNSCDATable,
+	k1TownsSFXwdTable,
+	k1TownsSFXbtTable,
+	k1TownsCDATable,
 	k1AudioTracks,
 	k1CreditsStrings,
 	-1
@@ -571,7 +571,7 @@ const int kyra2CDNeed[] = {
 	k2IngameSfxIndex,
 	k2IngameTracks,
 	k2IngameTalkObjIndex,
-	k2IngameItemAnimData,
+	k2IngameShapeAnimData,
 	-1
 };
 
@@ -589,7 +589,7 @@ const int kyra2CDDemoNeed[] = {
 	k2IngameSfxIndex,
 	k2IngameTracks,
 	k2IngameTalkObjIndex,
-	k2IngameItemAnimData,
+	k2IngameShapeAnimData,
 	k2IngameTlkDemoStrings,
 	-1
 };
@@ -606,7 +606,7 @@ const int kyra2FloppyNeed[] = {
 	k2IngameSfxIndex,
 	k2IngameTracks,
 	k2IngameTalkObjIndex,
-	k2IngameItemAnimData,
+	k2IngameShapeAnimData,
 	-1
 };
 
@@ -618,12 +618,12 @@ const int kyra2TownsNeed[] = {
 	k2SeqplayIntroCDA,
 	k2SeqplayFinaleCDA,
 	k2IngamePakFiles,
-	k2IngameSfxFilesTns,
+	k2IngameSfxFiles,
 	k2IngameSfxIndex,
 	k2IngameCDA,
 	k2IngameTalkObjIndex,
 	k2IngameTimJpStrings,
-	k2IngameItemAnimData,
+	k2IngameShapeAnimData,
 	-1
 };
 
@@ -655,9 +655,9 @@ const int lolFloppyNeed[] = {
 	kLolIngameSfxFiles,
 	kLolIngameSfxIndex,
 	kLolMusicTrackMap,
-	kLolGMSfxIndex,
-	kLolMT32SfxIndex,
-	kLolPcSpkSfxIndex,
+	kLolIngameGMSfxIndex,
+	kLolIngameMT32SfxIndex,
+	kLolIngamePcSpkSfxIndex,
 	kLolSpellProperties,
 	kLolGameShapeMap,
 	kLolSceneItemOffs,
@@ -669,12 +669,12 @@ const int lolFloppyNeed[] = {
 	kLolCharDefsAkshel,
 	kLolExpRequirements,
 	kLolMonsterModifiers,
-	kLolMonsterLevelOffsets,
+	kLolMonsterShiftOffsets,
 	kLolMonsterDirFlags,
 	kLolMonsterScaleY,
 	kLolMonsterScaleX,
 	kLolMonsterScaleWH,
-	kLolFlyingItemShp,
+	kLolFlyingObjectShp,
 	kLolInventoryDesc,
 
 	kLolLevelShpList,
@@ -682,8 +682,8 @@ const int lolFloppyNeed[] = {
 	kLolCompassDefs,
 	kLolStashSetup,
 	kLolDscUnk1,
-	kLolDscShapeIndex1,
-	kLolDscShapeIndex2,
+	kLolDscShapeIndex,
+	kLolDscOvlMap,
 	kLolDscScaleWidthData,
 	kLolDscScaleHeightData,
 	kLolDscX,
@@ -695,7 +695,7 @@ const int lolFloppyNeed[] = {
 	kLolDscDimData2,
 	kLolDscBlockMap,
 	kLolDscDimMap,
-	kLolDscShapeOvlIndex,
+	kLolDscOvlIndex,
 	kLolDscBlockIndex,
 	kLolDscDoor1,
 	kLolDscDoorScale,
@@ -749,12 +749,12 @@ const int lolPC98Need[] = {
 	kLolCharDefsAkshel,
 	kLolExpRequirements,
 	kLolMonsterModifiers,
-	kLolMonsterLevelOffsets,
+	kLolMonsterShiftOffsets,
 	kLolMonsterDirFlags,
 	kLolMonsterScaleY,
 	kLolMonsterScaleX,
 	kLolMonsterScaleWH,
-	kLolFlyingItemShp,
+	kLolFlyingObjectShp,
 	kLolInventoryDesc,
 
 	kLolLevelShpList,
@@ -762,8 +762,8 @@ const int lolPC98Need[] = {
 	kLolCompassDefs,
 	kLolStashSetup,
 	kLolDscUnk1,
-	kLolDscShapeIndex1,
-	kLolDscShapeIndex2,
+	kLolDscShapeIndex,
+	kLolDscOvlMap,
 	kLolDscScaleWidthData,
 	kLolDscScaleHeightData,
 	kLolDscX,
@@ -775,7 +775,7 @@ const int lolPC98Need[] = {
 	kLolDscDimData2,
 	kLolDscBlockMap,
 	kLolDscDimMap,
-	kLolDscShapeOvlIndex,
+	kLolDscOvlIndex,
 	kLolDscBlockIndex,
 	kLolDscDoor1,
 	kLolDscDoorScale,
@@ -819,9 +819,9 @@ const int lolCDNeed[] = {
 	kLolIngameSfxFiles,
 	kLolIngameSfxIndex,
 	kLolMusicTrackMap,
-	kLolGMSfxIndex,
-	kLolMT32SfxIndex,
-	kLolPcSpkSfxIndex,
+	kLolIngameGMSfxIndex,
+	kLolIngameMT32SfxIndex,
+	kLolIngamePcSpkSfxIndex,
 	kLolSpellProperties,
 	kLolGameShapeMap,
 	kLolSceneItemOffs,
@@ -833,12 +833,12 @@ const int lolCDNeed[] = {
 	kLolCharDefsAkshel,
 	kLolExpRequirements,
 	kLolMonsterModifiers,
-	kLolMonsterLevelOffsets,
+	kLolMonsterShiftOffsets,
 	kLolMonsterDirFlags,
 	kLolMonsterScaleY,
 	kLolMonsterScaleX,
 	kLolMonsterScaleWH,
-	kLolFlyingItemShp,
+	kLolFlyingObjectShp,
 	kLolInventoryDesc,
 
 	kLolLevelShpList,
@@ -847,8 +847,8 @@ const int lolCDNeed[] = {
 	kLolItemPrices,
 	kLolStashSetup,
 	kLolDscUnk1,
-	kLolDscShapeIndex1,
-	kLolDscShapeIndex2,
+	kLolDscShapeIndex,
+	kLolDscOvlMap,
 	kLolDscScaleWidthData,
 	kLolDscScaleHeightData,
 	kLolDscX,
@@ -860,7 +860,7 @@ const int lolCDNeed[] = {
 	kLolDscDimData2,
 	kLolDscBlockMap,
 	kLolDscDimMap,
-	kLolDscShapeOvlIndex,
+	kLolDscOvlIndex,
 	kLolDscBlockIndex,
 	kLolDscDoor1,
 	kLolDscDoorScale,
@@ -901,7 +901,7 @@ const int lolDemoNeed[] = {
 	k2SeqplayStrings,
 	k2SeqplaySeqData,
 	k2SeqplaySfxFiles,
-	kLolSeqplayIntroTracks,
+	k2SeqplayIntroTracks,
 	-1
 };
 
diff --git a/tools/create_kyradat/tables.cpp b/tools/create_kyradat/tables.cpp
index 53f1cc9494..1c7f574af9 100644
--- a/tools/create_kyradat/tables.cpp
+++ b/tools/create_kyradat/tables.cpp
@@ -965,19 +965,19 @@ const ExtractEntrySearchData k1ConfigStringsProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData k1TOWNSSfxWDTableProvider[] = {
+const ExtractEntrySearchData k1TownsSFXwdTableProvider[] = {
 	{ UNK_LANG, kPlatformFMTowns, { 0x00012608, 0x006717A1, { { 0x34, 0xDD, 0x2D, 0xA5, 0x14, 0x05, 0xEE, 0x2F, 0x93, 0x7C, 0x78, 0x4D, 0xCA, 0x13, 0xED, 0x93 } } } },
 
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData k1TOWNSSfxBTTableProvider[] = {
+const ExtractEntrySearchData k1TownsSFXbtTableProvider[] = {
 	{ UNK_LANG, kPlatformFMTowns, { 0x00000100, 0x00007FFE, { { 0xEF, 0x3D, 0x9F, 0x31, 0xE7, 0x19, 0x1E, 0x4F, 0xF3, 0x66, 0x42, 0xC8, 0x0D, 0x89, 0x96, 0x20 } } } },
 
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData k1TOWNSCDATableProvider[] = {
+const ExtractEntrySearchData k1TownsCDATableProvider[] = {
 	{ UNK_LANG, kPlatformFMTowns, { 0x000002C4, 0x0000C5ED, { { 0x76, 0x86, 0x77, 0xF9, 0x85, 0x23, 0x32, 0x56, 0x3C, 0x06, 0x03, 0xCF, 0x0C, 0x49, 0x94, 0xB5 } } } },
 
 	EXTRACT_END_ENTRY
@@ -1142,13 +1142,8 @@ const ExtractEntrySearchData k2IngamePakFilesProvider[] = {
 };
 
 const ExtractEntrySearchData k2IngameSfxFilesProvider[] = {
-	{ UNK_LANG, kPlatformUnknown, { 0x000006F1, 0x0001545E, { { 0xD3, 0x8A, 0xA1, 0xD4, 0x83, 0x77, 0x96, 0x6D, 0x87, 0xB1, 0x71, 0x8F, 0x38, 0x6A, 0x34, 0xDC } } } },
-
-	EXTRACT_END_ENTRY
-};
-
-const ExtractEntrySearchData k2IngameSfxFilesTnsProvider[] = {
-	{ UNK_LANG, kPlatformUnknown, { 0x00000967, 0x0002101A, { { 0x09, 0xC7, 0xB7, 0x2A, 0x76, 0xF1, 0x4B, 0x87, 0xC5, 0x83, 0xFF, 0xF3, 0xDB, 0x3C, 0x66, 0x60 } } } },
+	{ UNK_LANG, kPlatformPC, { 0x000006F1, 0x0001545E, { { 0xD3, 0x8A, 0xA1, 0xD4, 0x83, 0x77, 0x96, 0x6D, 0x87, 0xB1, 0x71, 0x8F, 0x38, 0x6A, 0x34, 0xDC } } } },
+	{ UNK_LANG, kPlatformFMTowns, { 0x00000967, 0x0002101A, { { 0x09, 0xC7, 0xB7, 0x2A, 0x76, 0xF1, 0x4B, 0x87, 0xC5, 0x83, 0xFF, 0xF3, 0xDB, 0x3C, 0x66, 0x60 } } } },
 
 	EXTRACT_END_ENTRY
 };
@@ -1190,7 +1185,7 @@ const ExtractEntrySearchData k2IngameTimJpStringsProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData k2IngameItemAnimDataProvider[] = {
+const ExtractEntrySearchData k2IngameShapeAnimDataProvider[] = {
 	{ UNK_LANG, kPlatformPC, { 0x00000348, 0x0001AAEB, { { 0x67, 0xD1, 0x03, 0xBF, 0x4B, 0xEC, 0x80, 0x26, 0x5D, 0x1D, 0x0E, 0x5B, 0xF1, 0xE8, 0x4C, 0x64 } } } }, // CD
 
 	{ UNK_LANG, kPlatformUnknown, { 0x00000348, 0x00002473, { { 0xBC, 0x18, 0x51, 0xFA, 0x51, 0x1D, 0x24, 0x7D, 0x44, 0xD0, 0xE2, 0x38, 0x31, 0x33, 0x3B, 0x56 } } } }, // floppy + FM-TOWNS
@@ -1254,12 +1249,6 @@ const ExtractEntrySearchData k3ItemStringMapProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolSeqplayIntroTracksProvider[] = {
-	{ UNK_LANG, kPlatformPC, { 0x0000001A, 0x0000096C, { { 0xC2, 0xBD, 0x2C, 0x65, 0xD3, 0xFE, 0xF1, 0x6A, 0xE7, 0x34, 0x18, 0x0C, 0x86, 0x95, 0x66, 0x35 } } } },
-
-	EXTRACT_END_ENTRY
-};
-
 const ExtractEntrySearchData kLolIngamePakFilesProvider[] = {
 	{ UNK_LANG, kPlatformPC, { 0x00000088, 0x0000224F, { { 0xDA, 0x24, 0x18, 0xA3, 0xEF, 0x16, 0x70, 0x8F, 0xA8, 0xC2, 0x2E, 0xC2, 0xED, 0x39, 0x03, 0xD1 } } } },
 	{ UNK_LANG, kPlatformPC98, { 0x00000084, 0x00002125, { { 0x7A, 0x89, 0xE2, 0x36, 0xEC, 0x6F, 0x52, 0x2B, 0xEF, 0xBA, 0x3D, 0x28, 0x54, 0xDA, 0xFB, 0x72 } } } },
@@ -1295,19 +1284,19 @@ const ExtractEntrySearchData kLolMusicTrackMapProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolGMSfxIndexProvider[] = {
+const ExtractEntrySearchData kLolIngameGMSfxIndexProvider[] = {
 	{ UNK_LANG, kPlatformPC, { 0x000000FA, 0x00006281, { { 0x25, 0x89, 0xB0, 0x3B, 0x12, 0x09, 0x02, 0xF6, 0xFE, 0x76, 0xD5, 0xC9, 0x5B, 0x88, 0xAC, 0xAA } } } },
 
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolMT32SfxIndexProvider[] = {
+const ExtractEntrySearchData kLolIngameMT32SfxIndexProvider[] = {
 	{ UNK_LANG, kPlatformPC, { 0x000000FA, 0x00006579, { { 0x16, 0x40, 0x1C, 0x09, 0x69, 0xA9, 0x0D, 0x6D, 0x4B, 0x0C, 0x99, 0xF0, 0x40, 0x5D, 0xBB, 0x6E } } } },
 
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolPcSpkSfxIndexProvider[] = {
+const ExtractEntrySearchData kLolIngamePcSpkSfxIndexProvider[] = {
 	{ UNK_LANG, kPlatformPC, { 0x000000FA, 0x00005EFC, { { 0xA3, 0x5C, 0x69, 0xED, 0x13, 0xEC, 0x08, 0x0E, 0xFA, 0x72, 0x83, 0x0D, 0xD7, 0x8D, 0x9C, 0x70 } } } },
 
 	EXTRACT_END_ENTRY
@@ -1381,7 +1370,7 @@ const ExtractEntrySearchData kLolMonsterModifiersProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolMonsterLevelOffsetsProvider[] = {
+const ExtractEntrySearchData kLolMonsterShiftOffsetsProvider[] = {
 	{ UNK_LANG, kPlatformUnknown, { 0x00000020, 0x00000803, { { 0x30, 0x55, 0x74, 0x0D, 0xC7, 0x3B, 0xD9, 0x5C, 0x26, 0xF0, 0x4E, 0x8F, 0xE4, 0x4D, 0xCB, 0x2A } } } },
 
 	EXTRACT_END_ENTRY
@@ -1412,7 +1401,7 @@ const ExtractEntrySearchData kLolMonsterScaleWHProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolFlyingItemShpProvider[] = {
+const ExtractEntrySearchData kLolFlyingObjectShpProvider[] = {
 	{ UNK_LANG, kPlatformUnknown, { 0x00000082, 0x00000252, { { 0xDE, 0x9D, 0x89, 0xAF, 0x0F, 0x50, 0x14, 0x60, 0x68, 0xAF, 0x19, 0xD8, 0x54, 0x8A, 0x36, 0x27 } } } },
 
 	EXTRACT_END_ENTRY
@@ -1461,13 +1450,13 @@ const ExtractEntrySearchData kLolDscUnk1Provider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolDscShapeIndex1Provider[] = {
+const ExtractEntrySearchData kLolDscShapeIndexProvider[] = {
 	{ UNK_LANG, kPlatformUnknown, { 0x00000024, 0x00000728, { { 0x14, 0xBA, 0x6D, 0x5C, 0x7D, 0x20, 0x0D, 0x35, 0xA7, 0xB0, 0x8D, 0x2F, 0x1D, 0x2A, 0x49, 0xA4 } } } },
 
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolDscShapeIndex2Provider[] = {
+const ExtractEntrySearchData kLolDscOvlMapProvider[] = {
 	{ UNK_LANG, kPlatformUnknown, { 0x0000000A, 0x0000001F, { { 0x9C, 0xF2, 0xCC, 0x48, 0x42, 0xC6, 0x76, 0x83, 0xD3, 0x1A, 0x43, 0x42, 0x7F, 0xEF, 0x19, 0x0F } } } },
 
 	EXTRACT_END_ENTRY
@@ -1539,7 +1528,7 @@ const ExtractEntrySearchData kLolDscDimMapProvider[] = {
 	EXTRACT_END_ENTRY
 };
 
-const ExtractEntrySearchData kLolDscShapeOvlIndexProvider[] = {
+const ExtractEntrySearchData kLolDscOvlIndexProvider[] = {
 	{ UNK_LANG, kPlatformUnknown, { 0x00000028, 0x00000048, { { 0x3E, 0x8E, 0x62, 0xAF, 0xD1, 0x28, 0x39, 0x73, 0x0D, 0xD8, 0x4A, 0xA7, 0xF4, 0xD7, 0x32, 0x25 } } } },
 
 	EXTRACT_END_ENTRY
@@ -1816,9 +1805,9 @@ const ExtractEntry extractProviders[] = {
 	{ k1SpecialPalette33, k1SpecialPalette33Provider },
 	{ k1GUIStrings, k1GUIStringsProvider },
 	{ k1ConfigStrings, k1ConfigStringsProvider },
-	{ k1TOWNSSfxWDTable, k1TOWNSSfxWDTableProvider },
-	{ k1TOWNSSfxBTTable, k1TOWNSSfxBTTableProvider },
-	{ k1TOWNSCDATable, k1TOWNSCDATableProvider },
+	{ k1TownsSFXwdTable, k1TownsSFXwdTableProvider },
+	{ k1TownsSFXbtTable, k1TownsSFXbtTableProvider },
+	{ k1TownsCDATable, k1TownsCDATableProvider },
 	{ k1PC98StoryStrings, k1PC98StoryStringsProvider },
 	{ k1PC98IntroSfx, k1PC98IntroSfxProvider },
 	{ k1CreditsStrings, k1CreditsStringsProvider },
@@ -1838,13 +1827,12 @@ const ExtractEntry extractProviders[] = {
 	{ k2SeqplayShapeAnimData, k2SeqplayShapeAnimDataProvider },
 	{ k2IngamePakFiles, k2IngamePakFilesProvider },
 	{ k2IngameSfxFiles, k2IngameSfxFilesProvider },
-	{ k2IngameSfxFilesTns, k2IngameSfxFilesTnsProvider },
 	{ k2IngameSfxIndex, k2IngameSfxIndexProvider },
 	{ k2IngameTracks, k2IngameTracksProvider },
 	{ k2IngameCDA, k2IngameCDAProvider },
 	{ k2IngameTalkObjIndex, k2IngameTalkObjIndexProvider },
 	{ k2IngameTimJpStrings, k2IngameTimJpStringsProvider },
-	{ k2IngameItemAnimData, k2IngameItemAnimDataProvider },
+	{ k2IngameShapeAnimData, k2IngameShapeAnimDataProvider },
 	{ k2IngameTlkDemoStrings, k2IngameTlkDemoStringsProvider },
 	{ k3MainMenuStrings, k3MainMenuStringsProvider },
 	{ k3MusicFiles, k3MusicFilesProvider },
@@ -1854,15 +1842,14 @@ const ExtractEntry extractProviders[] = {
 	{ k3ItemAnimData, k3ItemAnimDataProvider },
 	{ k3ItemMagicTable, k3ItemMagicTableProvider },
 	{ k3ItemStringMap, k3ItemStringMapProvider },
-	{ kLolSeqplayIntroTracks, kLolSeqplayIntroTracksProvider },
 	{ kLolIngamePakFiles, kLolIngamePakFilesProvider },
 	{ kLolCharacterDefs, kLolCharacterDefsProvider },
 	{ kLolIngameSfxFiles, kLolIngameSfxFilesProvider },
 	{ kLolIngameSfxIndex, kLolIngameSfxIndexProvider },
 	{ kLolMusicTrackMap, kLolMusicTrackMapProvider },
-	{ kLolGMSfxIndex, kLolGMSfxIndexProvider },
-	{ kLolMT32SfxIndex, kLolMT32SfxIndexProvider },
-	{ kLolPcSpkSfxIndex, kLolPcSpkSfxIndexProvider },
+	{ kLolIngameGMSfxIndex, kLolIngameGMSfxIndexProvider },
+	{ kLolIngameMT32SfxIndex, kLolIngameMT32SfxIndexProvider },
+	{ kLolIngamePcSpkSfxIndex, kLolIngamePcSpkSfxIndexProvider },
 	{ kLolSpellProperties, kLolSpellPropertiesProvider },
 	{ kLolGameShapeMap, kLolGameShapeMapProvider },
 	{ kLolSceneItemOffs, kLolSceneItemOffsProvider },
@@ -1874,12 +1861,12 @@ const ExtractEntry extractProviders[] = {
 	{ kLolCharDefsAkshel, kLolCharDefsAkshelProvider },
 	{ kLolExpRequirements, kLolExpRequirementsProvider },
 	{ kLolMonsterModifiers, kLolMonsterModifiersProvider },
-	{ kLolMonsterLevelOffsets, kLolMonsterLevelOffsetsProvider },
+	{ kLolMonsterShiftOffsets, kLolMonsterShiftOffsetsProvider },
 	{ kLolMonsterDirFlags, kLolMonsterDirFlagsProvider },
 	{ kLolMonsterScaleY, kLolMonsterScaleYProvider },
 	{ kLolMonsterScaleX, kLolMonsterScaleXProvider },
 	{ kLolMonsterScaleWH, kLolMonsterScaleWHProvider },
-	{ kLolFlyingItemShp, kLolFlyingItemShpProvider },
+	{ kLolFlyingObjectShp, kLolFlyingObjectShpProvider },
 	{ kLolInventoryDesc, kLolInventoryDescProvider },
 	{ kLolLevelShpList, kLolLevelShpListProvider },
 	{ kLolLevelDatList, kLolLevelDatListProvider },
@@ -1887,8 +1874,8 @@ const ExtractEntry extractProviders[] = {
 	{ kLolItemPrices, kLolItemPricesProvider },
 	{ kLolStashSetup, kLolStashSetupProvider },
 	{ kLolDscUnk1, kLolDscUnk1Provider },
-	{ kLolDscShapeIndex1, kLolDscShapeIndex1Provider },
-	{ kLolDscShapeIndex2, kLolDscShapeIndex2Provider },
+	{ kLolDscShapeIndex, kLolDscShapeIndexProvider },
+	{ kLolDscOvlMap, kLolDscOvlMapProvider },
 	{ kLolDscScaleWidthData, kLolDscScaleWidthDataProvider },
 	{ kLolDscScaleHeightData, kLolDscScaleHeightDataProvider },
 	{ kLolDscX, kLolDscXProvider },
@@ -1900,7 +1887,7 @@ const ExtractEntry extractProviders[] = {
 	{ kLolDscDimData2, kLolDscDimData2Provider },
 	{ kLolDscBlockMap, kLolDscBlockMapProvider },
 	{ kLolDscDimMap, kLolDscDimMapProvider },
-	{ kLolDscShapeOvlIndex, kLolDscShapeOvlIndexProvider },
+	{ kLolDscOvlIndex, kLolDscOvlIndexProvider },
 	{ kLolDscBlockIndex, kLolDscBlockIndexProvider },
 	{ kLolDscDoor1, kLolDscDoor1Provider },
 	{ kLolDscDoorScale, kLolDscDoorScaleProvider },