Script parser can read level scripts

ChangeLog.md

@@ -2,6 +2,9 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140807 ]
+    * Script parser successfully loading level scripts
+
     [ 20140806 ]
     * Improved Script reader and its Unit Test
     * Successfully parsing the TR2 Script strings!

include/Script.h

@@ -11,6 +11,7 @@
 #include "utils/binary.h"
 
 #include <cstdint>
+#include <functional>
 #include <string>
 #include <vector>
 
@@ -28,6 +29,66 @@ public:
         S_Japanese = 4
     } ScriptLanguage;
 
+    typedef enum {
+        OP_PICTURE        = 0,  //!< Unused in TR2. Or PSX?
+        OP_PSX_TRACK      = 1,  //!< Does not compile. PSX?
+        OP_PSX_FMV        = 2,  //!< Does not compile. PSX?
+        OP_FMV            = 3,  //!< Display FMV
+        OP_GAME           = 4,  //!< Start a playable level
+        OP_CUT            = 5,  //!< Display a cutscene
+        OP_COMPLETE       = 6,  //!< Display level-completion stats
+        OP_DEMO           = 7,  //!< Display demo sequence
+        OP_PSX_DEMO       = 8,  //!< Does not compile. PSX?
+        OP_END            = 9,  //!< Closes script sequence
+        OP_TRACK          = 10, //!< Play soundtrack (precedes level opcode)
+        OP_SUNSET         = 11, //!< Unknown, nothing changes in TR2.
+        OP_LOAD_PIC       = 12, //!< Does not compile. PSX or TR3?
+        OP_DEADLY_WATER   = 13, //!< Unknown, nothing changes in TR2.
+        OP_REMOVE_WEAPONS = 14, //!< Start level without weapons
+        OP_GAMECOMPLETE   = 15, //!< End of game. Show stats, start credits sequence, music ID 52.
+        OP_CUTANGLE       = 16, //!< Match N-S orientation of Room and animated characters.
+        OP_NOFLOOR        = 17, //!< Lara dies when her feet reach given depth.
+        OP_STARTINV       = 18, //!< Items given to Lara at level start (+1000), or at all secrets found (+0)
+        OP_STARTANIM      = 19, //!< Special animation of Lara when level starts
+        OP_SECRETS        = 20, //!< If zero, level does not account for secrets
+        OP_KILLTOCOMPLETE = 21, //!< Kill all enemies to finish the level
+        OP_REMOVE_AMMO    = 22, //!< Lara starts level without ammo or medi packs
+        OP_UNKNOWN        = 23
+    } ScriptOpCode;
+
+    // Items for all-secrets-found go from 0 to 26,
+    // for start-inventory add 1000, so 1000 - 1026
+    typedef enum {
+        OP_WEAPON_PISTOLS     = 0,  //!< Add standard pistols (2)
+        OP_WEAPON_SHOTGUN     = 1,  //!< Add shotgun (1)
+        OP_WEAPON_AUTOPISTOLS = 2,  //!< Add automatic pistols (2)
+        OP_WEAPON_UZIS        = 3,  //!< Add uzis (2)
+        OP_WEAPON_HARPOON     = 4,  //!< Add harpoon gun (1)
+        OP_WEAPON_M16         = 5,  //!< Add M16 (1)
+        OP_WEAPON_ROCKET      = 6,  //!< Add grenade launcher (1)
+        OP_AMMO_PISTOLS       = 7,  //!< No effect, infinite ammo
+        OP_AMMO_SHOTGUN       = 8,  //!< Add 2 shells
+        OP_AMMO_AUTOPISTOLS   = 9,  //!< Add 2 shells
+        OP_AMMO_UZIS          = 10, //!< Add 2 shells
+        OP_AMMO_HARPOON       = 11, //!< Add 2 harpoons
+        OP_AMMO_M16           = 12, //!< Add 2 shells
+        OP_AMMO_ROCKET        = 13, //!< Add 1 grenade
+        OP_ITEM_FLARE         = 14, //!< Add 1 flare
+        OP_ITEM_MEDI          = 15, //!< Add 1 small MediPack
+        OP_ITEM_BIGMEDI       = 16, //!< Add 1 big MediPack
+        OP_ITEM_PICKUP1       = 17, //!< Add Pickup Item 1
+        OP_ITEM_PICKUP2       = 18, //!< Add Pickup Item 2
+        OP_ITEM_PUZZLE1       = 19, //!< Add Puzzle Item 1
+        OP_ITEM_PUZZLE2       = 20, //!< Add Puzzle Item 2
+        OP_ITEM_PUZZLE3       = 21, //!< Add Puzzle Item 3
+        OP_ITEM_PUZZLE4       = 22, //!< Add Puzzle Item 4
+        OP_ITEM_KEY1          = 23, //!< Add Key Item 1
+        OP_ITEM_KEY2          = 24, //!< Add Key Item 2
+        OP_ITEM_KEY3          = 25, //!< Add Key Item 3
+        OP_ITEM_KEY4          = 26, //!< Add Key Item 4
+        OP_ITEM_UNKNOWN       = 27
+    } ScriptItem;
+
     Script();
     ~Script();
 
