Changeset 1663 for code/branches/gui/src

Timestamp:

Aug 20, 2008, 10:30:28 PM (16 years ago)

Author:

rgrieder

Message:

Added CommandLine class.
You can now call SetCommandLineArgument like SetConsoleCommand and hereby define a new command line argument. They are passed in main() and then they can be accessed by commandLine::getCommandLineArgument().

Location:

code/branches/gui/src

Files:

• core/CommandLine.cc (added)
• core/CommandLine.h (added)
• core/CorePrereqs.h (modified) (1 diff)
• core/Exception.h (modified) (4 diffs)
• orxonox/Main.cc (modified) (4 diffs)
• orxonox/Orxonox.cc (modified) (10 diffs)
• orxonox/Orxonox.h (modified) (2 diffs)
• orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• orxonox/Settings.cc (modified) (3 diffs)
• orxonox/Settings.h (modified) (1 diff)
• orxonox/gamestates/GSLevel.cc (modified) (2 diffs)
• orxonox/gamestates/GSRoot.cc (modified) (4 diffs)
• orxonox/gamestates/GSRoot.h (modified) (1 diff)

code/branches/gui/src/core/CorePrereqs.h

@@ -102 +102 @@
   class CommandEvaluation;
   class CommandExecutor;
+  class CommandLine;
+  class BaseCommandLineArgument;
+  template <class T>
+  class CommandLineArgument;
   class ConfigFile;
   class ConfigFileEntry;

code/branches/gui/src/core/Exception.h

@@ -59 +59 @@
             General,
             FileNotFound,
+            Argument,
             PluginsNotFound,
             InitialisationFailed,
@@ -119 +120 @@
             RETURN_EXCEPTION_CODE(General)
             RETURN_EXCEPTION_CODE(FileNotFound);
+            RETURN_EXCEPTION_CODE(Argument);
             RETURN_EXCEPTION_CODE(PluginsNotFound);
             RETURN_EXCEPTION_CODE(InitialisationFailed);
@@ -132 +134 @@
     CREATE_ORXONOX_EXCEPTION(General);
     CREATE_ORXONOX_EXCEPTION(FileNotFound);
+    CREATE_ORXONOX_EXCEPTION(Argument);
     CREATE_ORXONOX_EXCEPTION(PluginsNotFound);
     CREATE_ORXONOX_EXCEPTION(InitialisationFailed);
@@ -142 +145 @@
     // define an assert macro that can display a message
 #ifndef NDEBUG
-#define OrxAssert(condition, errorMessage) \
-    condition ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream().setOutputLevel(ORX_ERROR) << errorMessage << std::endl); \
-    assert(condition)
+#define OrxAssert(assertion, errorMessage) \
+    assertion ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream().setOutputLevel(ORX_ERROR) << errorMessage << std::endl); \
+    assert(assertion)
 #else
 #define OrxAssert(condition, errorMessage)  ((void)0)

code/branches/gui/src/orxonox/Main.cc

@@ -39 +39 @@
 
 #include "util/OrxonoxPlatform.h"
-#include "util/ArgReader.h"
 #include "core/SignalHandler.h"
 #include "core/Debug.h"
-#include "network/ClientConnection.h"
-#include "Settings.h"
-#include "Orxonox.h"
+#include "core/CommandLine.h"
+//#include "Orxonox.h"
 
 #include "gamestates/GSRoot.h"
@@ -80 +78 @@
 #endif
 
-bool parseCommandLine(int argc, char** argv)
-{
-    ArgReader args;
-    std::string errorStr = args.parse(argc, argv);
-    if (errorStr != "")
-    {
-        COUT(1) << "Command Line: Parsing failed.\n" << errorStr << std::endl;
-        return false;
-    }
-
-    // Argument reader parses the command line to check syntax.
-    // Settings Singleton then stores the arguments. It always
-    // expects a default value.
-    bool success = true;
-    success &= Settings::addCommandLineArgument<std::string>
-        ("mode",     args.getArgument("mode"),     "standalone");
-    success &= Settings::addCommandLineArgument<std::string>
-        ("dataPath", args.getArgument("dataPath"), "./");
-    success &= Settings::addCommandLineArgument<std::string>
-        ("ip",       args.getArgument("ip"),       "127.0.0.0");
-    success &= Settings::addCommandLineArgument<int>
-        ("port",     args.getArgument("port"),     NETWORK_PORT);
-
-    if (!success)
-        return false;
-
-    if (!args.allChecked())
-    {
-        COUT(1) << "Command Line: Parsing failed.\nNot all arguments were matched." << std::endl;
-        return false;
-    }
-
-    return true;
-}
-
-#include "core/GameState.h"
 
 #ifdef __cplusplus
