Added level loader test driver and fixed parsing bug

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141011 ]
+    * Added simple level loader unit test driver
+    * Fixed the parsing bug in the new loader that sometimes caused strange hangs on level load
+
     [ 20141010 ]
     * Added CPack packaging to the CMake script
     * Added suitable install target for the Mac App Bundle

include/Log.h

 Log &getLog();
 
 #endif
+

src/loader/LoaderTR2.cpp

     }
 
     loadPaletteTextiles();
-    getLog() << "->loaded palette" << Log::endl;
 
     file.seek(file.tell() + 4); // Unused value?
 
     loadRooms();
-    getLog() << "->loaded rooms" << Log::endl;
-
     loadFloorData();
-    getLog() << "->loaded floor data" << Log::endl;
-
     loadMeshes();
-    getLog() << "->loaded meshes" << Log::endl;
-
     loadMoveables();
-    getLog() << "->loaded moveables" << Log::endl;
-
     loadStaticMeshes();
-    getLog() << "->loaded static meshes" << Log::endl;
-
     loadTextures();
-    getLog() << "->loaded textures" << Log::endl;
-
     loadSprites();
-    getLog() << "->loaded sprites" << Log::endl;
-
     loadCameras();
-    getLog() << "->loaded cameras" << Log::endl;
-
     loadSoundSources();
-    getLog() << "->loaded sound sources" << Log::endl;
-
     loadBoxesOverlapsZones();
-    getLog() << "->loaded boxes overlaps zones" << Log::endl;
-
     loadAnimatedTextures();
-    getLog() << "->loaded animated textures" << Log::endl;
-
     loadItems();
-    getLog() << "->loaded items" << Log::endl;
 
     file.seek(file.tell() + 8192); // Skip Light map, only for 8bit coloring
 
     loadCinematicFrames();
-    getLog() << "->loaded cinematic frames" << Log::endl;
-
     loadDemoData();
-    getLog() << "->loaded demo data" << Log::endl;
-
     loadSoundMap();
-    getLog() << "->loaded sound map" << Log::endl;
-
     loadSoundDetails();
-    getLog() << "->loaded sound details" << Log::endl;
-
     loadSampleIndices();
-    getLog() << "->loaded sample indices" << Log::endl;
 
     return 0;
 }
 
 void LoaderTR2::loadRooms() {
     uint16_t numRooms = file.readU16();
+
     for (unsigned int i = 0; i < numRooms; i++) {
         // Room Header
         int32_t xOffset = file.read32();
             // 0x0010 - Normal?
             uint16_t attributes = file.readU16();
 
-            int16_t lighting2; // Almost always equal to lighting1
+            int16_t lighting2 = file.read16(); // Almost always equal to lighting1
 
             // TODO store vertex somewhere
         }
             int16_t xCorner3 = file.read16();
             int16_t yCorner3 = file.read16();
             int16_t zCorner3 = file.read16();
+            int16_t xCorner4 = file.read16();
+            int16_t yCorner4 = file.read16();
+            int16_t zCorner4 = file.read16();
 
             // TODO store portals somewhere
         }
     // only afterward we can read the number of meshes
     // in this data block
     uint32_t numMeshData = file.readU32();
-
     std::vector<uint16_t> buffer;
     for (unsigned int i = 0; i < numMeshData; i++) {
         buffer.push_back(file.readU16());
         uint16_t nextFrame = file.readU16();
         uint16_t numStateChanges = file.readU16();
         uint16_t stateChangeOffset = file.readU16(); // Index into StateChanges[]
-        uint16_t numAnimCommands; // How many animation commands to use
-        uint16_t animCommandOffset; // Index into AnimCommand[]
+        uint16_t numAnimCommands = file.readU16(); // How many animation commands to use
+        uint16_t animCommandOffset = file.readU16(); // Index into AnimCommand[]
 
         // TODO store animations somewhere
     }
         // reading the stack but not changing it
         uint32_t flags = file.readU32();
 
+
         // Offset of mesh origin from the parent mesh origin
+
+        /* Where the hell does this come from?!
         int32_t x = file.read32();
         int32_t y = file.read32();
         int32_t z = file.read32();
+        */
 
         // TODO store mesh trees somewhere
     }

