Script reader, unit tests

CMakeLists.txt

@@ -78,6 +78,7 @@ enable_testing ()
 
 # Add subdirectories
 add_subdirectory (src)
+add_subdirectory (test)
 
 #################################################################
 

ChangeLog.md

@@ -2,6 +2,11 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140804 ]
+    * Added preliminary Tomb Raider Script parser
+    * Moved Unit Test folder
+    * Compiling main.cpp into the unit tests
+
     [ 20140729 ]
     * Unit Tests are back, currently only for the binary reader
     * Some cmake build system improvements:

include/Script.h

@@ -0,0 +1,117 @@
+/*!
+ * \file include/Script.h
+ * \brief Game script loader
+ *
+ * \author xythobuz
+ */
+
+#ifndef _SCRIPT_H_
+#define _SCRIPT_H_
+
+#include "utils/binary.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+/*!
+ * \brief Game script loader
+ */
+class Script {
+public:
+
+    typedef enum {
+        S_English  = 0,
+        S_French   = 1,
+        S_German   = 2,
+        S_American = 3,
+        S_Japanese = 4
+    } ScriptLanguage;
+
+    Script();
+    ~Script();
+
+    int load(const char *file);
+
+    unsigned int levelCount();
+    std::string getLevelName(unsigned int i);
+    std::string getLevelFilename(unsigned int i);
+
+    unsigned int cutsceneCount();
+    std::string getCutsceneFilename(unsigned int i);
+
+    unsigned int titleCount();
+    std::string getTitleFilename(unsigned int i);
+
+    unsigned int videoCount();
+    std::string getVideoFilename(unsigned int i);
+
+    unsigned int gameStringCount();
+    std::string getGameString(unsigned int i);
+
+    unsigned int pcStringCount();
+    std::string getPCString(unsigned int i);
+
+private:
+
+    void readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n);
+
+    enum ScriptFlags {
+        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
+        S_NoInputTimeout         = (1 << 3),  //!< If set don't timeout input to start demo
+        S_LoadSaveDisabled       = (1 << 4),  //!< Don't allow load/save
+        S_ScreenSizingDisabled   = (1 << 5),  //!< Don't change screen resolution
+        S_LockOutOptionRing      = (1 << 6),  //!< No option ring while in level
+        S_DOZYCheatEnabled       = (1 << 7),  //!< DOZY flying cheat
+        S_UseSecurityTag         = (1 << 8),  //!< Strings XORed with cypherCode
+        S_Unknown                = (1 << 9),  //!< Usually set, no known effect
+        S_SelectAnyLevel         = (1 << 10), //!< Level selectable in Title
+        S_EnableCheatCode        = (1 << 11)  //!< No known effect
+    };
+
+    // Header
+    uint32_t version;
+    std::string description;
+
+    // Gameflow data
+    uint32_t firstOption;
+    int32_t titleReplace;
+    uint32_t onDeathDemoMode;
+    uint32_t onDeathInGame;
+    uint32_t noInputTime;
+    uint32_t onDemoInterrupt;
+    uint32_t onDemoEnd;
+    uint16_t numLevels;
+    uint16_t numPictures;
+    uint16_t numTitles;
+    uint16_t numFMVs;
+    uint16_t numCutscenes;
+    uint16_t numDemos;
+    uint16_t titleTrack;
+    int16_t singleLevel;
+    uint16_t flags;
+    uint8_t cypherCode;
+    uint8_t language;
+    uint16_t secretTrack;
+
+    uint16_t numGameStrings;
+
+    // Strings
+    std::vector<std::string> levelNames; // numLevels
+    std::vector<std::string> pictureFilenames; // numPictures
+    std::vector<std::string> titleFilenames; // numTitles
+    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::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
+};
+
+#endif
+

src/CMakeLists.txt

@@ -62,6 +62,7 @@ set (SRCS ${SRCS} "OpenRaider.cpp")
 set (SRCS ${SRCS} "Render.cpp")
 set (SRCS ${SRCS} "Room.cpp")
 set (SRCS ${SRCS} "RoomData.cpp")
+set (SRCS ${SRCS} "Script.cpp")
 set (SRCS ${SRCS} "SkeletalModel.cpp")
 set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "Sprite.cpp")
@@ -204,7 +205,6 @@ set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS}
 # Add subdirectories
 add_subdirectory ("deps")
 add_subdirectory ("math")
-add_subdirectory ("test")
 add_subdirectory ("utils")
 
 # Add Executable

src/Script.cpp