@@ -123 +85 @@
 int main(int argc, char** argv)
 {
+    try
+    {
+        orxonox::CommandLine::parse(argc, argv);
+    }
+    catch (orxonox::ArgumentException& ex)
+    {
+        COUT(1) << ex.what() << std::endl;
+        COUT(0) << "Usage:" << std::endl << "orxonox [--mode client|server|dedicated|standalone] "
+                << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
+    }
+
+
     // create a signal handler (only works for linux)
     SignalHandler::getInstance()->doCatch(argv[0], "orxonox.log");
 
-    if (!parseCommandLine(argc, argv))
-    {
-        COUT(0) << "Usage:" << std::endl << "orxonox [--mode client|server|dedicated|standalone] "
-                << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
-        return 0;
-    }
 
 
@@ -181 +149 @@
 
 
-    Orxonox orxonoxInstance;
+    //Orxonox orxonoxInstance;
 
     try

code/branches/gui/src/orxonox/Orxonox.cc

@@ -108 +108 @@
     , bAbort_(false)
     , timefactor_(1.0f)
-    , mode_(GameMode::GM_Unspecified)
     , debugRefreshTime_(0.0f)
     , graphicsEngine_(0)
@@ -119 +118 @@
 
     //assert(singletonRef_s == 0);
-    OrxAssert(singletonRef_s == 0, "asdfasdfasdfasdfblahblah");
+    OrxAssert(singletonRef_s == 0, "Cannot instantiate Orxonox class twice");
     singletonRef_s = this;
   }
@@ -229 +228 @@
         setConfigValues();
 
-        const Settings::CommandLineArgument* mode = Settings::getCommandLineArgument("mode");
-        assert(mode);
-        if (!mode->bHasDefaultValue_)
-        {
-            Settings::setGameMode(mode->value_);
-            this->mode_ = Settings::getGameMode();
-        }
-        COUT(3) << "Orxonox: Game mode is " << mode_.name << "." << std::endl;
-
-        const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
-        assert(dataPath);
-        if (!dataPath->bHasDefaultValue_)
-        {
-            if (*dataPath->value_.getString().end() != '/' && *dataPath->value_.getString().end() != '\\')
-                Settings::tsetDataPath(dataPath->value_.getString() + "/");
-            else
-                Settings::tsetDataPath(dataPath->value_.getString());
-        }
+        //const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
+        //assert(dataPath);
+        //if (!dataPath->bHasDefaultValue_)
+        //{
+        //    if (*dataPath->value_.getString().end() != '/' && *dataPath->value_.getString().end() != '\\')
+        //        Settings::tsetDataPath(dataPath->value_.getString() + "/");
+        //    else
+        //        Settings::tsetDataPath(dataPath->value_.getString());
+        //}
 
         try
@@ -256 +246 @@
             graphicsEngine_->setup();       // creates ogre root and other essentials
 
-            if (mode_.showsGraphics)
+            if (Settings::showsGraphics())
             {
                 graphicsEngine_->loadRenderer();    // creates the render window
@@ -286 +276 @@
                 // We probably want to use std::cin to catch input (OIS uses DirectX or X server)
             }
-
-            bool showGUI = true;
-            if (mode_.mode != GameMode::Unspecified)
-            {
-                showGUI = false;
-                // a game mode was specified with the command line
-                // we therefore load the game and level directly
-
-                if (!loadLevel(this->mode_))
-                {
-                    COUT(1) << "Loading with predefined mode failed. Showing main menu." << std::endl;
-                    showGUI = true;
-                    mode_ = GameMode::GM_Unspecified;
-                }
-            }
-
-            if (showGUI)
-            {
-                // show main menu
-                GUIManager::getInstance().showGUI("MainMenu", 0);
-                GraphicsEngine::getInstance().getViewport()->setCamera(GUIManager::getInstance().getCamera());
-            }
         }
         catch (std::exception& ex)
