Changeset 1638 for code/branches/gui/src/orxonox/Settings.h

Timestamp:

Jul 20, 2008, 7:49:26 PM (16 years ago)

Author:

rgrieder

Message:

merged input branch into gui test branch (was about time)
svn save (it's still a mess and CMLs haven't been updated)
I'll have to create a special project to create the tolua_bind files for tolua itself anyway..

Location:

code/branches/gui

Files:

• . (modified) (1 prop)
• src/orxonox/Settings.h (modified) (2 diffs)

code/branches/gui/src/orxonox/Settings.h

@@ -29 +29 @@
 /**
     @file Core.h
-    @brief Definition of the Settings class.
+    @brief Declaration of the Settings class.
 
     The static Settings class is only used to configure some variables
@@ -41 +41 @@
 #include <string>
 #include "core/OrxonoxClass.h"
+#include "core/Debug.h"
+#include "util/MultiTypeMath.h"
+#include "util/Convert.h"
 
 namespace orxonox
 {
-  class _OrxonoxExport Settings : public OrxonoxClass
-  {
+    /**
+    @brief
+        Defines a bit field structure that holds the mode as enum plus
+        the attributes as single named bits.
+        Every different GameMode is stored as static const, but if you wish to
+        compare two modes, you will have to use the 'mode' member variable.
+    */
+    struct GameMode
+    {
+        enum Mode
+        {
+            None,
+            Unspecified,
+            Server,
+            Client,
+            Standalone,
+            Dedicated,
+        };
+
+        Mode mode;
+        bool showsGraphics;
+        bool isMaster;
+        bool hasServer;
+        std::string name;
+
+        static const GameMode GM_None;
+        static const GameMode GM_Unspecified;
+        static const GameMode GM_Server;
+        static const GameMode GM_Client;
+        static const GameMode GM_Standalone;
+        static const GameMode GM_Dedicated;
+    };
+
+
+    class _OrxonoxExport Settings : public OrxonoxClass
+    {
     public:
-      void setConfigValues();
+        struct CommandLineArgument
+        {
+            std::string name_;
+            MultiTypeMath value_;
+            bool bHasDefaultValue_;
+        };
 
-      static const std::string& getDataPath();
+        void setConfigValues();
 
-      static void tsetDataPath(const std::string& path);
+        static const std::string& getDataPath();
+        static void tsetDataPath(const std::string& path);
+
+        static const GameMode& getGameMode();
+        static const GameMode& getGameMode(const std::string& name);
+        static void setGameMode(const GameMode& mode);
+        static void setGameMode(const std::string& mode);
+        static bool addGameMode(const GameMode* mode);
+
+        static const CommandLineArgument* getCommandLineArgument(const std::string& name);
+        template <class T>
+        static bool addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue);
 
     private:
-      Settings();
-      Settings(const Settings& instance);
-      ~Settings();
-      static Settings& getSingleton();
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { }
+        static Settings& getInstance();
 
-      void _tsetDataPath(const std::string& path);
+        void _tsetDataPath(const std::string& path);
 
-      std::string dataPath_;               //!< Path to the game data
-  };
+        std::string dataPath_;                                        //!< Path to the game data
+        GameMode gameMode_;                                           //!< Current game mode
+        std::map<std::string, const GameMode*> gameModes_;            //!< Holds all game modes for easy string access
+        //! holds all command line arguments (even if not given!)
+        std::map<std::string, CommandLineArgument> commandArguments_;
+    };
+
+    /**
+    @brief
+        Returns the relative path to the game data.
+    */
+    inline const std::string& Settings::getDataPath()
+    {
+        return getInstance().dataPath_;
+    }
+
+    inline void Settings::tsetDataPath(const std::string& path)
+    {
+        getInstance()._tsetDataPath(path);
+    }
+
+    inline const GameMode& Settings::getGameMode()
+    {
+        return getInstance().gameMode_;
+    }
+
+    inline const GameMode& Settings::getGameMode(const std::string& name)
+    {
+        if (getInstance().gameModes_.find(name) != getInstance().gameModes_.end())
+            return *getInstance().gameModes_[name];
+        else
+        {
+            COUT(2) << "Warning: GameMode '" << name << "' doesn't exist." << std::endl;
+            return GameMode::GM_None;
+        }
+    }
+
+    inline void Settings::setGameMode(const GameMode& mode)
+    {
+        getInstance().gameMode_ = mode;
+    }
+
+    /**
+    @brief
+        Adds one argument of the command line to the map of command line arguments.
+    @param name
+        Name of the command line option.
+    @param valueStr
+        The value of the command line option as string
+    @param defaultValue
+        Default value for the option (marked when used).
+    @return
+        Dummy return value to enable code execution before main().
+    */
+    template <class T>
+    bool Settings::addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue)
+    {
+        T value;
+        bool useDefault = false;
+        if (valueStr == "")
+        {
+            // note: ArgReader only returns "" for not found arguments, " " otherwise for empty ones.
+            value = defaultValue;
+            useDefault = true;
+        }
+        else if (!convertValue(&value, valueStr))
+        {
+            COUT(1) << "Command Line: Couldn't read option '" << name << "'." << std::endl;
+            return false;
+        }
+        CommandLineArgument arg = { name, MultiTypeMath(value), useDefault };
+        getInstance().commandArguments_[name] = arg;
+        return true;
+    }
 }