Menu background now chosen randomly

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141230 ]
+    * Added random number generation utility
+    * Added file name searching utilities
+    * Finally made file name comparisons case-insensitive
+    * Splash screen now chosen randomly from all PCX images in pak folder
+
     [ 20141229 ]
     * Removed utils/png, utils/tga image readers
     * Included current stb_image, stb_image_write and stb_textedit

include/TextureManager.h

                        TextureStorage s = TextureStorage::GAME,
                        int slot = -1, bool filter = true);
 
-    int loadImage(const char* filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
+    int loadImage(std::string filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
 
     void addTile(TextureTile* t);
     int numTiles();
 
   private:
     std::vector<unsigned int>& getIds(TextureStorage s);
-    int loadPCX(const char* filename, TextureStorage s, int slot);
+    int loadPCX(std::string filename, TextureStorage s, int slot);
 
     std::vector<unsigned int> mTextureIdsGame;
     std::vector<unsigned int> mTextureIdsSystem;

include/utils/File.h

-/*!
- * \file include/utils/File.h
- * \brief Recursive file-system walking utilities
- *
- * \author xythobuz
- */
-
-#ifndef _UTILS_FILE_H_
-#define _UTILS_FILE_H_
-
-#include <string>
-
-class Folder;
-
-class File {
-  public:
-    File(std::string file);
-
-    std::string& getName();
-    std::string& getPath();
-
-  private:
-    std::string name;
-    std::string path;
-};
-
-#endif
-

include/utils/Folder.h

 #define _UTILS_FOLDER_H_
 
 #include "Exception.h"
-#include "utils/File.h"
 
 #include <functional>
 #include <memory>
 #include <string>
 #include <vector>
 
+class File {
+  public:
+    File(std::string file);
+
+    std::string& getName() { return name; }
+    std::string& getPath() { return path; }
+
+  private:
+    std::string name;
+    std::string path;
+};
+
 class Folder {
   public:
     Folder(std::string folder, bool listDotFiles = false);
 
-    std::string& getName();
-    std::string& getPath();
+    std::string& getName() { return name; }
+    std::string& getPath() { return path; }
 
     unsigned long fileCount();
     File& getFile(unsigned long i);
     Folder getParent();
 
     void executeRemoveFiles(std::function<bool (File& f)> func);
+    void findFilesEndingWith(std::vector<File>& found, std::string end, bool casesensitive = false);
 
     // Accessing a folder recursively
     // This treats all files in all subfolders as if they were in this folder
     void executeRemoveRecursiveFiles(std::function<bool (File& f)> func);
     std::string getRecursiveFileName(unsigned long i);
     File& getRecursiveFile(unsigned long i);
+    void findRecursiveFilesEndingWith(std::vector<File>& found, std::string end, bool casesensitive = false);
 
   private:
-
     void createFolderItems();
     int readFolderItems(std::vector<std::string>& foundFiles, std::vector<std::string>& foundFolders);
 

include/utils/random.h

+/*!
+ * \file include/utils/random.h
+ * \brief Random number generation
+ *
+ * \author xythobuz
+ */
+
+#ifndef _UTILS_RANDOM_H_
+#define _UTILS_RANDOM_H_
+
+int randomInteger(int max, int min = 0);
+
+#endif
+

include/utils/strings.h

 
 std::string expandHomeDirectory(std::string s);
 
-bool stringEndsWith(std::string s, std::string suffix);
+bool stringEndsWith(std::string s, std::string suffix, bool casesensitive = false);
 
 #endif
 

src/TextureManager.cpp

 #include "global.h"
 #include "Log.h"
 #include "RunTime.h"
+#include "utils/Folder.h"
 #include "utils/pcx.h"
 #include "utils/pixel.h"
+#include "utils/random.h"
 #include "utils/strings.h"
 #include "TextureManager.h"
 
         return -1;
     }
 
-    //! \fixme Temporary?
-    std::string filename = RunTime::getPakDir() + "/tr2/TITLE.PCX";
-    if (loadImage(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
-        filename = RunTime::getDataDir() + "/splash.tga";
-        if (loadImage(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
+    Folder f(RunTime::getPakDir());
+    std::vector<File> files;
+    f.findRecursiveFilesEndingWith(files, ".pcx");
+    if (files.size() == 0) {
+        if (loadImage(RunTime::getDataDir() + "/splash.tga", TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
             return -2;
         }
+    } else {
+        int i = randomInteger(files.size() - 1);
+        if (loadImage(files.at(i).getPath(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
+            if (loadImage(RunTime::getDataDir() + "/splash.tga", TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
+                return -3;
+            }
+        }
     }
 
     return 0;
     glBindTexture(GL_TEXTURE_2D, getIds(s).at(n));
 }
 
-int TextureManager::loadImage(const char* filename, TextureStorage s, int slot) {
+int TextureManager::loadImage(std::string filename, TextureStorage s, int slot) {
     //! \todo case insensitive compare
 
-    if (stringEndsWith(filename, ".pcx") || stringEndsWith(filename, ".PCX")) {
+    if (stringEndsWith(filename, ".pcx")) {
         return loadPCX(filename, s, slot);
     } else {
         int x, y, n;
-        unsigned char* data = stbi_load(filename, &x, &y, &n, 0);
+        unsigned char* data = stbi_load(filename.c_str(), &x, &y, &n, 0);
         if (data) {
             if ((n < 3) || (n > 4)) {
                 getLog() << "Image \"" << filename << "\" has unsupported format ("
     }
 }
 
-int TextureManager::loadPCX(const char* filename, TextureStorage s, int slot) {
-    assert(filename != nullptr);
-    assert(filename[0] != '\0');
-
-    int error = pcxCheck(filename);
+int TextureManager::loadPCX(std::string filename, TextureStorage s, int slot) {
+    int error = pcxCheck(filename.c_str());
     if (!error) {
         unsigned char* image;
         unsigned int w, h, bpp;
         ColorMode c;
 
-        error = pcxLoad(filename, &image, &w, &h, &c, &bpp);
+        error = pcxLoad(filename.c_str(), &image, &w, &h, &c, &bpp);
         if (!error) {
             unsigned char* image2 = scaleBuffer(image, &w, &h, bpp);
             if (image2) {

src/utils/CMakeLists.txt

 # Source files
 set (UTIL_SRCS ${UTIL_SRCS} "binary.cpp" "../../include/utils/binary.h")
-set (UTIL_SRCS ${UTIL_SRCS} "File.cpp" "../../include/utils/File.h")
 set (UTIL_SRCS ${UTIL_SRCS} "filesystem.cpp" "../../include/utils/filesystem.h")
 set (UTIL_SRCS ${UTIL_SRCS} "Folder.cpp" "../../include/utils/Folder.h")
 set (UTIL_SRCS ${UTIL_SRCS} "FolderRecursive.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "pcx.cpp" "../../include/utils/pcx.h")
 set (UTIL_SRCS ${UTIL_SRCS} "pixel.cpp" "../../include/utils/pixel.h")
+set (UTIL_SRCS ${UTIL_SRCS} "random.cpp" "../../include/utils/random.h")
 set (UTIL_SRCS ${UTIL_SRCS} "strings.cpp" "../../include/utils/strings.h")
 set (UTIL_SRCS ${UTIL_SRCS} "time.cpp" "../../include/utils/time.h")
 

src/utils/File.cpp

-/*!
- * \file src/utils/File.cpp
- * \brief Recursive file-system walking utilities
- *
- * \author xythobuz
- */
-
-#include <algorithm>
-
-#include "global.h"
-#include "utils/File.h"
-#include "utils/Folder.h"
-
-File::File(std::string file) : path(file) {
-    size_t pos = file.rfind('/', file.length() - 2);
-    name = file.substr(pos + 1);
-    std::transform(name.begin(), name.end(), name.begin(), ::tolower);
-}
-
-std::string& File::getName() {
-    return name;
-}
-
-std::string& File::getPath() {
-    return path;
-}
-

src/utils/Folder.cpp

 
 #include "global.h"
 #include "utils/filesystem.h"
-#include "utils/File.h"
+#include "utils/strings.h"
 #include "utils/Folder.h"
 
+File::File(std::string file) : path(file) {
+    size_t pos = file.rfind('/', file.length() - 2);
+    name = file.substr(pos + 1);
+    std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+}
+
+// ----------------------------------------------------------------------------
+
 #if defined(HAVE_DIRENT_H) && defined(HAVE_OPENDIR) && defined(HAVE_READDIR_R) && defined(HAVE_CLOSEDIR) && defined(HAVE_DT_DIR)
 #include <dirent.h>
 #define USE_DIRENT
     listDot = listDotFiles;
 }
 
-std::string& Folder::getName() {
-    return name;
-}
-
-std::string& Folder::getPath() {
-    return path;
-}
-
 unsigned long Folder::fileCount() {
     createFolderItems();
     return files.size();
 
 #endif
 
+void Folder::findFilesEndingWith(std::vector<File>& found, std::string end, bool casesensitive) {
+    createFolderItems();
+    for (auto& f : files) {
+        if (stringEndsWith(f.getName(), end, casesensitive))
+            found.push_back(f);
+    }
+}
+

src/utils/FolderRecursive.cpp

  */
 
 #include "global.h"
-#include "utils/File.h"
+#include "utils/strings.h"
 #include "utils/Folder.h"
 
 unsigned long Folder::countRecursiveFiles() {
     return files.at(0);
 }
 
+void Folder::findRecursiveFilesEndingWith(std::vector<File>& found, std::string end, bool casesensitive) {
+    createFolderItems();
+    for (unsigned long i = 0; i < countRecursiveFiles(); i++) {
+        if (stringEndsWith(getRecursiveFile(i).getName(), end, casesensitive)) {
+            found.push_back(getRecursiveFile(i));
+        }
+    }
+}
+

src/utils/random.cpp

+/*!
+ * \file src/utils/random.cpp
+ * \brief Random number generation
+ *
+ * \author xythobuz
+ */
+
+#include <chrono>
+#include <map>
+#include <random>
+#include <utility>
+
+#include "global.h"
+#include "utils/random.h"
+
+static std::map<int, std::uniform_int_distribution<int>> distributions;
+static std::default_random_engine engine;
+static bool engineIsSeeded = false;
+
+int randomInteger(int max, int min) {
+    if (max == min)
+        return max;
+
+    assert(max > min);
+
+    if (!engineIsSeeded) {
+        engine.seed(std::chrono::system_clock::now().time_since_epoch().count());
+        engineIsSeeded = true;
+    }
+
+    int range = max - min;
+    auto elem = distributions.find(range);
+    if (elem == distributions.end()) {
+        distributions[range] = std::uniform_int_distribution<int>(0, range);
+        return distributions[range](engine) + min;
+    } else {
+        return std::get<1>(*elem)(engine) + min;
+    }
+}
+

src/utils/strings.cpp

  * \author xythobuz
  */
 
+#include <algorithm>
+
 #include "global.h"
 #include "utils/filesystem.h"
 #include "utils/strings.h"
     return s;
 }
 
-bool stringEndsWith(std::string s, std::string suffix) {
+bool stringEndsWith(std::string s, std::string suffix, bool casesensitive) {
+    if (!casesensitive) {
+        std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+        std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
+    }
+
     if (s.length() >= suffix.length()) {
         std::string end = s.substr(s.length() - suffix.length());
         return (end == suffix);