@@ -316 +284 @@
         }
 
-        modeRequest_ = mode_;
         // here happens the game
         startRenderLoop();
 
-        if (mode_.mode == GameMode::Client)
-            network::Client::getSingleton()->closeConnection();
-
-        if (mode_.hasServer)
-            server_g->close();
-    }
-
-    /*static*/ void Orxonox::loadGame(const std::string& name)
-    {
-        const GameMode& mode = Settings::getGameMode(name);
-        if (mode.mode == GameMode::None)
-            return;
-
-        getInstance().modeRequest_ = mode;
-    }
-
-    bool Orxonox::loadLevel(const GameMode& mode)
-    {
-        bool success = true;
-
-        if (mode.showsGraphics)
-        {
-            // create Ogre SceneManager for the level
-            graphicsEngine_->createNewScene();
-
-            if (!loadPlayground())
-                return false;
-        }
-
-        switch (mode.mode)
-        {
-        case GameMode::Server:
-            success &= serverLoad();
-            break;
-        case GameMode::Client:
-            success &= clientLoad();
-            break;
-        case GameMode::Dedicated:
-            success &= serverLoad();
-            break;
-        case GameMode::Standalone:
-            success &= standaloneLoad();
-            break;
-        default: // never happens
-            assert(false);
-        }
-
-        if (success)
-        {
-            InputManager::getInstance().requestEnterState("game");
-            this->mode_ = mode;
-        }
-
-        return success;
+        //if (mode_.mode == GameMode::Client)
+        //    network::Client::getSingleton()->closeConnection();
+
+        //if (mode_.hasServer)
+        //    server_g->close();
     }
 
@@ -408 +326 @@
     COUT(0) << "Loading level in server mode" << std::endl;
 
-    assert(Settings::getCommandLineArgument("port"));
-    int serverPort = Settings::getCommandLineArgument("port")->value_;
-    //server_g = new network::Server(serverPort_);
-    server_g = network::Server::createSingleton(serverPort);
+    //assert(Settings::getCommandLineArgument("port"));
+    //int serverPort = Settings::getCommandLineArgument("port")->value_;
+    ////server_g = new network::Server(serverPort_);
+    //server_g = network::Server::createSingleton(serverPort);
 
     if (!loadScene())
@@ -428 +346 @@
     COUT(0) << "Loading level in client mode" << std::endl;\
 
-    assert(Settings::getCommandLineArgument("port"));
-    assert(Settings::getCommandLineArgument("ip"));
-    int serverPort = Settings::getCommandLineArgument("port")->value_;
-    std::string serverIP = Settings::getCommandLineArgument("ip")->value_;
-
-    if (serverIP.compare("") == 0)
-      client_g = network::Client::createSingleton();
-    else
-      client_g = network::Client::createSingleton(serverIP, serverPort);
+    //assert(Settings::getCommandLineArgument("port"));
+    //assert(Settings::getCommandLineArgument("ip"));
+    //int serverPort = Settings::getCommandLineArgument("port")->value_;
+    //std::string serverIP = Settings::getCommandLineArgument("ip")->value_;
+
+    //if (serverIP.compare("") == 0)
+    //  client_g = network::Client::createSingleton();
+    //else
+    //  client_g = network::Client::createSingleton(serverIP, serverPort);
 
     if(!client_g->establishConnection())
@@ -504 +422 @@
         float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
 
-        // check whether we have to load a game
-        if (mode_.mode != modeRequest_.mode && mode_.mode == GameMode::Unspecified)
-        {
-            this->loadLevel(modeRequest_);
-            this->modeRequest_ = GameMode::GM_None;
-        }
-
 
         // tick the core (needs real time for input and tcl thread management)
@@ -552 +463 @@
         ogreRoot._fireFrameStarted(evt);
 