@@ -0,0 +1,167 @@
+/*!
+ * \file src/Script.cpp
+ * \brief Game script loader
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Script.h"
+
+Script::Script() {
+
+}
+
+Script::~Script() {
+
+}
+
+int Script::load(const char *file) {
+    BinaryFile f(file);
+
+    version = f.readU32();
+
+    char desc[256];
+    for (int i = 0; i < 256; i++)
+        desc[i] = f.read8();
+    description = desc;
+
+    uint16_t gameflowSize = f.readU16();
+    assert(gameflowSize == 128);
+
+    firstOption = f.readU32();
+    titleReplace = f.read32();
+    onDeathDemoMode = f.readU32();
+    onDeathInGame = f.readU32();
+    noInputTime = f.readU32();
+    onDemoInterrupt = f.readU32();
+    onDemoEnd = f.readU32();
+
+    // Filler 1 (36 bytes)
+    f.seek(f.tell() + 36);
+
+    numLevels = f.readU16();
+    numPictures = f.readU16();
+    numTitles = f.readU16();
+    numFMVs = f.readU16();
+    numCutscenes = f.readU16();
+    numDemos = f.readU16();
+    titleTrack = f.readU16();
+    singleLevel = f.read16();
+
+    // Filler 2 (32 bytes)
+    f.seek(f.tell() + 32);
+
+    flags = f.readU16();
+
+    // Filler 3 (6 bytes)
+    f.seek(f.tell() + 6);
+
+    cypherCode = f.readU8();
+    language = f.readU8();
+    secretTrack = f.readU16();
+
+    // Filler 4 (4 bytes)
+    f.seek(f.tell() + 4);
+
+    // Strings
+    readStringPackage(f, levelNames, numLevels);
+    readStringPackage(f, pictureFilenames, numPictures);
+    readStringPackage(f, titleFilenames, numTitles);
+    readStringPackage(f, fmvFilenames, numFMVs);
+    readStringPackage(f, levelFilenames, numLevels);
+    readStringPackage(f, cutsceneFilenames, numCutscenes);
+    readStringPackage(f, script, numLevels + 1);
+
+    numGameStrings = f.readU16();
+    readStringPackage(f, gameStrings, numGameStrings);
+
+    readStringPackage(f, pcStrings, 41);
+
+    //! \todo read puzzle strings
+    //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
+
+    return 0;
+}
+
+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();
+
+    char *list = new char[numBytes];
+    for (uint16_t i = 0; i < numBytes; i++)
+        list[i] = f.read8();
+
+    for (unsigned int i = 0; i < n; i++) {
+        std::string tmp(list + offset[i]);
+        v.push_back(tmp);
+    }
+
+    delete [] list;
+    delete [] offset;
+}
+
+unsigned int Script::levelCount() {
+    return numLevels;
+}
+
+std::string Script::getLevelName(unsigned int i) {
+    assert(i < numLevels);
+    return levelNames.at(i);
+}
+
+std::string Script::getLevelFilename(unsigned int i) {
+    assert(i < numLevels);
+    return levelFilenames.at(i);
+}
+
+unsigned int Script::cutsceneCount() {
+    return numCutscenes;
+}
+
+std::string Script::getCutsceneFilename(unsigned int i) {
+    assert(i < numCutscenes);
+    return cutsceneFilenames.at(i);
+}
+
+unsigned int Script::titleCount() {
+    return numTitles;
+}
+
+std::string Script::getTitleFilename(unsigned int i) {
+    assert(i < numTitles);
+    return titleFilenames.at(i);
+}
+
+unsigned int Script::videoCount() {
+    return numFMVs;
+}
+
+std::string Script::getVideoFilename(unsigned int i) {
+    assert(i < numFMVs);
+    return fmvFilenames.at(i);
+}
+
+unsigned int Script::gameStringCount() {
+    return numGameStrings;
+}
+
+std::string Script::getGameString(unsigned int i) {
+    assert(i < numGameStrings);
+    return gameStrings.at(i);
+}
+
+unsigned int Script::pcStringCount() {
+    return 41;
+}
+
+std::string Script::getPCString(unsigned int i) {
+    assert(i < 41);
+    return pcStrings.at(i);
+}
+

src/TombRaider.cpp

@@ -4534,7 +4534,7 @@ void TombRaider::extractMeshes(unsigned char *mesh_data,
             mMeshes[i].coloured_rectangles = 0x0;
             mMeshes[i].coloured_triangles = 0x0;
 
-            // Mongoose 2002.04.04, FIXME is this right?
+            //! \fixme is this right? Mongoose 2002.04.04
             mesh_pointer += 2;
             continue;
         }

src/main.cpp

@@ -23,6 +23,8 @@
 #include "utils/strings.h"
 #include "utils/time.h"
 
+#ifndef UNIT_TEST
+
 #ifdef USING_AL
 #include "SoundAL.h"
 #else
@@ -149,29 +151,6 @@ int main(int argc, char *argv[]) {
     return 0;
 }
 
-#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS) && (!defined(NDEBUG))
-
-#include <execinfo.h>
-
-void assertImplementation(const char *exp, const char *file, int line) {
-    const unsigned int maxSize = 128;
-    void *callstack[maxSize];
-    int frames = backtrace(callstack, maxSize);
-    char **strs = backtrace_symbols(callstack, frames);
-
-    std::cout << std::endl << "assertion failed:" << std::endl;
-    std::cout << "\t" << exp << std::endl;
-    std::cout << "in " << file << ":" << line << std::endl << std::endl;
-
-    for (int i = 0; i < frames; i++)
-        std::cout << strs[i] << std::endl;
-
-    delete [] strs;
-    abort();
-}
-
-#endif
-
 ActionEvents stringToActionEvent(const char *action) {
     if (strcmp(action, "menu") == 0) {
         return menuAction;
@@ -385,3 +364,28 @@ KeyboardButton stringToKeyboardButton(const char *key) {
     return unknownKey;
 }
 
+#endif // UNIT_TEST
+
+#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS) && (!defined(NDEBUG))
+
+#include <execinfo.h>
+
+void assertImplementation(const char *exp, const char *file, int line) {
+    const unsigned int maxSize = 128;
+    void *callstack[maxSize];
+    int frames = backtrace(callstack, maxSize);
+    char **strs = backtrace_symbols(callstack, frames);
+
+    std::cout << std::endl << "assertion failed:" << std::endl;
+    std::cout << "\t" << exp << std::endl;
+    std::cout << "in " << file << ":" << line << std::endl << std::endl;
+
+    for (int i = 0; i < frames; i++)
+        std::cout << strs[i] << std::endl;
+
+    delete [] strs;
+    abort();
+}
+
+#endif
+

src/test/CMakeLists.txt

@@ -1,16 +0,0 @@
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenRaider_CXX_FLAGS}")
-set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_DEBUG}")
-set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_RELEASE}")
-
-add_custom_target (check COMMAND ${CMAKE_CTEST_COMMAND} -V)
-
-#################################################################
-
-add_executable (tester_binary EXCLUDE_FROM_ALL
-    "binary.cpp" "../utils/binary.cpp"
-)
-add_dependencies (check tester_binary)
-add_test (NAME test_binary COMMAND tester_binary)
-
-#################################################################
-

src/test/binary.cpp

@@ -1,91 +0,0 @@
-/*!
- * \file test/binary.cpp
- * \brief Binary Unit Test
- *
- * \author xythobuz
- */
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-
-#include "utils/binary.h"
-
-
-namespace {
-    const char testData[] = {
-        // Unsigned Integers
-        -1,                     // u 8 -> 255
-        -1, -1,                 // u16 -> 65535
-        42, 0, 0, 0,            // u32 -> 42
-        1, 0, 0, 0, 0, 0, 0, 0, // u64 -> 1
-
-        // Signed Integers
-        -1,                     //  8 -> -1
-        92, -2,                 // 16 -> -420
-        102, -3, -1, -1,        // 32 -> -666
-        -5, -1, -1, -1,
-        -1, -1, -1, -1          // 64 -> -5
-    };
-
-    float f1 = 3.1415926f;
-    float f2 = 42.23f;
-
-    void fillFile(const char *name) {
-        std::ofstream file(name, std::ios_base::out | std::ios_base::binary);
-        file.write(testData, sizeof(testData) / sizeof(testData[0]));
-        file.write(reinterpret_cast<char *>(&f1), sizeof(f1));
-        file.write(reinterpret_cast<char *>(&f2), sizeof(f2));
-    }
-
-    int assertImplementation(const char *exp, const char *file, int line) {
-        std::cout << "Failed: \"" << exp << "\" in " << file << " at " << line << std::endl;
-        return 1;
-    }
-
-#define assert(x) if (!(x)) { return assertImplementation(#x, __FILE__, __LINE__); }
-
-    int test(const char *name) {
-        BinaryFile file(name);
-
-        uint8_t a = file.readU8();
-        uint16_t b = file.readU16();
-        uint32_t c = file.readU32();
-        uint64_t d = file.readU64();
-
-        int8_t e = file.read8();
-        int16_t f = file.read16();
-        int32_t g = file.read32();
-        int64_t h = file.read64();
-
-        float i = file.readFloat();
-        float j = file.readFloat();
-
-        assert(a == 255);
-        assert(b == 65535);
-        assert(c == 42);
-        assert(d == 1);
-
-        assert(e == -1);
-        assert(f == -420);
-        assert(g == -666);
-        assert(h == -5);
-
-        assert(i == f1);
-        assert(j == f2);
-
-        return 0;
-    }
-}
-
-int main(int argc, char *argv[]) {
-    char *tmpFile = tmpnam(NULL);
-    std::cout << "Temporary test-file: " << tmpFile << std::endl;
-
-    fillFile(tmpFile);
-    int error = test(tmpFile);
-    remove(tmpFile);
-
-    return error;
-}
-