@@ -56,11 +117,12 @@ public:
     std::string getPickupString(unsigned int i, unsigned int j);
     std::string getKeyString(unsigned int i, unsigned int j);
 
-private:
+    void registerScriptHandler(ScriptOpCode op, std::function<int (bool, uint16_t)> func);
+    int runScript(unsigned int level);
 
-    void readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n, bool tag, uint16_t off);
+private:
 
-    enum ScriptFlags {
+    typedef enum {
         S_DemoVersion            = (1 << 0),  //!< Don't load a MAIN.SFX
         S_TitleDisabled          = (1 << 1),  //!< If set, game has no title screen
         S_CheatModeCheckDisabled = (1 << 2),  //!< Disable flare/step/rotate/jump sequence
@@ -73,6 +135,15 @@ private:
         S_Unknown                = (1 << 9),  //!< Usually set, no known effect
         S_SelectAnyLevel         = (1 << 10), //!< Level selectable in Title
         S_EnableCheatCode        = (1 << 11)  //!< No known effect
+    } ScriptFlag;
+
+    void readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n);
+
+    const bool opcodeHasOperand[OP_UNKNOWN] {
+        true, true, true, true, true, true,
+        false, true, true, false, true, false,
+        true, false, false, false, true, true,
+        true, true, true, false, false
     };
 
     // Header
@@ -100,8 +171,6 @@ private:
     uint8_t language;
     uint16_t secretTrack;
 
-    uint16_t numGameStrings;
-
     // Strings
     std::vector<std::string> levelNames; // numLevels
     std::vector<std::string> pictureFilenames; // numPictures
@@ -109,12 +178,15 @@ private:
     std::vector<std::string> fmvFilenames; // numFMVs
     std::vector<std::string> levelFilenames; // numLevels
     std::vector<std::string> cutsceneFilenames; // numCutscenes
-    std::vector<std::string> script; // numLevels + 1
+    std::vector<std::vector<uint16_t>> script; // numLevels + 1
+    uint16_t numGameStrings;
     std::vector<std::string> gameStrings; // numGameStrings, 89
     std::vector<std::string> pcStrings; // 41
     std::vector<std::vector<std::string>> puzzles; // 4 * numLevels
     std::vector<std::vector<std::string>> pickups; // 2 * numLevels
     std::vector<std::vector<std::string>> keys; // 4 * numLevels
+
+    std::function<int (bool, uint16_t)> scriptHandlers[OP_UNKNOWN];
 };
 
 #endif

src/Script.cpp