-        if (mode_.showsGraphics)
+        if (Settings::showsGraphics())
         {
           // Pump messages in all registered RenderWindows

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

@@ -74 +74 @@
       Orxonox(Orxonox& instance);
 
-      bool loadLevel(const GameMode& mode);
       bool serverLoad();
       bool clientLoad();
@@ -91 +90 @@
       float                 timefactor_;       //!< A factor to change the gamespeed
 
-      // this is used to identify the mode (server/client/...) we're in
-      GameMode              mode_;
-      GameMode              modeRequest_;
-
       // config values
       float                 debugRefreshTime_;

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

@@ -75 +75 @@
     class GraphicsEngine;
     class Orxonox;
+    class Settings;
 
     class RadarViewable;

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

@@ -42 +42 @@
 namespace orxonox
 {
-
-// Using a macro makes the above list much more readable.
-// Settings::addGameMode adds the mode in a map, so we can access game modes by string.
-#define CreateGameMode(name, showsGraphics, isMaster, hasServer)                                        \
-    const GameMode GameMode::GM_##name = { GameMode::name, showsGraphics, isMaster, hasServer, #name }; \
-    bool temporaryVariable##name = Settings::addGameMode(&GameMode::GM_##name)
-
-    //                          showsGraphics  isMaster  hasServer
-    CreateGameMode(None,        false,         false,    false);
-    CreateGameMode(Unspecified, true,          false,    false);
-    CreateGameMode(Server,      true,          true,     true );
-    CreateGameMode(Client,      true,          false,    false);
-    CreateGameMode(Standalone,  true,          true,     false);
-    CreateGameMode(Dedicated,   false,         true,     true );
+    Settings* Settings::singletonRef_s = 0;
 
     /**
@@ -62 +49 @@
     */
     Settings::Settings()
+        : bShowsGraphics_(false)
+        , bHasServer_(false)
     {
         RegisterRootObject(Settings);
-        gameMode_ = GameMode::GM_None;
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
         setConfigValues();
-    }
-
-    /**
-    @brief
-        Returns a unique instance of Core.
-    @return
-        The instance
-    */
-    Settings& Settings::getInstance()
-    {
-        static Settings instance;
-        return instance;
     }
 
@@ -110 +88 @@
     }
 
-    /**
-    @brief
-        Sets the game mode.
-    */
-    /*static*/ void Settings::setGameMode(const std::string& mode)
-    {
-        std::string modeL = getLowercase(mode);
-        std::map<std::string, const GameMode*>::const_iterator it = getInstance().gameModes_.find(modeL);
-        if (it != getInstance().gameModes_.end())
-            getInstance().gameMode_ = *(*it).second;
-        else
-        {
-            COUT(2) << "Warning: mode \"" << mode << "\" doesn't exist. "
-                    << "Defaulting to 'Standalone'" << std::endl;
-            getInstance().gameMode_ = GameMode::GM_Standalone;
-        }
-    }
-
-    /*static*/ bool Settings::addGameMode(const GameMode* mode)
-    {
-        getInstance().gameModes_[getLowercase(mode->name)] = mode;
-        return true;
-    }
-
-
-    /**
-    @brief
-        Gets an argument from the command line by name.
-    @return
-        Is 0 if name was not found.
-    */
-    /*static*/ const Settings::CommandLineArgument* Settings::getCommandLineArgument(const std::string &name)
-    {
-        std::map<std::string, CommandLineArgument>::const_iterator it = getInstance().commandArguments_.find(name);
-        if (it != getInstance().commandArguments_.end())
-        {
-            return &((*it).second);
-        }
-        else
-            return 0;
-    }
-
 }

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

