Improved Script reader and its Unit Test

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140806 ]
+    * Improved Script reader and its Unit Test
+
     [ 20140804 ]
     * Added preliminary Tomb Raider Script parser
     * Moved Unit Test folder

include/Script.h

     unsigned int pcStringCount();
     std::string getPCString(unsigned int i);
 
+    std::string getPuzzleString(unsigned int i, unsigned int j);
+    std::string getPickupString(unsigned int i, unsigned int j);
+    std::string getKeyString(unsigned int i, unsigned int j);
+
 private:
 
     void readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n);

include/utils/binary.h

 class BinaryFile {
 public:
 
-    BinaryFile(const char *f);
     ~BinaryFile();
 
+    int open(const char *f);
+
     long long tell();
     void seek(long long pos);
 

src/Script.cpp

 #include "global.h"
 #include "Script.h"
 
-Script::Script() {
-
+Script::Script() : puzzles(4), pickups(2), keys(4) {
 }
 
 Script::~Script() {
 }
 
 int Script::load(const char *file) {
-    BinaryFile f(file);
+    BinaryFile f;
+
+    if (f.open(file) != 0)
+        return 1;
 
     version = f.readU32();
 
     readStringPackage(f, script, numLevels + 1);
 
     numGameStrings = f.readU16();
+    numGameStrings = 89; // Ignored?
+
     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
+    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;
 }
     uint16_t numBytes = f.readU16();
 
     char *list = new char[numBytes];
-    for (uint16_t i = 0; i < numBytes; i++)
+    for (uint16_t i = 0; i < numBytes; i++) {
         list[i] = f.read8();
+        if (flags & S_UseSecurityTag) {
+            list[i] ^= cypherCode;
+        }
+    }
 
     for (unsigned int i = 0; i < n; i++) {
         std::string tmp(list + offset[i]);
     return pcStrings.at(i);
 }
 
+std::string Script::getPuzzleString(unsigned int i, unsigned int j) {
+    assert(i < 4);
+    assert(j < numLevels);
+    return puzzles.at(i).at(j);
+}
+
+std::string Script::getPickupString(unsigned int i, unsigned int j) {
+    assert(i < 2);
+    assert(j < numLevels);
+    return pickups.at(i).at(j);
+}
+
+std::string Script::getKeyString(unsigned int i, unsigned int j) {
+    assert(i < 4);
+    assert(j < numLevels);
+    return keys.at(i).at(j);
+}
+

src/utils/binary.cpp

  * \author xythobuz
  */
 
+#include "global.h"
 #include "utils/binary.h"
 
-BinaryFile::BinaryFile(const char *f) {
-    file.open(f, std::ios_base::in | std::ios_base::binary);
+BinaryFile::~BinaryFile() {
+    if (file.is_open())
+        file.close();
 }
 
-BinaryFile::~BinaryFile() {
-    file.close();
+int BinaryFile::open(const char *f) {
+    if (file.is_open()) {
+        return 1;
+    } else {
+        file.open(f, std::ios_base::in | std::ios_base::binary);
+        return (file ? 0 : 1);
+    }
 }
 
 long long BinaryFile::tell() {
+    assert(file.is_open());
     return file.tellg();
 }
 
 void BinaryFile::seek(long long pos) {
+    assert(file.is_open());
     file.seekg(pos);
 }
 
 uint8_t BinaryFile::readU8() {
+    assert(file.is_open());
     uint8_t ret;
     char *c = reinterpret_cast<char *>(&ret);
     file.read(c, 1);
 }
 
 uint16_t BinaryFile::readU16() {
+    assert(file.is_open());
     uint8_t a = readU8();
     uint8_t b = readU8();
     return ((uint16_t)a | (uint16_t)(b << 8));
 }
 
 uint32_t BinaryFile::readU32() {
+    assert(file.is_open());
     uint16_t a = readU16();
     uint16_t b = readU16();
     return ((uint32_t)a | (uint32_t)(b << 16));
 }
 
 uint64_t BinaryFile::readU64() {
+    assert(file.is_open());
     uint32_t a = readU32();
     uint32_t b = readU32();
     return ((uint64_t)a | ((uint64_t)b << 32));
 }
 
 float BinaryFile::readFloat() {
+    assert(file.is_open());
     uint32_t val = readU32();
     char *a = reinterpret_cast<char *>(&val);
 
 }
 
 int8_t BinaryFile::read8() {
+    assert(file.is_open());
     int8_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 }
 
 int16_t BinaryFile::read16() {
+    assert(file.is_open());
     int16_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 }
 
 int32_t BinaryFile::read32() {
+    assert(file.is_open());
     int32_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 }
 
 int64_t BinaryFile::read64() {
+    assert(file.is_open());
     int64_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));

test/CMakeLists.txt

 
 add_executable (tester_script EXCLUDE_FROM_ALL
     "Script.cpp" "../src/Script.cpp" "../src/main.cpp"
-    "../src/utils/binary.cpp"
+    "../src/utils/binary.cpp" "../src/utils/strings.cpp"
 )
 add_dependencies (check tester_script)
 add_test (NAME test_script COMMAND tester_script)

test/Script.cpp

 /*!
- * \file src/Script.cpp
- * \brief Game script loader
+ * \file test/Script.cpp
+ * \brief Game script loader unit test
  *
  * \author xythobuz
  */
 
+#include <iostream>
+
 #include "global.h"
+#include "test.h"
+#include "utils/strings.h"
 #include "Script.h"
 
+#define printStrings(cnt, acc, name) { \
+    std::cout << name << " (" << cnt << ")" << std::endl; \
+    for (unsigned int i = 0; i < cnt; i++) { \
+        std::cout << "    " << acc(i) << std::endl; \
+    } \
+    std::cout << std::endl; \
+}
+
+#define printStrings2D(c, cnt, acc, name) { \
+    std::cout << name << " (" << c << "*" << cnt << ")" << std::endl; \
+    for (unsigned int a = 0; a < cnt; a++) { \
+        std::cout << "    "; \
+        for (unsigned int i = 0; i < c; i++) { \
+            std::cout << acc(i, a) << " "; \
+        } \
+        std::cout << std::endl; \
+    } \
+    std::cout << std::endl; \
+}
+
 int main() {
+    Script s;
+    char *f = fullPath("~/.OpenRaider/paks/tr2/TOMBPC.DAT", 0);
+    assertEqual(s.load(f), 0);
+    delete [] f;
+
+    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");
+
+    //std::cout << "This test always fails so you can see its output!" << std::endl;
+    //return 1;
 
     return 0;
 }

test/binary.cpp

 #include <fstream>
 
 #include "global.h"
+#include "test.h"
 #include "utils/binary.h"
 
 
         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);
+        BinaryFile file;
+        assertEqual(file.open(name), 0);
 
         assertEqual(file.readU8(), 255);
         assertEqual(file.readU16(), 65535);

test/test.h

+/*!
+ * \file test/test.h
+ * \brief Common Unit Test helpers
+ *
+ * \author xythobuz
+ */
+
+#ifndef _TEST_H
+#define _TEST_H
+
+#include <iostream>
+
+#define assertEqual(x, y) if (x != y) { \
+    std::cout << "Assertion failed:" << std::endl; \
+    std::cout << #x << " == " << #y << " (" << x << ", " << y << ")" << std::endl; \
+    return 1; \
+}
+
+#endif
+