@@ -29,7 +29,7 @@ int Script::load(const char *file) {
     description = desc;
 
     uint16_t gameflowSize = f.readU16();
-    assert(gameflowSize == 128);
+    assertEqual(gameflowSize, 128);
 
     firstOption = f.readU32();
     titleReplace = f.read32();
@@ -55,7 +55,6 @@ int Script::load(const char *file) {
     f.seek(f.tell() + 32);
 
     flags = f.readU16();
-    bool tag = (flags & S_UseSecurityTag) != 0;
 
     // Filler 3 (6 bytes)
     f.seek(f.tell() + 6);
@@ -68,50 +67,87 @@ int Script::load(const char *file) {
     f.seek(f.tell() + 4);
 
     // Strings
-    readStringPackage(f, levelNames, numLevels, tag, 0);
-    readStringPackage(f, pictureFilenames, numPictures, tag, 0);
-    readStringPackage(f, titleFilenames, numTitles, tag, 0);
-    readStringPackage(f, fmvFilenames, numFMVs, tag, 0);
-    readStringPackage(f, levelFilenames, numLevels, tag, 0);
-    readStringPackage(f, cutsceneFilenames, numCutscenes, tag, 0);
+    readStringPackage(f, levelNames, numLevels);
+    readStringPackage(f, pictureFilenames, numPictures);
+    readStringPackage(f, titleFilenames, numTitles);
+    readStringPackage(f, fmvFilenames, numFMVs);
+    readStringPackage(f, levelFilenames, numLevels);
+    readStringPackage(f, cutsceneFilenames, numCutscenes);
+
+    // Script Package
+    uint16_t *offset = new uint16_t[numLevels + 1];
+    for (unsigned int i = 0; i < (numLevels + 1); i++) {
+        offset[i] = f.readU16();
+        assertEqual(offset[i] % 2, 0);
+    }
 
-    // Offset definitely TR2 specific?!
-    readStringPackage(f, script, numLevels + 1, false, 6);
+    uint16_t numBytes = f.readU16() + 6; // Offset TR2 specific?!
+    assertEqual(numBytes % 2, 0); // 16 bit opcodes and operands
 
-    numGameStrings = f.readU16();
-    assert(numGameStrings == 89);
+    uint16_t *list = new uint16_t[numBytes / 2];
+    for (uint16_t i = 0; i < (numBytes / 2); i++) {
+        list[i] = f.readU16();
+    }
 
-    readStringPackage(f, gameStrings, numGameStrings, tag, 0);
+    for (unsigned int i = 0; i < (numLevels + 1); i++) {
+        unsigned int end = offset[i] / 2;
+
+        bool readingOperand = false;
+        while (readingOperand || (list[end] != OP_END)) {
+            if (readingOperand) {
+                readingOperand = false;
+                end++;
+            } else {
+                if (opcodeHasOperand[list[end]]) {
+                    readingOperand = true;
+                }
+                end++;
+            }
+        }
+        end++;
 
-    readStringPackage(f, pcStrings, 41, tag, 0);
+        std::vector<uint16_t> tmp;
+        for (unsigned int a = (offset[i] / 2); a < end; a++)
+            tmp.push_back(list[a]);
 
-    readStringPackage(f, puzzles[0], numLevels, tag, 0);
-    readStringPackage(f, puzzles[1], numLevels, tag, 0);
-    readStringPackage(f, puzzles[2], numLevels, tag, 0);
-    readStringPackage(f, puzzles[3], numLevels, tag, 0);
+        script.push_back(tmp);
+    }
 
-    readStringPackage(f, pickups[0], numLevels, tag, 0);
-    readStringPackage(f, pickups[1], numLevels, tag, 0);
+    delete [] list;
+    delete [] offset;
 
-    readStringPackage(f, keys[0], numLevels, tag, 0);
-    readStringPackage(f, keys[1], numLevels, tag, 0);
-    readStringPackage(f, keys[2], numLevels, tag, 0);
-    readStringPackage(f, keys[3], numLevels, tag, 0);
+    // Engine expects 89 game strings!
+    numGameStrings = f.readU16();
+    assertEqual(numGameStrings, 89);
+
+    // More strings...
+    readStringPackage(f, gameStrings, numGameStrings);
+    readStringPackage(f, pcStrings, 41);
+    readStringPackage(f, puzzles[0], numLevels);
+    readStringPackage(f, puzzles[1], numLevels);
+    readStringPackage(f, puzzles[2], numLevels);
+    readStringPackage(f, puzzles[3], numLevels);
+    readStringPackage(f, pickups[0], numLevels);
+    readStringPackage(f, pickups[1], numLevels);
+    readStringPackage(f, keys[0], numLevels);
+    readStringPackage(f, keys[1], numLevels);
+    readStringPackage(f, keys[2], numLevels);
+    readStringPackage(f, keys[3], numLevels);
 
     return 0;
 }
 
-void Script::readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n, bool tag, uint16_t off) {
+void Script::readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n) {
     uint16_t *offset = new uint16_t[n];
     for (unsigned int i = 0; i < n; i++)
         offset[i] = f.readU16();
 
-    uint16_t numBytes = f.readU16() + off;
+    uint16_t numBytes = f.readU16();
 
     char *list = new char[numBytes];
     for (uint16_t i = 0; i < numBytes; i++) {
         list[i] = f.read8();
-        if (tag) {
+        if (flags & S_UseSecurityTag) {
             list[i] ^= cypherCode;
         }
     }
@@ -202,3 +238,38 @@ std::string Script::getKeyString(unsigned int i, unsigned int j) {
     return keys.at(i).at(j);
 }
 
+void Script::registerScriptHandler(ScriptOpCode op, std::function<int (bool, uint16_t)> func) {
+    assert(op < OP_UNKNOWN);
+    scriptHandlers[op] = func;
+}
+
+int Script::runScript(unsigned int level) {
+    assert(level < (numLevels + 1));
+    std::vector<uint16_t> s = script.at(level);
+
+    for (unsigned int i = 0; i < s.size(); i++) {
+        uint16_t opcode = s.at(i);
+        if (opcode >= OP_UNKNOWN) {
+            return 1;
+        }
+
+        uint16_t operand = 0;
+        if (opcodeHasOperand[opcode]) {
+            if ((i + 1) >= s.size())
+                return 2; // Can't read operand!
+
+            operand = s.at(++i);
+        }
+
+        if (scriptHandlers[opcode]) {
+            int error = scriptHandlers[opcode](opcodeHasOperand[opcode], operand);
+            if (error != 0)
+                return error;
+        } else {
+            return 3;
+        }
+    }
+
+    return 0;
+}
+

test/Script.cpp

@@ -33,31 +33,79 @@
     std::cout << std::endl; \
 }
 
+#define registerLambda(x, y) { \
+    s.registerScriptHandler(x, [](bool hasOperand, uint16_t operand) { \
+        std::cout << "\t" << y; \
+        if (hasOperand) \
+            std::cout << " (" << operand << ")"; \
+        std::cout << std::endl; \
+        return 0; \
+    }); \
+}
+
 namespace {
-    int test(const char *f) {
+    int test(const char *f, bool strings) {
         Script s;
         assertEqual(s.load(f), 0);
 
-        printStrings(s.levelCount(), s.getLevelName, "Level Names");
-        printStrings(s.levelCount(), s.getLevelFilename, "Level Filenames");
-        printStrings(s.cutsceneCount(), s.getCutsceneFilename, "Cutscenes");
-        printStrings(s.titleCount(), s.getTitleFilename, "Titles");
-        printStrings(s.videoCount(), s.getVideoFilename, "Videos");
-        printStrings(s.gameStringCount(), s.getGameString, "Game Strings");
-        printStrings(s.pcStringCount(), s.getPCString, "PC Strings");
+        if (strings) {
+            printStrings(s.levelCount(), s.getLevelName, "Level Names");
+            printStrings(s.levelCount(), s.getLevelFilename, "Level Filenames");
+            printStrings(s.cutsceneCount(), s.getCutsceneFilename, "Cutscenes");
+            printStrings(s.titleCount(), s.getTitleFilename, "Titles");
+            printStrings(s.videoCount(), s.getVideoFilename, "Videos");
+            printStrings(s.gameStringCount(), s.getGameString, "Game Strings");
+            printStrings(s.pcStringCount(), s.getPCString, "PC Strings");
 
-        printStrings2D(4, s.levelCount(), s.getPuzzleString, "Puzzles");
-        printStrings2D(2, s.levelCount(), s.getPickupString, "Pickups");
-        printStrings2D(4, s.levelCount(), s.getKeyString, "Keys");
+            printStrings2D(4, s.levelCount(), s.getPuzzleString, "Puzzles");
+            printStrings2D(2, s.levelCount(), s.getPickupString, "Pickups");
+            printStrings2D(4, s.levelCount(), s.getKeyString, "Keys");
+        } else {
+            registerLambda(Script::OP_PICTURE, "Picture");
+            registerLambda(Script::OP_PSX_TRACK, "PSX-Track");
+            registerLambda(Script::OP_PSX_FMV, "PSX-FMV");
+            registerLambda(Script::OP_FMV, "Show FMV");
+            registerLambda(Script::OP_GAME, "Load level");
+            registerLambda(Script::OP_CUT, "Cutscene");
+            registerLambda(Script::OP_COMPLETE, "Level finished");
+            registerLambda(Script::OP_DEMO, "Demo sequence");
+            registerLambda(Script::OP_PSX_DEMO, "PSX-Demo");
+            registerLambda(Script::OP_END, "End of script");
+            registerLambda(Script::OP_TRACK, "Sound Track");
+            registerLambda(Script::OP_SUNSET, "Sunset");
+            registerLambda(Script::OP_LOAD_PIC, "Load picture");
+            registerLambda(Script::OP_DEADLY_WATER, "Deadly water");
+            registerLambda(Script::OP_REMOVE_WEAPONS, "Remove weapons");
+            registerLambda(Script::OP_GAMECOMPLETE, "End of game!");
+            registerLambda(Script::OP_CUTANGLE, "Cutscene angle");
+            registerLambda(Script::OP_NOFLOOR, "No floor, fall death");
+            registerLambda(Script::OP_STARTINV, "Inventory/Bonus");
+            registerLambda(Script::OP_STARTANIM, "Start animation");
+            registerLambda(Script::OP_SECRETS, "Secrets");
+            registerLambda(Script::OP_KILLTOCOMPLETE, "Kill to complete level");
+            registerLambda(Script::OP_REMOVE_AMMO, "Remove ammo");
+
+            for (unsigned int i = 0; i < (s.levelCount() + 1); i++) {
+                if (i == 0)
+                    std::cout << "Script for Title:" << std::endl;
+                else
+                    std::cout << "Script for \"" << s.getLevelName(i - 1) << "\" (" << i - 1 << "):" << std::endl;
+                int error = s.runScript(i);
+                if (error != 0)
+                    std::cout << "Returned " << error << "..." << std::endl;
+                std::cout << std::endl;
+            }
+        }
 
         return 0;
     }
 }
 
-int main() {
+int main(int argc, char *argv[]) {
     char *f = fullPath("~/.OpenRaider/paks/tr2/TOMBPC.DAT", 0);
-    int error = test(f);
+    int error = test(f, !((argc > 1) && (argv[1][0] == 's')));
     delete [] f;
+
     return error;
 }