src/utils/binary.cpp

@@ -8,7 +8,7 @@
 #include "utils/binary.h"
 
 BinaryFile::BinaryFile(const char *f) {
-    file.open(f, std::ios_base::in | std::ios_base:: binary);
+    file.open(f, std::ios_base::in | std::ios_base::binary);
 }
 
 BinaryFile::~BinaryFile() {

test/CMakeLists.txt

@@ -0,0 +1,25 @@
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenRaider_CXX_FLAGS} -DUNIT_TEST")
+set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OpenRaider_CXX_FLAGS_DEBUG} -DUNIT_TEST")
+set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS_RELEASE} -DUNIT_TEST")
+
+add_custom_target (check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure)
+
+#################################################################
+
+add_executable (tester_binary EXCLUDE_FROM_ALL
+    "binary.cpp" "../src/utils/binary.cpp" "../src/main.cpp"
+)
+add_dependencies (check tester_binary)
+add_test (NAME test_binary COMMAND tester_binary)
+
+#################################################################
+
+add_executable (tester_script EXCLUDE_FROM_ALL
+    "Script.cpp" "../src/Script.cpp" "../src/main.cpp"
+    "../src/utils/binary.cpp"
+)
+add_dependencies (check tester_script)
+add_test (NAME test_script COMMAND tester_script)
+
+#################################################################
+

