Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 9, 2011, 11:27:05 AM (14 years ago)
Author:
dafrick
Message:

Merging latest changes in usability branch into tutorial branch.

Location:
code/branches/tutorial
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • code/branches/tutorial

  • code/branches/tutorial/src/libraries/core/CMakeLists.txt

    r7966 r8051  
    8080    Game.h
    8181    GameMode.h
     82    GraphicsManager.h
    8283    GUIManager.h
    8384    Loader.h

  • code/branches/tutorial/src/libraries/core/Core.cc

    r7872 r8051  
    208208#ifdef ORXONOX_RELEASE
    209209        const unsigned int defaultLevelLogFile = 3;
     210        SetConfigValue(bDevMode_, false)
     211            .description("Developer mode. If not set, hides some things from the user to not confuse him.");
    210212#else
    211213        const unsigned int defaultLevelLogFile = 4;
     214        SetConfigValue(bDevMode_, true)
     215            .description("Developer mode. If not set, hides some things from the user to not confuse him.");
    212216#endif
    213217        SetConfigValueExternal(softDebugLevelLogFile_, "OutputHandler", "softDebugLevelLogFile", defaultLevelLogFile)

  • code/branches/tutorial/src/libraries/core/Core.h

    r7870 r8051  
    9191                { return this->ogreConfigTimestamp_; }
    9292
     93            inline bool inDevMode(void) const
     94                { return this->bDevMode_; }
     95
    9396        private:
    9497            Core(const Core&); //!< Don't use (undefined symbol)
    … …  
    130133            long long                     lastLevelTimestamp_;         ///< Timestamp when the last level was started
    131134            long long                     ogreConfigTimestamp_;        ///< Timestamp wehen the ogre config level was modified
     135            bool                          bDevMode_;                   //!< Developers bit. If set to false, some options are not available as to not confuse the normal user.
    132136
    133137            static Core*                  singletonPtr_s;

  • code/branches/tutorial/src/libraries/core/GUIManager.cc

    r7994 r8051  
    103103    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen";
    104104
     105    static const std::string __CC_navigateGUI_name = "navigateGUI";
     106
    105107    SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
    106108    SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
     109    SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false);
     110    SetConsoleCommand(__CC_navigateGUI_name, &GUIManager::navigateGUI).deactivate();
     111
     112    //! Strings that specify modes for the GUI navigation.
     113    /*static*/ const std::string GUIManager::NAVIGATE_UP = "up";
     114    /*static*/ const std::string GUIManager::NAVIGATE_DOWN = "down";
     115    /*static*/ const std::string GUIManager::NAVIGATE_LEFT = "left";
     116    /*static*/ const std::string GUIManager::NAVIGATE_RIGHT = "right";
     117    /*static*/ const std::string GUIManager::NAVIGATE_ENTER = "enter";
    107118
    108119    /**
    … …  
    282293    {
    283294        GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
     295    }
     296
     297    /**
     298    @brief
     299        Toggles specified GUI.
     300        If the GUI with the input name is already shown and on the top, it is hidden, else it is shown.
     301    */
     302    /*static*/ void GUIManager::toggleGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
     303    {
     304        GUIManager::getInstance().executeCode("getGUIFirstActive(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
     305    }
     306
     307    /**
     308    @brief
     309        Helper method to toggle a specified GUI.
     310        Is called by lua.
     311    */
     312    void GUIManager::toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show)
     313    {
     314        if(show)
     315            GUIManager::showGUI(name, bHidePrevious, bNoInput);
     316        else
     317            GUIManager::hideGUI(name);
    284318    }
    285319
    … …  
    340374            this->rootWindow_->setProperty("Alpha", "1.0");
    341375        this->rootWindow_->setProperty("Image", image);
     376    }
     377
     378    /**
     379    @brief
     380        Method to navigate the GUI, by specifying the mode of navigation.
     381    @param mode
     382        The mode of navigation, at this point can be either 'up', 'down', 'left', 'right' or 'enter'.
     383    */
     384    /*static*/ void GUIManager::navigateGUI(const std::string& mode)
     385    {
     386        if(mode == NAVIGATE_UP)
     387            GUIManager::getInstance().executeCode("navigateGUI(\"" + NAVIGATE_UP + "\")");
     388        else if(mode == NAVIGATE_DOWN)
     389            GUIManager::getInstance().executeCode("navigateGUI(\"" + NAVIGATE_DOWN + "\")");
     390        else if(mode == NAVIGATE_LEFT)
     391            GUIManager::getInstance().executeCode("navigateGUI(\"" + NAVIGATE_LEFT + "\")");
     392        else if(mode == NAVIGATE_RIGHT)
     393            GUIManager::getInstance().executeCode("navigateGUI(\"" + NAVIGATE_RIGHT + "\")");
     394        else if(mode == NAVIGATE_ENTER)
     395            GUIManager::getInstance().executeCode("navigateGUI(\"" + NAVIGATE_ENTER + "\")");
     396    }
     397
     398    /**
     399    @brief
     400        Is called by lua to change whether there are any GUIs active at the moment.
     401    @param active
     402        Whether GUIs are active.
     403    */
     404    void GUIManager::guisActiveChanged(bool active)
     405    {
     406        if(this->GUIsActive_ == active)
     407            return;
     408        this->GUIsActive_ = active;
     409        if(this->GUIsActive_)
     410            ModifyConsoleCommand(__CC_navigateGUI_name).activate();
     411        else
     412            ModifyConsoleCommand(__CC_navigateGUI_name).deactivate();
    342413    }
    343414

  • code/branches/tutorial/src/libraries/core/GUIManager.h

    r7874 r8051  
    4949#include "util/Singleton.h"
    5050#include "input/InputHandler.h"
     51#include "Core.h"
    5152#include "OrxonoxClass.h"
    5253#include "WindowEventListener.h"
    … …  
    8889        void showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious = false, bool bNoInput = false);
    8990        static void hideGUI(const std::string& name);
     91        static void toggleGUI(const std::string& name, bool bHidePrevious = false, bool bNoInput = false);
     92        void toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show); // tolua_export
    9093        void keyESC();
    9194        void setBackgroundImage(const std::string& imageSet, const std::string imageName); // tolua_export
    9295        void setBackgroundImage(const std::string& image);
     96
     97        static void navigateGUI(const std::string& mode);
     98        void guisActiveChanged(bool active); // tolua_export
     99
     100        /**
     101        @brief Helper method to get the developer's mode without having to export Core.h.
     102        @see Core::inDevMode
     103        */
     104        static bool inDevMode(void) { return Core::getInstance().inDevMode(); } // tolua_export
    93105
    94106        //! Creates a new InputState to be used with a GUI Sheet
    … …  
    122134        template <typename FunctionType>
    123135        bool protectedCall(FunctionType function);
     136
     137        static const std::string NAVIGATE_UP;
     138        static const std::string NAVIGATE_DOWN;
     139        static const std::string NAVIGATE_LEFT;
     140        static const std::string NAVIGATE_RIGHT;
     141        static const std::string NAVIGATE_ENTER;
     142
     143        bool GUIsActive_; //!< Whether there are any GUIs active at a given moment.
    124144
    125145        // keyHandler functions

  • code/branches/tutorial/src/libraries/core/Game.cc

    r7993 r8051  
    6161    static void printFPS()
    6262        { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
    63     SetConsoleCommand("printFPS", &printFPS);
     63    SetConsoleCommand("Stats", "printFPS", &printFPS);
    6464    static void printTickTime()
    6565        { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
    66     SetConsoleCommand("printTickTime", &printTickTime);
     66    SetConsoleCommand("Stats", "printTickTime", &printTickTime);
    6767
    6868    std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;

  • code/branches/tutorial/src/libraries/core/GraphicsManager.cc

    r8008 r8051  
    480480    }
    481481
     482    unsigned int GraphicsManager::getWindowWidth() const
     483    {
     484        return this->renderWindow_->getWidth();
     485    }
     486
     487    unsigned int GraphicsManager::getWindowHeight() const
     488    {
     489        return this->renderWindow_->getHeight();
     490    }
     491
    482492    bool GraphicsManager::hasVSyncEnabled() const
    483493    {
    484494        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
    485         if (options.find("VSync") != options.end())
    486             return (options["VSync"].currentValue == "Yes");
     495        Ogre::ConfigOptionMap::iterator it = options.find("VSync");
     496        if (it != options.end())
     497            return (it->second.currentValue == "Yes");
    487498        else
    488499            return false;
    489500    }
    490501
     502    std::string GraphicsManager::getFSAAMode() const
     503    {
     504        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
     505        Ogre::ConfigOptionMap::iterator it = options.find("FSAA");
     506        if (it != options.end())
     507            return it->second.currentValue;
     508        else
     509            return "";
     510    }
     511
    491512    std::string GraphicsManager::setScreenResolution(unsigned int width, unsigned int height, bool fullscreen)
    492513    {
    493         this->ogreRoot_->getRenderSystem()->setConfigOption("Video Mode", multi_cast<std::string>(width) + " x " + multi_cast<std::string>(height) + " @ " + multi_cast<std::string>(this->getRenderWindow()->getColourDepth()) + "-bit colour");
     514        // workaround to detect if the colour depth should be written to the config file
     515        bool bWriteColourDepth = false;
     516        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
     517        Ogre::ConfigOptionMap::iterator it = options.find("Video Mode");
     518        if (it != options.end())
     519            bWriteColourDepth = (it->second.currentValue.find('@') != std::string::npos);
     520
     521        if (bWriteColourDepth)
     522        {
     523            this->ogreRoot_->getRenderSystem()->setConfigOption("Video Mode", multi_cast<std::string>(width)
     524                                                                    + " x " + multi_cast<std::string>(height)
     525                                                                    + " @ " + multi_cast<std::string>(this->getRenderWindow()->getColourDepth()) + "-bit colour");
     526        }
     527        else
     528        {
     529            this->ogreRoot_->getRenderSystem()->setConfigOption("Video Mode", multi_cast<std::string>(width)
     530                                                                    + " x " + multi_cast<std::string>(height));
     531        }
     532
    494533        this->ogreRoot_->getRenderSystem()->setConfigOption("Full Screen", fullscreen ? "Yes" : "No");
    495534

  • code/branches/tutorial/src/libraries/core/GraphicsManager.h

    r7995 r8051  
    5454#include "OrxonoxClass.h"
    5555
     56// tolua_begin
    5657namespace orxonox
    5758{
    … …  
    6061        Graphics engine manager class
    6162    */
    62     class _CoreExport GraphicsManager : public Singleton<GraphicsManager>, public OrxonoxClass, public Ogre::LogListener
    63     {
     63    class _CoreExport GraphicsManager
     64// tolua_end
     65        : public Singleton<GraphicsManager>, public OrxonoxClass, public Ogre::LogListener
     66    { // tolua_export
    6467        friend class Singleton<GraphicsManager>;
    6568    public:
    … …  
    7477        Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
    7578        size_t getRenderWindowHandle();
     79
     80// tolua_begin
     81        static GraphicsManager& getInstance() { return Singleton<GraphicsManager>::getInstance(); } // tolua_export
     82
    7683        bool isFullScreen() const;
     84        unsigned int getWindowWidth() const;
     85        unsigned int getWindowHeight() const;
     86
    7787        bool hasVSyncEnabled() const;
     88        std::string getFSAAMode() const;
     89// tolua_end
    7890
    7991        void upgradeToGraphics();
    … …  
    127139
    128140        static GraphicsManager* singletonPtr_s;        //!< Pointer to the Singleton
     141// tolua_begin
    129142    };
    130143}
     144// tolua_end
    131145
    132146#endif /* _GraphicsManager_H__ */

  • code/branches/tutorial/src/libraries/core/command/CommandEvaluation.h

    r7401 r8051  
    7070
    7171        @remarks execCommand_ and hintCommand_ can be different in this case: There are multiple
    72         commands avaliable, let's say "tcl", "tclexecute", and "tclquery". The user enters
    73         "tcl", which is already a valid command. Now execCommand_ points to the "tcl"-command,
    74         but hintCommand_ still points to the autocompletion command of CommandExecutor, because
    75         the auto-completion list must still return the three possible commands, "tcl tclexecute tclquery"
    76         because the user may want to execute "tclquery" and needs auto-completion.
     72        commands avaliable, let's say "tcl" and "TclThreadManager". The user enters "tcl", which
     73        is already a valid command. Now execCommand_ points to the "tcl"-command, but hintCommand_
     74        still points to the autocompletion command of CommandExecutor, because the auto-completion
     75        list must still return the two possible commands, "tcl TclThreadManager" because the user
     76        may want to write "TclThreadManager ..." and needs auto-completion.
    7777
    7878        @see See @ref CommandExecutorExample "this description" for an example.

  • code/branches/tutorial/src/libraries/core/command/ConsoleCommandCompilation.cc

    r7401 r8051  
    4646namespace orxonox
    4747{
    48     SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());
     48//    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
    4949    SetConsoleCommand("echo", echo);
    50     SetConsoleCommand("puts", puts);
    51 
    52     SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());
    53     SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());
    54     SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());
     50//    SetConsoleCommand("puts", puts);                                                    // disabled because we use the implementation in Tcl
     51
     52//    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());      // disabled because we use the implementation in Tcl
     53//    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
     54//    SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());    // disabled because we use the implementation in Tcl
    5555
    5656    SetConsoleCommand("calculate", calculate);

  • code/branches/tutorial/src/libraries/core/command/Shell.cc

    r7401 r8051  
    4646{
    4747    SetConsoleCommand("log",     OutputHandler::log    );
    48     SetConsoleCommand("error",   OutputHandler::error  );
    49     SetConsoleCommand("warning", OutputHandler::warning);
    50     SetConsoleCommand("info",    OutputHandler::info   );
    51     SetConsoleCommand("debug",   OutputHandler::debug  );
     48    SetConsoleCommand("error",   OutputHandler::error  ).hide();
     49    SetConsoleCommand("warning", OutputHandler::warning).hide();
     50    SetConsoleCommand("info",    OutputHandler::info   ).hide();
     51    SetConsoleCommand("debug",   OutputHandler::debug  ).hide();
    5252
    5353    unsigned int Shell::cacheSize_s;

  • code/branches/tutorial/src/libraries/core/command/TclBind.cc

    r7401 r8051  
    4545{
    4646    SetConsoleCommand("tcl", &TclBind::tcl);
    47     SetConsoleCommand("bgerror", &TclBind::bgerror);
     47    SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
    4848
    4949    TclBind* TclBind::singletonPtr_s = 0;
    … …  
    9191
    9292            this->interpreter_->def("::orxonox::query", TclBind::tcl_query, Tcl::variadic());
     93            this->interpreter_->def("::orxonox::execute", TclBind::tcl_execute, Tcl::variadic());
    9394            this->interpreter_->def("::orxonox::crossquery", TclThreadManager::tcl_crossquery, Tcl::variadic());
    94             this->interpreter_->def("execute", TclBind::tcl_execute, Tcl::variadic());
    9595            this->interpreter_->def("::orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
    9696
    9797            try
    9898            {
    99                 this->interpreter_->eval("proc query        {args}    { ::orxonox::query $args }");
     99                this->interpreter_->def("query", TclBind::tcl_query, Tcl::variadic());
     100                this->interpreter_->def("execute", TclBind::tcl_execute, Tcl::variadic());
    100101                this->interpreter_->eval("proc crossquery   {id args} { ::orxonox::crossquery 0 $id $args }");
    101                 this->interpreter_->eval("proc crossexecute {id args} { ::orxonox::crossquery 0 $id $args }");
     102                this->interpreter_->eval("proc crossexecute {id args} { ::orxonox::crossexecute 0 $id $args }");
    102103                this->interpreter_->eval("proc running      {}        { return 1 }");
    103104                this->interpreter_->eval("set id 0");
    … …  
    154155    {
    155156        COUT(4) << "Tcl_query: " << args.get() << std::endl;
    156 
     157        return TclBind::tcl_helper(args, true);
     158    }
     159
     160    /**
     161        @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
     162    */
     163    void TclBind::tcl_execute(Tcl::object const &args)
     164    {
     165        COUT(4) << "Tcl_execute: " << args.get() << std::endl;
     166        TclBind::tcl_helper(args, false);
     167    }
     168
     169    /**
     170        @brief Helper function, used by tcl_query() and tcl_execute().
     171    */
     172    std::string TclBind::tcl_helper(Tcl::object const &args, bool bQuery)
     173    {
    157174        const std::string& command = stripEnclosingBraces(args.get());
    158175
    159176        int error;
     177        std::string result;
     178
    160179        CommandEvaluation evaluation = CommandExecutor::evaluate(command);
    161         const std::string& result = evaluation.query(&error);
     180
     181        if (bQuery)
     182            result = evaluation.query(&error).getString();
     183        else
     184            error = evaluation.execute();
     185
    162186        switch (error)
    163187        {
    … …  
    175199
    176200    /**
    177         @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
    178     */
    179     void TclBind::tcl_execute(Tcl::object const &args)
    180     {
    181         COUT(4) << "Tcl_execute: " << args.get() << std::endl;
    182         const std::string& command = stripEnclosingBraces(args.get());
    183 
    184         if (CommandExecutor::execute(command, false))
    185         {
    186             COUT(1) << "Error: Can't execute command \"" << command << "\"!" << std::endl;
    187         }
    188     }
    189 
    190     /**
    191201        @brief Console command, executes Tcl code. Can be used to bind Tcl-commands to a key, because native
    192202        Tcl-commands can not be evaluated and are thus not supported by the key-binder.
    … …  
    198208            try
    199209            {
    200                 const std::string& output = TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
    201                 if (!output.empty())
    202                 {
    203                     COUT(0) << "tcl> " << output << std::endl;
    204                 }
    205                 return output;
     210                return TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
    206211            }
    207212            catch (Tcl::tcl_error const &e)
    208             {   COUT(1) << "tcl> Error: " << e.what() << std::endl;   }
     213            {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
    209214        }
    210215

  • code/branches/tutorial/src/libraries/core/command/TclBind.h

    r7401 r8051  
    126126            TclBind(const TclBind& other);      ///< Copy-constructor, not implemented
    127127
     128            static std::string tcl_helper(Tcl::object const &args, bool bQuery);
     129
    128130            Tcl::interpreter* interpreter_;     ///< The wrapped Tcl interpreter
    129131            std::string tclDataPath_;           ///< The path to the directory that contains the Orxonox-specific Tcl-files

  • code/branches/tutorial/src/libraries/core/command/TclThreadManager.cc

    r7401 r8051  
    5555    const float TCLTHREADMANAGER_MAX_CPU_USAGE = 0.50f;
    5656
    57     SetConsoleCommand("tclexecute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());
    58     SetConsoleCommand("tclquery",   &TclThreadManager::query  ).argumentCompleter(0, autocompletion::tclthreads());
    5957    SetConsoleCommand("TclThreadManager", "create",  &TclThreadManager::create);
    6058    SetConsoleCommand("TclThreadManager", "destroy", &TclThreadManager::destroy).argumentCompleter(0, autocompletion::tclthreads());

  • code/branches/tutorial/src/libraries/core/input/InputManager.cc

    r7874 r8051  
    641641        state->destroy();
    642642    }
     643
     644    bool InputManager::setMouseExclusive(const std::string& name, TriBool::Value value)
     645    {
     646        if (name == "empty")
     647        {
     648            COUT(2) << "InputManager: Changing the empty state is not allowed!" << std::endl;
     649            return false;
     650        }
     651        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
     652        if (it != statesByName_.end())
     653        {
     654            it->second->setMouseExclusive(value);
     655            return true;
     656        }
     657        return false;
     658    }
    643659}

  • code/branches/tutorial/src/libraries/core/input/InputManager.h

    r7874 r8051  
    163163        */
    164164        bool destroyState(const std::string& name); // tolua_export
     165        /**
     166        @brief
     167            Changes the mouse mode of an input state.
     168        @return
     169            True if the call was successful, fals if the name was not found
     170        */
     171        bool setMouseExclusive(const std::string& name, TriBool::Value value); // tolua_export
    165172
    166173        //-------------------------------

  • code/branches/tutorial/src/libraries/core/input/Keyboard.cc

    r6422 r8051  
    3636    {
    3737        // update modifiers
    38         if (arg.key == OIS::KC_RMENU    || arg.key == OIS::KC_LMENU)
    39             modifiers_ |= KeyboardModifier::Alt;   // alt key
    40         if (arg.key == OIS::KC_RCONTROL || arg.key == OIS::KC_LCONTROL)
    41             modifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
    42         if (arg.key == OIS::KC_RSHIFT   || arg.key == OIS::KC_LSHIFT)
    43             modifiers_ |= KeyboardModifier::Shift; // shift key
     38        switch (arg.key)
     39        {
     40            case OIS::KC_RMENU:
     41            case OIS::KC_LMENU:
     42                modifiers_ |= KeyboardModifier::Alt;   // alt key
     43                break;
     44            case OIS::KC_RCONTROL:
     45            case OIS::KC_LCONTROL:
     46                modifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
     47                break;
     48            case OIS::KC_RSHIFT:
     49            case OIS::KC_LSHIFT:
     50                modifiers_ |= KeyboardModifier::Shift; // shift key
     51                break;
     52            case OIS::KC_TAB:
     53                // Do not distribute the alt+tab event (messes with the operating system)
     54                if ((modifiers_ & KeyboardModifier::Alt) != 0)
     55                    return true;
     56            default:;
     57        }
    4458
    45         // Do not distribute the alt+tab event (messes with the operating system)
    46         if ((modifiers_ & KeyboardModifier::Alt) != 0 && arg.key == OIS::KC_TAB)
    47             return true;
    48 
    49         KeyEvent evt(arg);
     59        KeyEvent evt(static_cast<KeyCode::ByEnum>(arg.key), Keyboard::getKeyText(arg), 0);
    5060        super::buttonPressed(evt);
    5161        return true;
    … …  
    5666    {
    5767        // update modifiers
    58         if (arg.key == OIS::KC_RMENU    || arg.key == OIS::KC_LMENU)
    59             modifiers_ &= ~KeyboardModifier::Alt;   // alt key
    60         if (arg.key == OIS::KC_RCONTROL || arg.key == OIS::KC_LCONTROL)
    61             modifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
    62         if (arg.key == OIS::KC_RSHIFT   || arg.key == OIS::KC_LSHIFT)
    63             modifiers_ &= ~KeyboardModifier::Shift; // shift key
     68        switch (arg.key)
     69        {
     70            case OIS::KC_RMENU:
     71            case OIS::KC_LMENU:
     72                modifiers_ &= ~KeyboardModifier::Alt;   // alt key
     73                break;
     74            case OIS::KC_RCONTROL:
     75            case OIS::KC_LCONTROL:
     76                modifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
     77                break;
     78            case OIS::KC_RSHIFT:
     79            case OIS::KC_LSHIFT:
     80                modifiers_ &= ~KeyboardModifier::Shift; // shift key
     81                break;
     82            default:;
     83        }
    6484
    65         KeyEvent evt(arg);
     85        KeyEvent evt(static_cast<KeyCode::ByEnum>(arg.key), Keyboard::getKeyText(arg), 0);
    6686        super::buttonReleased(evt);
    6787        return true;
    6888    }
     89
     90    /// A map which returns the corresponding chars for some key codes
     91    unsigned int Keyboard::getKeyText(const OIS::KeyEvent& arg)
     92    {
     93        switch (arg.key)
     94        {
     95            case OIS::KC_NUMPAD0:     return static_cast<unsigned int>('0');
     96            case OIS::KC_NUMPAD1:     return static_cast<unsigned int>('1');
     97            case OIS::KC_NUMPAD2:     return static_cast<unsigned int>('2');
     98            case OIS::KC_NUMPAD3:     return static_cast<unsigned int>('3');
     99            case OIS::KC_NUMPAD4:     return static_cast<unsigned int>('4');
     100            case OIS::KC_NUMPAD5:     return static_cast<unsigned int>('5');
     101            case OIS::KC_NUMPAD6:     return static_cast<unsigned int>('6');
     102            case OIS::KC_NUMPAD7:     return static_cast<unsigned int>('7');
     103            case OIS::KC_NUMPAD8:     return static_cast<unsigned int>('8');
     104            case OIS::KC_NUMPAD9:     return static_cast<unsigned int>('9');
     105            case OIS::KC_DECIMAL:     return static_cast<unsigned int>('.');
     106            case OIS::KC_DIVIDE:      return static_cast<unsigned int>('/');
     107            case OIS::KC_NUMPADENTER: return static_cast<unsigned int>('\n');
     108            default:                  return arg.text;
     109        }
     110    }
    69111}

  • code/branches/tutorial/src/libraries/core/input/Keyboard.h

    r7809 r8051  
    8383        static std::string getClassNameImpl() { return "Keyboard"; }
    8484
     85        static unsigned int getKeyText(const OIS::KeyEvent& arg);
     86
    8587        //! Bit mask representing keyboard modifiers
    8688        int modifiers_;

  • code/branches/tutorial/src/libraries/network/Host.cc

    r7801 r8051  
    3838namespace orxonox {
    3939
     40  static const std::string __CC_printRTT_group = "Stats";
    4041  static const std::string __CC_printRTT_name = "printRTT";
    4142
    4243  SetConsoleCommand("chat", &Host::Chat);
    43   SetConsoleCommand(__CC_printRTT_name, &Host::printRTT);
     44  SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
    4445
    4546  // Host*               Host::instance_=0;
    … …  
    5556  //   assert(instance_==0);
    5657    instances_s.push_back(this);
    57     ModifyConsoleCommand(__CC_printRTT_name).setObject(this);
     58    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
    5859    this->bIsActive_ = false;
    5960  }
    … …  
    6768    assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
    6869    instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
    69     ModifyConsoleCommand(__CC_printRTT_name).setObject(0);
     70    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
    7071  }
    7172

  • code/branches/tutorial/src/libraries/tools/Shader.h

    r7976 r8051  
    3838#include <OgreCompositorInstance.h>
    3939
     40#include "util/MultiType.h"
    4041#include "util/OgreForwardRefs.h"
    4142#include "core/ViewportEventListener.h"

  • code/branches/tutorial/src/libraries/tools/Timer.cc

    r7401 r8051  
    3535
    3636#include <set>
     37
     38#include <boost/bimap.hpp>
    3739
    3840#include "util/Clock.h"
    … …  
    4143#include "core/command/CommandExecutor.h"
    4244#include "core/command/Functor.h"
     45#include "tools/interfaces/TimeFactorListener.h"
    4346
    4447namespace orxonox
    4548{
    4649    SetConsoleCommand("delay", &delay).argumentCompleter(1, autocompletion::command());
     50    SetConsoleCommand("delayreal", &delayreal).argumentCompleter(1, autocompletion::command());
     51    SetConsoleCommand("killdelay", &killdelay);
    4752    SetConsoleCommand("killdelays", &killdelays);
    4853
    49     static std::set<Timer*> delaytimerset;
    50 
    51     /**
    52         @brief Console-command: Calls another console command after @a delay seconds.
     54    static boost::bimap<unsigned int, Timer*> delaytimers;
     55    static unsigned int delayHandleCounter = 0;
     56
     57    /**
     58        @brief Console-command: Calls another console command after @a delay seconds (game time).
    5359        @param delay The delay in seconds
    5460        @param command The console command
    55     */
    56     void delay(float delay, const std::string& command)
    57     {
    58         Timer* delaytimer = new Timer();
    59         delaytimerset.insert(delaytimer);
     61        @return The handle of the delayed command, can be used as argument for killdelay()
     62    */
     63    unsigned int delay(float delay, const std::string& command)
     64    {
     65        return addDelayedCommand(new Timer(), delay, command);
     66    }
     67
     68    /**
     69        @brief Console-command: Calls another console command after @a delay seconds (real time)
     70        @param delay The delay in seconds
     71        @param command The console command
     72        @return The handle of the delayed command, can be used as argument for killdelay()
     73    */
     74    unsigned int delayreal(float delay, const std::string& command)
     75    {
     76        return addDelayedCommand(new RealTimer(), delay, command);
     77    }
     78
     79    /**
     80        @brief Helper function, used by delay() and delayreal() to add a delayed command.
     81        @param timer The timer which will execute the command
     82        @param delay The delay in seconds
     83        @param command The console command
     84        @return The handle of the delayed command, can be used as argument for killdelay()
     85    */
     86    unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command)
     87    {
     88        delaytimers.insert(boost::bimap<unsigned int, Timer*>::value_type(++delayHandleCounter, timer));
    6089
    6190        const ExecutorStaticPtr& delayexecutor = createExecutor(createFunctor(&executeDelayedCommand));
    62         delayexecutor->setDefaultValues(delaytimer, command);
    63         delaytimer->setTimer(delay, false, delayexecutor);
     91        delayexecutor->setDefaultValues(timer, command);
     92        timer->setTimer(delay, false, delayexecutor);
     93
     94        return delayHandleCounter;
    6495    }
    6596
    … …  
    73104        CommandExecutor::execute(command);
    74105        timer->destroy();
    75         delaytimerset.erase(timer);
     106        delaytimers.right.erase(timer);
    76107    }
    77108
    … …  
    81112    void killdelays()
    82113    {
    83         for (std::set<Timer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
    84             (*it)->destroy();
    85 
    86         delaytimerset.clear();
     114        for (boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.begin(); it != delaytimers.left.end(); ++it)
     115            it->second->destroy();
     116
     117        delaytimers.clear();
     118    }
     119
     120    /**
     121        @brief Console-command: Kills a delayed command with given handle.
     122    */
     123    void killdelay(unsigned int handle)
     124    {
     125        boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.find(handle);
     126        if (it != delaytimers.left.end())
     127        {
     128            it->second->destroy();
     129            delaytimers.left.erase(it);
     130        }
    87131    }
    88132
    … …  
    93137    {
    94138        this->init();
    95         RegisterObject(Timer);
     139        RegisterRootObject(Timer);
    96140    }
    97141
    … …  
    106150    {
    107151        this->init();
    108         RegisterObject(Timer);
     152        RegisterRootObject(Timer);
    109153
    110154        this->setTimer(interval, bLoop, executor, bKillAfterCall);
    … …  
    123167
    124168        this->time_ = 0;
     169    }
     170
     171    /**
     172        @brief Returns the current time factor of the game.
     173    */
     174    float Timer::getTimeFactor()
     175    {
     176        return TimeFactorListener::getTimeFactor();
    125177    }
    126178
    … …  
    168220        }
    169221    }
     222
     223    ///////////////
     224    // RealTimer //
     225    ///////////////
     226    /// @copydoc Timer::Timer
     227    RealTimer::RealTimer()
     228    {
     229        RegisterObject(RealTimer);
     230    }
     231
     232    /// @copydoc Timer::Timer(float, bool, const ExecutorPtr&, bool)
     233    RealTimer::RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall) : Timer(interval, bLoop, executor, bKillAfterCall)
     234    {
     235        RegisterObject(RealTimer);
     236    }
     237
     238    /// Returns always 1 because RealTimer doesn't depend on the game time.
     239    float RealTimer::getTimeFactor()
     240    {
     241        return 1;
     242    }
    170243}

  • code/branches/tutorial/src/libraries/tools/Timer.h

    r7851 r8051  
    8181#include "core/OrxonoxClass.h"
    8282#include "core/command/Executor.h"
    83 #include "tools/interfaces/TimeFactorListener.h"
    8483
    8584namespace orxonox
    8685{
    87     void delay(float delay, const std::string& command);
    88     void killdelays();
     86    unsigned int delay(float delay, const std::string& command);
     87    unsigned int delayreal(float delay, const std::string& command);
     88
     89    unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command);
    8990    void executeDelayedCommand(Timer* timer, const std::string& command);
    9091
     92    void killdelay(unsigned int handle);
     93    void killdelays();
     94
    9195    /**
    92         @brief Timer is a helper class that executes a function after a given amount of time.
     96        @brief Timer is a helper class that executes a function after a given amount of seconds in game-time.
    9397
    9498        @see See @ref TimerExample "Timer.h" for an example.
     99
     100        The time interval of Timer depends on the game time, hence it stops if the game is paused or runs
     101        slower/faster if the game-speed is modified. See RealTimer for a timer class which doesn't depend
     102        on the game time.
    95103    */
    96     class _ToolsExport Timer : public TimeFactorListener
     104    class _ToolsExport Timer : virtual public OrxonoxClass
    97105    {
    98106        public:
    … …  
    123131            void run();
    124132
    125             /// Re-starts the Timer: The executor will be called after @a interval seconds.
     133            /// Re-starts the timer: The executor will be called after @a interval seconds.
    126134            inline void startTimer()
    127135                { this->bActive_ = true; this->time_ = this->interval_; }
    128             /// Stops the Timer.
     136            /// Stops the timer.
    129137            inline void stopTimer()
    130138                { this->bActive_ = false; this->time_ = this->interval_; }
    131             /// Pauses the Timer - it will continue with the actual state if you call unpauseTimer().
     139            /// Pauses the timer - it will continue with the actual state if you call unpauseTimer().
    132140            inline void pauseTimer()
    133141                { this->bActive_ = false; }
    134             /// Unpauses the Timer - continues with the given state.
     142            /// Unpauses the timer - continues with the given state.
    135143            inline void unpauseTimer()
    136144                { this->bActive_ = true; }
    137             /// Returns true if the Timer is active (neither stopped nor paused).
     145            /// Returns true if the timer is active (neither stopped nor paused).
    138146            inline bool isActive() const
    139147                { return this->bActive_; }
    140             /// Returns the remaining time until the Timer calls the executor.
     148            /// Returns the remaining time until the timer calls the executor.
    141149            inline float getRemainingTime() const
    142150                { return static_cast<float>(this->time_ / 1000000.0f); }
    143             /// Increases the remaining time of the Timer by the given amount of time (in seconds).
     151            /// Increases the remaining time of the timer by the given amount of time (in seconds).
    144152            inline void addTime(float time)
    145153                { if (time > 0.0f) this->time_ += static_cast<long long>(time * 1000000.0f); }
    146             /// Decreases the remaining time of the Timer by the given amount of time (in seconds)
     154            /// Decreases the remaining time of the timer by the given amount of time (in seconds)
    147155            inline void removeTime(float time)
    148156                { if (time > 0.0f) this->time_ -= static_cast<long long>(time * 1000000.0f); }
    … …  
    156164            void tick(const Clock& time);
    157165
     166        protected:
     167            virtual float getTimeFactor();
     168
    158169        private:
    159170            void init();
    … …  
    163174            long long interval_;    //!< The time-interval in micro seconds
    164175            bool bLoop_;            //!< If true, the executor gets called every @a interval seconds
    165             bool bActive_;          //!< If true, the Timer ticks and calls the executor if the time's up
     176            bool bActive_;          //!< If true, the timer ticks and calls the executor if the time's up
    166177            bool bKillAfterCall_;   //!< If true the timer gets deleted after it expired and called the executor
    167178
    168179            long long time_;        //!< Internal variable, counting the time untill the next executor-call
    169180    };
     181
     182    /**
     183        @brief RealTimer is a helper class that executes a function after a given amount of seconds in real-time.
     184
     185        The time interval of RealTimer doesn't depend on the game time, it will also call the function
     186        if the game is paused. See Timer for a timer class that depends on the game time.
     187    */
     188    class _ToolsExport RealTimer : public Timer
     189    {
     190        public:
     191            RealTimer();
     192            RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall = false);
     193
     194        protected:
     195            virtual float getTimeFactor();
     196    };
    170197}
    171198

  • code/branches/tutorial/src/libraries/tools/ToolsPrereqs.h

    r7163 r8051  
    8585    class Mesh;
    8686    class ParticleInterface;
     87    class RealTimer;
    8788    class ResourceCollection;
    8889    class ResourceLocation;

  • code/branches/tutorial/src/orxonox/ChatInputHandler.cc

    r8000 r8051  
    2828
    2929#include "ChatInputHandler.h"
     30
     31#include <cassert>
     32#include <string>
     33#include <CEGUIWindow.h>
     34#include <CEGUIWindowManager.h>
     35#include <elements/CEGUIListbox.h>
     36#include <elements/CEGUIListboxItem.h>
     37#include <elements/CEGUIListboxTextItem.h>
     38
    3039#include "util/ScopedSingletonManager.h"
    3140#include "core/CoreIncludes.h"
    3241#include "core/GUIManager.h"
    33 #include "core/CorePrereqs.h"
    3442#include "core/command/ConsoleCommand.h"
    35 #include <CEGUIWindow.h>
    36 #include <elements/CEGUIListbox.h>
    37 #include <elements/CEGUIListboxItem.h>
    38 #include <elements/CEGUIListboxTextItem.h>
    39 #include <CEGUIWindowManager.h>
    40 #include <string>
     43#include "core/input/InputBuffer.h"
     44#include "core/input/InputManager.h"
     45#include "core/input/InputState.h"
     46#include "network/Host.h"
     47
     48#include "PlayerManager.h"
     49#include "infos/PlayerInfo.h"
    4150
    4251namespace orxonox

  • code/branches/tutorial/src/orxonox/ChatInputHandler.h

    r8000 r8051  
    3030#define _ChatInputHandler_H__
    3131
    32 /* std includes */
    33 #include <deque>
     32#include <OrxonoxPrereqs.h>
     33
    3434#include <string>
    35 #include <fstream>
    36 #include <iostream>
    37 #include <cassert>
    3835#include <CEGUIForwardRefs.h>
    3936#include <CEGUIcolour.h>
    4037
    41 /* project includes */
    42 #include <OrxonoxPrereqs.h>
    43 #include <core/BaseObject.h>
    44 #include <core/PathConfig.h>
    45 
    46 #include "core/input/InputBuffer.h"
    47 #include "core/input/InputManager.h"
    48 #include "core/input/InputState.h"
    49 
    50 #include <network/ChatListener.h>
    51 #include <PlayerManager.h>
    52 #include <infos/PlayerInfo.h>
    53 
    54 #include "../libraries/network/Host.h"
    55 #include <util/Singleton.h>
     38#include "util/Singleton.h"
     39#include "network/ChatListener.h"
    5640
    5741namespace orxonox // tolua_export

  • code/branches/tutorial/src/orxonox/LevelInfo.h

    r7804 r8051  
    109109            @return Returns the XML-filename (including *.oxw extension) of the Level.
    110110            */
    111             inline const std::string& getXMLFilename(void) { return this->xmlfilename_; } // tolua_export
     111            inline const std::string& getXMLFilename(void) const { return this->xmlfilename_; } // tolua_export
    112112
    113113        protected:
    … …  
    212212    {
    213213        bool operator() (const LevelInfoItem* lhs, const LevelInfoItem* rhs) const
    214             { return getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) < 0; }
     214            {
     215                if(getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) == 0)
     216                    return getLowercase(lhs->getXMLFilename()).compare(getLowercase(rhs->getXMLFilename())) < 0;
     217                return getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) < 0;
     218            }
    215219    };
    216220   

  • code/branches/tutorial/src/orxonox/LevelManager.cc

    r7999 r8051  
    251251        // Iterate over all the found *.oxw files
    252252        COUT(3) << "Loading LevelInfos..." << std::endl;
     253        std::set<std::string> names;
    253254        for (Ogre::StringVector::const_iterator it = levels->begin(); it != levels->end(); ++it)
    254255        {
    … …  
    277278                }
    278279
     280                // Warn about levels with the same name.
     281                if(!names.insert(info->getName()).second)
     282                    COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with name '" << info->getName() << "' found!" << std::endl;
     283
    279284                // Warn about multiple items so that it gets fixed quickly
    280285                if(availableLevels_.find(info) != availableLevels_.end())
    281286                {
    282                     COUT(2) << "Warning: Multiple levels with name '" << info->getName() << "' found!" << std::endl;
     287                    COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with same name '" << info->getName() << "' and filename found! Exluding..." << std::endl;
    283288                    // Delete LevelInfoItem to avoid a dangling pointer
    284289                    delete info;

  • code/branches/tutorial/src/orxonox/LevelManager.h

    r7804 r8051  
    112112            // Helpers to allow fast access to the availableLevels list.
    113113            unsigned int nextIndex_; //! The next expected index to be accessed.
    114             std::set<LevelInfoItem*, LevelInfoCompare>::iterator nextLevel_; //! The nex expected Level to be accessed.
     114            std::set<LevelInfoItem*, LevelInfoCompare>::iterator nextLevel_; //! The next expected Level to be accessed.
    115115
    116116            // config values

  • code/branches/tutorial/src/orxonox/gamestates/GSLevel.cc

    r7978 r8051  
    4646#include "LevelManager.h"
    4747#include "PlayerManager.h"
     48#include "GSRoot.h"
    4849
    4950namespace orxonox
    … …  
    156157        COUT(0) << "Loading level..." << std::endl;
    157158        startFile_ = new XMLFile(LevelManager::getInstance().getDefaultLevel());
    158         Loader::open(startFile_);
     159        bool loaded = Loader::open(startFile_);
    159160
    160161        Core::getInstance().updateLastLevelTimestamp();
     162        if(!loaded)
     163            GSRoot::delayedStartMainMenu();
    161164    }
    162165

  • code/branches/tutorial/src/orxonox/gamestates/GSMainMenu.cc

    r7978 r8051  
    6868        RegisterRootObject(GSMainMenu);
    6969
    70         InputManager::getInstance().createInputState("MainMenuHackery", true, true)->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
     70        InputManager::getInstance().createInputState("MainMenuHackery")->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
    7171
    7272        // create an empty Scene

  • code/branches/tutorial/src/orxonox/gamestates/GSRoot.cc

    r7935 r8051  
    3838#include "tools/interfaces/Tickable.h"
    3939
     40#include "GSLevel.h"
     41
    4042namespace orxonox
    4143{
    … …  
    4547    static const std::string __CC_setPause_name = "setPause";
    4648    static const std::string __CC_pause_name = "pause";
     49
     50    /*static*/ bool GSRoot::startMainMenu_s = false;
    4751
    4852    SetConsoleCommand("printObjects", &GSRoot::printObjects).hide();
    … …  
    98102    void GSRoot::update(const Clock& time)
    99103    {
     104        if(startMainMenu_s)
     105        {
     106            delayedStartMainMenu();
     107            startMainMenu_s = false;
     108        }
     109
    100110        for (ObjectList<Timer>::iterator it = ObjectList<Timer>::begin(); it; )
    101111        {
    … …  
    175185            callStaticNetworkFunction(&TimeFactorListener::setTimeFactor, CLIENTID_UNKNOWN, factor_new);
    176186    }
     187
     188    /*static*/ void GSRoot::delayedStartMainMenu(void)
     189    {
     190        if(!startMainMenu_s)
     191            startMainMenu_s = true;
     192        else
     193            GSLevel::startMainMenu();
     194    }
     195
    177196}

  • code/branches/tutorial/src/orxonox/gamestates/GSRoot.h

    r7935 r8051  
    5454        void pause();
    5555
     56        static void delayedStartMainMenu(void);
     57
    5658    protected:
    5759        virtual void changedTimeFactor(float factor_new, float factor_old);
    … …  
    6062        bool                  bPaused_;
    6163        float                 timeFactorPauseBackup_;
     64        static bool           startMainMenu_s;
    6265    };
    6366}

  • code/branches/tutorial/src/orxonox/gametypes/Gametype.cc

    r7801 r8051  
    3030
    3131#include "util/Math.h"
     32#include "core/Core.h"
    3233#include "core/CoreIncludes.h"
    3334#include "core/ConfigValueIncludes.h"
    … …  
    386387                    if (allplayersready && hashumanplayers)
    387388                    {
    388                         this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
     389                        // If in developer's mode, there is no start countdown.
     390                        if(Core::getInstance().inDevMode())
     391                            this->gtinfo_->startCountdown_ = 0;
     392                        else
     393                            this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
    389394                        this->gtinfo_->bStartCountdownRunning_ = true;
    390395                    }

  • code/branches/tutorial/src/orxonox/graphics/Model.cc

    r7183 r8051  
    6060    void Model::setConfigValues()
    6161    {
    62         SetConfigValueExternal(bGlobalEnableLod_, "GraphicsSettings", "enableModelLoD", true)
     62        SetConfigValueExternal(bGlobalEnableLod_, "GraphicsSettings", "enableMeshLoD", true)
    6363            .description("Enable level of detail for models");
    6464    }

  • code/branches/tutorial/src/orxonox/overlays/InGameConsole.cc

    r8015 r8051  
    4949#include "core/ConfigValueIncludes.h"
    5050#include "core/command/ConsoleCommand.h"
    51 #include "core/GUIManager.h"
    5251#include "core/input/InputManager.h"
    5352#include "core/input/InputState.h"
    … …  
    6059    const float CHAR_WIDTH = 7.45f; // fix this please - determine the char-width dynamically
    6160
    62     SetConsoleCommand("InGameConsole", "openConsole", &InGameConsole::openConsole).addShortcut();
    63     SetConsoleCommand("InGameConsole", "closeConsole", &InGameConsole::closeConsole).addShortcut();
     61    SetConsoleCommand("InGameConsole", "openConsole", &InGameConsole::openConsole);
     62    SetConsoleCommand("InGameConsole", "closeConsole", &InGameConsole::closeConsole);
    6463
    6564    ManageScopedSingleton(InGameConsole, ScopeID::Graphics, false);
    … …  
    534533        {
    535534            this->bActive_ = false;
    536             GUIManager::getInstance().getLuaState()->doString("inGameConsoleClosed()"); // Notify the SheetManager in lua, that the console has been closed.
    537535            InputManager::getInstance().leaveState("console");
    538536            this->shell_->unregisterListener(this);
    … …  
    611609    /*static*/ void InGameConsole::closeConsole()
    612610    {
    613         GUIManager::getInstance().getLuaState()->doString("inGameConsoleClosed()");  // Notify the SheetManager in lua, that the console has been closed, but not by ESC.
    614611        InGameConsole::getInstance().deactivate();
    615612    }
Note: See TracChangeset for help on using the changeset viewer.