src/utils/binary.cpp

 
 uint8_t BinaryFile::readU8() {
     assert(file.is_open());
+    assert(file.good());
     uint8_t ret;
     char *c = reinterpret_cast<char *>(&ret);
     file.read(c, 1);
 
 uint16_t BinaryFile::readU16() {
     assert(file.is_open());
+    assert(file.good());
     uint8_t a = readU8();
     uint8_t b = readU8();
     return ((uint16_t)a | (uint16_t)(b << 8));
 
 uint32_t BinaryFile::readU32() {
     assert(file.is_open());
+    assert(file.good());
     uint16_t a = readU16();
     uint16_t b = readU16();
     return ((uint32_t)a | (uint32_t)(b << 16));
 
 uint64_t BinaryFile::readU64() {
     assert(file.is_open());
+    assert(file.good());
     uint32_t a = readU32();
     uint32_t b = readU32();
     return ((uint64_t)a | ((uint64_t)b << 32));
 
 float BinaryFile::readFloat() {
     assert(file.is_open());
+    assert(file.good());
     uint32_t val = readU32();
     char *a = reinterpret_cast<char *>(&val);
 
 
 int8_t BinaryFile::read8() {
     assert(file.is_open());
+    assert(file.good());
     int8_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 
 int16_t BinaryFile::read16() {
     assert(file.is_open());
+    assert(file.good());
     int16_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 
 int32_t BinaryFile::read32() {
     assert(file.is_open());
+    assert(file.good());
     int32_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));
 
 int64_t BinaryFile::read64() {
     assert(file.is_open());
+    assert(file.good());
     int64_t ret;
     char *p = reinterpret_cast<char *>(&ret);
     file.read(p, sizeof(ret));

test/CMakeLists.txt

 
 #################################################################
 
+add_executable (tester_loader EXCLUDE_FROM_ALL
+    "Loader.cpp" "../src/utils/binary.cpp"
+    "../src/loader/Loader.cpp" "../src/loader/LoaderTR1.cpp"
+    "../src/loader/LoaderTR2.cpp" "../src/loader/LoaderTR3.cpp"
+)
+add_dependencies (check tester_loader)
+add_test (NAME test_loader COMMAND tester_loader)
+
+#################################################################
+
 add_executable (tester_script EXCLUDE_FROM_ALL
     "Script.cpp" "../src/Script.cpp" "../src/main.cpp"
     "../src/utils/binary.cpp" "../src/Exception.cpp"

test/Loader.cpp

+/*!
+ * \file test/Loader.cpp
+ * \brief Level Loader Unit Test
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "loader/Loader.h"
+
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+        std::cout << "Usage:" << std::endl;
+        std::cout << "\t" << argv[0] << " /path/to/level.tr2" << std::endl;
+        return 0; // Don't fail when just running this test...
+    }
+
+    // Print file engine version
+    std::cout << "Loading \"" << argv[1] << "\"" << std::endl;
+    std::cout << "Trying to detect engine version... ";
+    Loader::LoaderVersion v = Loader::checkFile(argv[1]);
+    switch (v) {
+        case Loader::TR_1:
+            std::cout << "TR 1";
+            break;
+
+        case Loader::TR_2:
+            std::cout << "TR 2";
+            break;
+
+        case Loader::TR_3:
+            std::cout << "TR 3";
+            break;
+
+        case Loader::TR_4:
+            std::cout << "TR 4";
+            break;
+
+        case Loader::TR_5:
+            std::cout << "TR 5";
+            break;
+
+        case Loader::TR_UNKNOWN:
+            std::cout << "Unknown version!" << std::endl;
+            return 2;
+    }
+    std::cout << " detected!" << std::endl;
+
+    // Create matching loader
+    std::cout << std::endl << "Creating level loader... ";
+    std::unique_ptr<Loader> loader = Loader::createLoader(argv[1]);
+    if (!loader) {
+        std::cout << "Failed!" << std::endl;
+        return 3;
+    } else {
+        std::cout << "Success!" << std::endl;
+    }
+
+    // Try to load the level
+    std::cout << "Trying to load level... ";
+    int error = loader->load(argv[1]);
+    if (error != 0) {
+        std::cout << "Failure!" << std::endl;
+        std::cout << "Error code: " << error << std::endl;
+    } else {
+        std::cout << "Success!" << std::endl;
+    }
+
+    return error;
+}
+