test/Script.cpp

@@ -0,0 +1,15 @@
+/*!
+ * \file src/Script.cpp
+ * \brief Game script loader
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Script.h"
+
+int main() {
+
+    return 0;
+}
+

test/binary.cpp

@@ -0,0 +1,84 @@
+/*!
+ * \file test/binary.cpp
+ * \brief Binary Unit Test
+ *
+ * \author xythobuz
+ */
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+
+#include "global.h"
+#include "utils/binary.h"
+
+
+namespace {
+    const char testData[] = {
+        // Unsigned Integers
+        -1,
+        -1, -1,
+        42, 42, 42, 42,
+        -1, -1, -1, -1, -1, 0, 0, 0,
+
+        // Signed Integers
+        -1,
+        92, -2,
+        102, -3, -1, -1,
+        66, 66, 66, 66, 66, 66, 66, 66
+    };
+
+    float f1 = 3.1415926f;
+    float f2 = 42.23f;
+
+    void fillFile(const char *name) {
+        std::ofstream file(name, std::ios_base::out | std::ios_base::binary);
+        file.write(testData, sizeof(testData) / sizeof(testData[0]));
+        file.write(reinterpret_cast<char *>(&f1), sizeof(f1));
+        file.write(reinterpret_cast<char *>(&f2), sizeof(f2));
+    }
+
+#define assertEqual(x, y) if (x != y) {\
+    std::cout << "Assertion failed:" << std::endl; \
+    std::cout << #x << " == " << #y << " (" << x << ", " << y << ")" << std::endl; \
+    return 1; \
+}
+
+    int test(const char *name) {
+        BinaryFile file(name);
+
+        assertEqual(file.readU8(), 255);
+        assertEqual(file.readU16(), 65535);
+        assertEqual(file.readU32(), 707406378);
+        assertEqual(file.readU64(), 1099511627775);
+
+        assertEqual(file.read8(), -1);
+        assertEqual(file.read16(), -420);
+        assertEqual(file.read32(), -666);
+        assertEqual(file.read64(), 4774451407313060418);
+
+        std::cout << "This test will fail on big-endian machines!" << std::endl;
+        assertEqual(file.readFloat(), f1);
+        assertEqual(file.readFloat(), f2);
+
+        assert(file.tell() == 38);
+
+        return 0;
+    }
+}
+
+int main() {
+    char tmpFile[] = "/tmp/openraider_unit_test_0";
+    FILE *f;
+    while ((f = fopen(tmpFile, "r")) != NULL) {
+        fclose(f);
+        tmpFile[25]++;
+    }
+
+    fillFile(tmpFile);
+    int error = test(tmpFile);
+    remove(tmpFile);
+
+    return error;
+}
+