@@ -47 +47 @@
 namespace orxonox
 {
-    /**
-    @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
+    class _OrxonoxExport Settings : public OrxonoxClass
     {
-        enum Mode
-        {
-            None,
-            Unspecified,
-            Server,
-            Client,
-            Standalone,
-            Dedicated,
-        };
+        friend class ClassIdentifier<Settings>;
+        friend class GSRoot;
 
-        Mode mode;
-        bool showsGraphics;
-        bool isMaster;
-        bool hasServer;
-        std::string name;
+    public:
+        static const std::string& getDataPath()
+        { assert(singletonRef_s); return singletonRef_s->dataPath_; }
+        static void tsetDataPath(const std::string& path)
+        { assert(singletonRef_s); singletonRef_s->_tsetDataPath(path); }
 
-        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;
-    };
+        // an alternative to a global game mode variable
+        static bool showsGraphics() { assert(singletonRef_s); return singletonRef_s->bShowsGraphics_; }
+        static bool hasServer()     { assert(singletonRef_s); return singletonRef_s->bHasServer_; }
 
 
-    class _OrxonoxExport Settings : public OrxonoxClass
-    {
-    public:
-        struct CommandLineArgument
-        {
-            std::string name_;
-            MultiTypeMath value_;
-            bool bHasDefaultValue_;
-        };
+    private:
+        // GSRoot has access to these
+        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; }
+        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; }
+
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { singletonRef_s = 0; }
+
+        static Settings& _getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+        void _tsetDataPath(const std::string& path);
 
         void setConfigValues();
 
-        static const std::string& getDataPath();
-        static void tsetDataPath(const std::string& path);
+        bool bShowsGraphics_;                                  //!< global variable that tells whether to show graphics
+        bool bHasServer_;                                      //!< global variable that tells whether this is a server
 
-        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);
+        std::string dataPath_;                                 //!< Path to the game data
 
-        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& getInstance();
-
-        void _tsetDataPath(const std::string& path);
-
-        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_;
+        static Settings* singletonRef_s;                       //!< Static pointer to the only instance.
     };
 
-    /**
-    @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;
-    }
 }
 

code/branches/gui/src/orxonox/gamestates/GSLevel.cc

@@ -35 +35 @@
 #include "core/input/KeyBinder.h"
 #include "core/Loader.h"
+#include "core/CommandLine.h"
 #include "overlays/console/InGameConsole.h"
 #include "gui/GUIManager.h"
@@ -45 +46 @@
 namespace orxonox
 {
+    SetCommandLineArgument(port, 55556).setShortcut("p");
+    SetCommandLineArgument(ip, std::string("127.0.0.0"));
+
     GSLevel::GSLevel()
         : GameState("level")

code/branches/gui/src/orxonox/gamestates/GSRoot.cc

@@ -38 +38 @@
 #include "core/TclBind.h"
 #include "core/Core.h"
+#include "core/CommandLine.h"
 #include "GraphicsEngine.h"
 #include "Settings.h"
@@ -43 +44 @@
 namespace orxonox
 {
+    SetCommandLineArgument(dataPath, std::string("./"));
+
     GSRoot::GSRoot()
         : GameState("root")
+        , settings_(0)
         , graphicsEngine_(0)
     {
@@ -64 +68 @@
         Factory::createClassHierarchy();
 
-        const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
-        assert(dataPath);
-        if (!dataPath->bHasDefaultValue_)
+        // instantiate Settings class
+        this->settings_ = new Settings();
+
+        const CommandLineArgument<std::string>* dataPath = CommandLine::getCommandLineArgument<std::string>("dataPath");
+        if (!dataPath->hasDefaultValue())
         {
-            if (*dataPath->value_.getString().end() != '/' && *dataPath->value_.getString().end() != '\\')
-                Settings::tsetDataPath(dataPath->value_.getString() + "/");
+            if (*dataPath->getValue().end() != '/' && *dataPath->getValue().end() != '\\')
+                Settings::tsetDataPath(dataPath->getValue() + "/");
             else
-                Settings::tsetDataPath(dataPath->value_.getString());
+                Settings::tsetDataPath(dataPath->getValue());
         }
 
@@ -89 +95 @@
     void GSRoot::leave()
     {
-        if (this->graphicsEngine_)
-            delete graphicsEngine_;
+        delete graphicsEngine_;
+
+        delete settings_;
     }
 

code/branches/gui/src/orxonox/gamestates/GSRoot.h

@@ -48 +48 @@
         void leave();
 
+        Settings*             settings_;
         GraphicsEngine*       graphicsEngine_;   //!< our dearest graphics engine <3
     };