Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10768 for code


Ignore:
Timestamp:
Nov 6, 2015, 10:54:34 PM (9 years ago)
Author:
landauf
Message:

replace '0' by 'nullptr'

Location:
code/branches/cpp11_v2
Files:
215 edited

Legend:

Unmodified
Added
Removed

  • code/branches/cpp11_v2/src/libraries/core/ApplicationPaths.cc

    r10765 r10768  
    6868
    6969    //! Static pointer to the singleton
    70     ApplicationPaths* ApplicationPaths::singletonPtr_s  = 0;
     70    ApplicationPaths* ApplicationPaths::singletonPtr_s  = nullptr;
    7171
    7272    ApplicationPaths::ApplicationPaths()

  • code/branches/cpp11_v2/src/libraries/core/BaseObject.cc

    r10765 r10768  
    6565        this->bRegisteredEventStates_ = false;
    6666
    67         this->lastLoadedXMLElement_ = 0;
    68 
    69         this->mainStateFunctor_ = 0;
     67        this->lastLoadedXMLElement_ = nullptr;
     68
     69        this->mainStateFunctor_ = nullptr;
    7070
    7171        if (context)
    … …  
    8686        else
    8787        {
    88             this->file_ = 0;
     88            this->file_ = nullptr;
    8989            this->sceneID_ = OBJECTID_UNKNOWN;
    9090        }
    … …  
    132132        XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
    133133
    134         Element* events = 0;
     134        Element* events = nullptr;
    135135        if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
    136136            events = xmlelement.FirstChildElement("events", false);
    … …  
    240240            i++;
    241241        }
    242         return 0;
     242        return nullptr;
    243243    }
    244244
    … …  
    278278            ++i;
    279279        }
    280         return 0;
     280        return nullptr;
    281281    }
    282282
    … …  
    302302            ++i;
    303303        }
    304         return 0;
     304        return nullptr;
    305305    }
    306306
    … …  
    331331            return (it->second);
    332332        else
    333             return 0;
     333            return nullptr;
    334334    }
    335335
    … …  
    423423    void BaseObject::changedMainStateName()
    424424    {
    425         this->mainStateFunctor_ = 0;
     425        this->mainStateFunctor_ = nullptr;
    426426
    427427        if (!this->mainStateName_.empty())

  • code/branches/cpp11_v2/src/libraries/core/BaseObject.h

    r10765 r10768  
    218218            bool                       bInitialized_;          //!< True if the object was initialized (passed the object registration)
    219219            const XMLFile*             file_;                  //!< The XMLFile that loaded this object
    220             Element*                   lastLoadedXMLElement_;  //!< Non 0 if the TinyXML attributes have already been copied to our own lowercase map
     220            Element*                   lastLoadedXMLElement_;  //!< Non nullptr if the TinyXML attributes have already been copied to our own lowercase map
    221221            std::map<std::string, std::string> xmlAttributes_; //!< Lowercase XML attributes
    222222            std::string                loaderIndentation_;     //!< Indentation of the debug output in the Loader

  • code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc

    r10624 r10768  
    207207            return ((*this->nodes_.top().first) == compare);
    208208        else
    209             return (compare == 0);
     209            return (compare == nullptr);
    210210    }
    211211
    … …  
    218218            return ((*this->nodes_.top().first) != compare);
    219219        else
    220             return (compare != 0);
     220            return (compare != nullptr);
    221221    }
    222222

  • code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.h

    r10693 r10768  
    211211            inline const ClassTreeMask& begin() const { return (*this); }
    212212            /// End of the ClassTreeMaskObjectIterator.
    213             inline BaseObject*          end()   const { return 0; }
     213            inline BaseObject*          end()   const { return nullptr; }
    214214
    215215            ClassTreeMask& operator=(const ClassTreeMask& other);
    … …  
    285285
    286286            /// Returns true if the ClassTreeMaskObjectIterator points at the given object.
    287             inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
     287            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == nullptr); }
    288288            /// Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object.
    289             inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
     289            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != nullptr); }
    290290            /// Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end.
    291291            inline operator bool() const { return (this->objectIterator_); }

  • code/branches/cpp11_v2/src/libraries/core/ConfigurablePaths.cc

    r10765 r10768  
    6767
    6868    //! Static pointer to the singleton
    69     ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = 0;
     69    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = nullptr;
    7070
    7171    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");

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

    r10765 r10768  
    8383{
    8484    //! Static pointer to the singleton
    85     Core* Core::singletonPtr_s  = 0;
     85    Core* Core::singletonPtr_s  = nullptr;
    8686
    8787    SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");

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

    r10765 r10768  
    248248    static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
    249249
    250     GUIManager* GUIManager::singletonPtr_s = 0;
     250    GUIManager* GUIManager::singletonPtr_s = nullptr;
    251251    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen"; //Alternative: Orxonox (not fully complete yet, see the graphics menu)
    252252
    … …  
    337337        // Create the CEGUI system singleton
    338338#ifdef ORXONOX_OLD_CEGUI
    339         guiSystem_ = new System(guiRenderer_, resourceProvider_, 0, scriptModule_);
     339        guiSystem_ = new System(guiRenderer_, resourceProvider_, nullptr, scriptModule_);
    340340        // Add functions that have been renamed in newer versions
    341341        luaState_->doString("CEGUI.SchemeManager.create = CEGUI.SchemeManager.loadScheme");
    … …  
    343343        luaState_->doString("CEGUI.ImagesetManager.createFromImageFile= CEGUI.ImagesetManager.createImagesetFromImageFile");
    344344#else
    345         guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
     345        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, nullptr, imageCodec_, scriptModule_);
    346346#endif
    347347
    … …  
    468468#ifdef ORXONOX_OLD_CEGUI
    469469        if (camera == nullptr)
    470             this->guiRenderer_->setTargetSceneManager(0);
     470            this->guiRenderer_->setTargetSceneManager(nullptr);
    471471        else
    472472            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());

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

    r9675 r10768  
    135135        inline void setPlayer(const std::string& guiname, PlayerInfo* player)
    136136            { this->players_[guiname] = player; }
    137         inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : 0; } // tolua_export
     137        inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : nullptr; } // tolua_export
    138138
    139139        // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work

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

    r10765 r10768  
    6666
    6767    std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
    68     Game* Game::singletonPtr_s = 0;
     68    Game* Game::singletonPtr_s = nullptr;
    6969
    7070    //! Represents one node of the game state tree.

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

    r10765 r10768  
    9393    };
    9494
    95     GraphicsManager* GraphicsManager::singletonPtr_s = 0;
     95    GraphicsManager* GraphicsManager::singletonPtr_s = nullptr;
    9696
    9797    RegisterAbstractClass(GraphicsManager).inheritsFrom<Configurable>();
    … …  
    9999    GraphicsManager::GraphicsManager(bool bLoadRenderer)
    100100        : ogreWindowEventListener_(new OgreWindowEventListener())
    101         , renderWindow_(0)
    102         , viewport_(0)
     101        , renderWindow_(nullptr)
     102        , viewport_(nullptr)
    103103        , lastFrameStartTime_(0.0f)
    104104        , lastFrameEndTime_(0.0f)
    … …  
    304304        //       But in our case we only have one viewport for now anyway, therefore
    305305        //       no ScopeGuards or anything to handle exceptions.
    306         this->viewport_ = this->renderWindow_->addViewport(0, 0);
     306        this->viewport_ = this->renderWindow_->addViewport(nullptr, 0);
    307307
    308308        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(Ogre::MIP_UNLIMITED);
    … …  
    312312        HWND hwnd;
    313313        this->renderWindow_->getCustomAttribute("WINDOW", (void*)&hwnd);
    314         LONG iconID = (LONG)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(101));
     314        LONG iconID = (LONG)LoadIcon(GetModuleHandle(nullptr), MAKEINTRESOURCE(101));
    315315        SetClassLong(hwnd, GCL_HICON, iconID);
    316316#endif

  • code/branches/cpp11_v2/src/libraries/core/Language.cc

    r10624 r10768  
    8888    // ###############################
    8989
    90     Language* Language::singletonPtr_s = 0;
     90    Language* Language::singletonPtr_s = nullptr;
    9191
    9292    /**

  • code/branches/cpp11_v2/src/libraries/core/Loader.cc

    r10765 r10768  
    4848namespace orxonox
    4949{
    50     Loader* Loader::singletonPtr_s = 0;
     50    Loader* Loader::singletonPtr_s = nullptr;
    5151
    5252    /**

  • code/branches/cpp11_v2/src/libraries/core/Namespace.cc

    r10624 r10768  
    109109    const BaseObject* Namespace::saveObjects(unsigned int index) const
    110110    {
    111         return 0; // todo
     111        return nullptr; // todo
    112112    }
    113113

  • code/branches/cpp11_v2/src/libraries/core/NamespaceNode.h

    r7401 r10768  
    4646    {
    4747        public:
    48             NamespaceNode(const std::string& name, NamespaceNode* parent = 0);
     48            NamespaceNode(const std::string& name, NamespaceNode* parent = nullptr);
    4949            ~NamespaceNode();
    5050

  • code/branches/cpp11_v2/src/libraries/core/Template.cc

    r9667 r10768  
    4949        this->bLoadDefaults_ = true;
    5050        this->bIsReturningXMLElement_ = false;
    51         this->baseclassIdentifier_ = 0;
     51        this->baseclassIdentifier_ = nullptr;
    5252    }
    5353
    … …  
    176176        {
    177177            orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
    178             return 0;
     178            return nullptr;
    179179        }
    180180    }

  • code/branches/cpp11_v2/src/libraries/core/Thread.cc

    r8399 r10768  
    4848
    4949    Thread::Thread():
    50         executor_(0),
     50        executor_(nullptr),
    5151        isWorking_(false),
    5252        stopThread_(false)
    … …  
    102102                (*executor)();
    103103                this->executorMutex_->lock();
    104                 this->executor_ = 0;
     104                this->executor_ = nullptr;
    105105                this->executorMutex_->unlock();
    106106                this->isWorkingMutex_->lock();

  • code/branches/cpp11_v2/src/libraries/core/ThreadWin.cc

    r8706 r10768  
    4545
    4646    Thread::Thread():
    47         executor_(0),
     47        executor_(nullptr),
    4848        isWorking_(false),
    4949        stopThread_(false)
    … …  
    101101//                 (*executor)();
    102102//                 this->executorMutex_->lock();
    103 //                 this->executor_ = 0;
     103//                 this->executor_ = nullptr;
    104104//                 this->executorMutex_->unlock();
    105105//                 this->isWorkingMutex_->lock();

  • code/branches/cpp11_v2/src/libraries/core/XMLPort.h

    r9667 r10768  
    245245            return my_added_objects[index];
    246246          else
    247             return 0;
     247            return nullptr;
    248248        }
    249249      @endcode
    … …  
    399399                            // Iterate through the attributes manually in order to make them case insensitive
    400400                            ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
    401                             while (attribute != 0)
     401                            while (attribute != nullptr)
    402402                            {
    403403                                this->owner_->xmlAttributes_[getLowercase(attribute->Name())] = attribute->Value();

  • code/branches/cpp11_v2/src/libraries/core/class/Identifiable.cc

    r10624 r10768  
    4848    Identifiable::Identifiable()
    4949    {
    50         this->identifier_ = 0;
     50        this->identifier_ = nullptr;
    5151        this->objectPointers_.reserve(6); // Optimisation
    5252

  • code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc

    r10624 r10768  
    117117            orxout(user_error) << "Aborting..." << endl;
    118118            abort();
    119             return 0;
     119            return nullptr;
    120120        }
    121121    }
    … …  
    393393            return it->second;
    394394        else
    395             return 0;
     395            return nullptr;
    396396    }
    397397
    … …  
    407407            return it->second;
    408408        else
    409             return 0;
     409            return nullptr;
    410410    }
    411411
    … …  
    438438            return it->second;
    439439        else
    440             return 0;
     440            return nullptr;
    441441    }
    442442

  • code/branches/cpp11_v2/src/libraries/core/class/Identifier.h

    r10765 r10768  
    5656    object->getIdentifier()->getName();                                         // returns "MyClass"
    5757
    58     Identifiable* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
     58    Identifiable* other = object->getIdentifier()->fabricate(nullptr);                // fabricates a new instance of MyClass
    5959
    6060
    … …  
    137137
    138138            /// Returns true if the Identifier has a Factory.
    139             inline bool hasFactory() const { return (this->factory_ != 0); }
     139            inline bool hasFactory() const { return (this->factory_ != nullptr); }
    140140
    141141            Identifiable* fabricate(Context* context);
    … …  
    297297
    298298            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
    299                 { return dynamic_cast<T*>(object) != 0; }
     299                { return dynamic_cast<T*>(object) != nullptr; }
    300300
    301301            virtual void destroyObjects();
    … …  
    408408    void ClassIdentifier<T>::destroyObjects()
    409409    {
    410         this->destroyObjects((T*)0);
     410        this->destroyObjects((T*)nullptr);
    411411    }
    412412

  • code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.cc

    r10765 r10768  
    4444namespace orxonox
    4545{
    46     IdentifierManager* IdentifierManager::singletonPtr_s = 0;
     46    IdentifierManager* IdentifierManager::singletonPtr_s = nullptr;
    4747
    4848    IdentifierManager::IdentifierManager()
    … …  
    221221            return it->second;
    222222        else
    223             return 0;
     223            return nullptr;
    224224    }
    225225
    … …  
    235235            return it->second;
    236236        else
    237             return 0;
     237            return nullptr;
    238238    }
    239239
    … …  
    249249            return it->second;
    250250        else
    251             return 0;
     251            return nullptr;
    252252    }
    253253
    … …  
    263263            if ((*it)->getTypeInfo() == typeInfo)
    264264                return (*it);
    265         return 0;
     265        return nullptr;
    266266    }
    267267

  • code/branches/cpp11_v2/src/libraries/core/class/SubclassIdentifier.h

    r10765 r10768  
    189189                    orxout(user_error) << "Aborting..." << endl;
    190190                    abort();
    191                     return 0;
     191                    return nullptr;
    192192                }
    193193            }

  • code/branches/cpp11_v2/src/libraries/core/class/Super.h

    r10624 r10768  
    9494            static void superCheck() \
    9595            { \
    96                 SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0)); \
     96                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr)); \
    9797                SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::superCheck(); \
    9898            } \
    … …  
    108108                    { \
    109109                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
    110                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0; \
     110                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr; \
    111111                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
    112112                    } \
    … …  
    154154                // This call to the apply-function is the whole check. By calling the function with
    155155                // a T* pointer, the right function get's called.
    156                 SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0));
     156                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr));
    157157
    158158                // Go go the superCheck for of next super-function (functionnumber + 1)
    … …  
    178178                        // Delete the fallback caller an prepare to get a real caller
    179179                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
    180                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0;
     180                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr;
    181181                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
    182182                    }

  • code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc

    r10765 r10768  
    5454    void CommandEvaluation::initialize(const std::string& command)
    5555    {
    56         this->execCommand_ = 0;
    57         this->hintCommand_ = 0;
     56        this->execCommand_ = nullptr;
     57        this->hintCommand_ = nullptr;
    5858        this->string_ = command;
    5959        this->execArgumentsOffset_ = 0;

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

    r10765 r10768  
    8686
    8787            int execute();
    88             MultiType query(int* error = 0);
     88            MultiType query(int* error = nullptr);
    8989
    9090            std::string complete();
    … …  
    9797            /// Returns true if the command evaluation contains a valid command that can be executed.
    9898            inline bool isValid() const
    99                 { return (this->execCommand_ != 0); }
     99                { return (this->execCommand_ != nullptr); }
    100100
    101101            /// Returns the console command that was evaluated by this object.

  • code/branches/cpp11_v2/src/libraries/core/command/CommandExecutor.h

    r8858 r10768  
    113113            static int execute(const std::string& command, bool useTcl = true, bool printErrors = true); // tolua_export
    114114
    115             static MultiType queryMT(const std::string& command, int* error = 0, bool useTcl = true);
    116             static std::string query(const std::string& command, int* error = 0, bool useTcl = true); // tolua_export
     115            static MultiType queryMT(const std::string& command, int* error = nullptr, bool useTcl = true);
     116            static std::string query(const std::string& command, int* error = NULL, bool useTcl = true); // tolua_export
    117117
    118118            static CommandEvaluation evaluate(const std::string& command);

  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc

    r10765 r10768  
    7676
    7777        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
    78             this->argumentCompleter_[i] = 0;
     78            this->argumentCompleter_[i] = nullptr;
    7979
    8080        this->keybindMode_ = KeybindMode::OnPress;
    … …  
    353353    {
    354354        if (this->executor_)
    355             this->executor_->setFunctor(0);
     355            this->executor_->setFunctor(nullptr);
    356356        this->objectStack_.clear();
    357357    }
    … …  
    405405    void ConsoleCommand::popObject()
    406406    {
    407         void* newobject = 0;
     407        void* newobject = nullptr;
    408408        if (!this->objectStack_.empty())
    409409        {
    … …  
    422422            return this->executor_->getFunctor()->getRawObjectPointer();
    423423        else
    424             return 0;
     424            return nullptr;
    425425    }
    426426
    … …  
    528528            return this->argumentCompleter_[index];
    529529        else
    530             return 0;
     530            return nullptr;
    531531    }
    532532

  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommandManager.cc

    r10624 r10768  
    3939namespace orxonox
    4040{
    41     ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = 0;
     41    ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = nullptr;
    4242
    4343    /**
    … …  
    6868                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
    6969        }
    70         return 0;
     70        return nullptr;
    7171    }
    7272
    … …  
    101101                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
    102102        }
    103         return 0;
     103        return nullptr;
    104104    }
    105105
    … …  
    125125
    126126        // check if a command with this name already exists
    127         if (this->getCommand(group, name) != 0)
     127        if (this->getCommand(group, name) != nullptr)
    128128        {
    129129            if (group == "")

  • code/branches/cpp11_v2/src/libraries/core/command/Executor.h

    r9550 r10768  
    121121                { return (*this->functor_)(arg1, arg2, arg3, arg4, arg5); }
    122122
    123             MultiType parse(const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
    124             MultiType parse(const SubString& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
    125 
    126             int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
     123            MultiType parse(const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
     124            MultiType parse(const SubString& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
     125
     126            int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = nullptr, const std::string& delimiter = " ") const;
    127127
    128128            /// Changes the functor.
    … …  
    249249
    250250            /// Overloads Executor::parse() with an additional object-pointer.
    251             MultiType parse(T* object, const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
     251            MultiType parse(T* object, const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const
    252252            {
    253253                T* oldobject = this->functorMember_->getObject();

  • code/branches/cpp11_v2/src/libraries/core/command/Functor.h

    r10765 r10768  
    242242        public:
    243243            /// Constructor: Stores the object-pointer.
    244             FunctorMember(O* object = 0) : object_(object), bSafeMode_(false) {}
     244            FunctorMember(O* object = nullptr) : object_(object), bSafeMode_(false) {}
    245245            virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
    246246
    … …  
    310310            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted and the Functor is in safe mode.
    311311            inline void objectDeleted()
    312                 { this->object_ = 0; }
     312                { this->object_ = nullptr; }
    313313
    314314            O* object_;     ///< The stored object-pointer, used to execute a member-function (or nullptr for static functions)
    … …  
    322322        public:
    323323            /// Constructor: Stores the object-pointer.
    324             FunctorMember(void* object = 0) {}
     324            FunctorMember(void* object = nullptr) {}
    325325
    326326            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be nullptr. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
    … …  
    330330            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
    331331            {
    332                 return (*this)((void*)0, param1, param2, param3, param4, param5);
     332                return (*this)((void*)nullptr, param1, param2, param3, param4, param5);
    333333            }
    334334
    … …  
    342342            // see Functor::getRawObjectPointer()
    343343            inline void* getRawObjectPointer() const
    344                 { return 0; }
     344                { return nullptr; }
    345345
    346346            // see Functor::setSafeMode()
    … …  
    369369        public:
    370370            /// Constructor: Initializes the base class and stores the function-pointer.
    371             FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
     371            FunctorPointer(F functionPointer, O* object = nullptr) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
    372372
    373373            /// Changes the function-pointer.
    … …  
    494494        public:
    495495            /// Constructor: Initializes the base class.
    496             FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = 0) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
     496            FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = nullptr) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
    497497
    498498            // see FunctorMember::operator()()

  • code/branches/cpp11_v2/src/libraries/core/command/IOConsolePOSIX.cc

    r10765 r10768  
    6262        , promptString_("orxonox # ")
    6363        , bStatusPrinted_(false)
    64         , originalTerminalSettings_(0)
     64        , originalTerminalSettings_(nullptr)
    6565    {
    6666        this->setTerminalMode();
    … …  
    326326            tcsetattr(0, TCSANOW, IOConsole::singletonPtr_s->originalTerminalSettings_);
    327327            delete IOConsole::singletonPtr_s->originalTerminalSettings_;
    328             IOConsole::singletonPtr_s->originalTerminalSettings_ = 0;
     328            IOConsole::singletonPtr_s->originalTerminalSettings_ = nullptr;
    329329        }
    330330    }

  • code/branches/cpp11_v2/src/libraries/core/command/IRC.cc

    r10624 r10768  
    6666    IRC::IRC()
    6767    {
    68         this->interpreter_ = 0;
     68        this->interpreter_ = nullptr;
    6969    }
    7070

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

    r10765 r10768  
    4747    SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
    4848
    49     TclBind* TclBind::singletonPtr_s = 0;
     49    TclBind* TclBind::singletonPtr_s = nullptr;
    5050
    5151    /**
    … …  
    5555    TclBind::TclBind(const std::string& datapath)
    5656    {
    57         this->interpreter_ = 0;
     57        this->interpreter_ = nullptr;
    5858        this->bSetTclDataPath_ = false;
    5959        this->setDataPath(datapath);

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

    r8079 r10768  
    121121            static void tcl_execute(Tcl::object const &args);
    122122
    123             static std::string eval(const std::string& tclcode, int* error = 0);
     123            static std::string eval(const std::string& tclcode, int* error = nullptr);
    124124
    125125        private:

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

    r10624 r10768  
    8686    };
    8787
    88     TclThreadManager* TclThreadManager::singletonPtr_s = 0;
     88    TclThreadManager* TclThreadManager::singletonPtr_s = nullptr;
    8989
    9090    /**
    … …  
    289289        catch (const Tcl::tcl_error& e)
    290290        {
    291             bundle->interpreter_ = 0;
     291            bundle->interpreter_ = nullptr;
    292292            orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
    293293        }
    … …  
    521521        {
    522522            TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
    523             return 0;
     523            return nullptr;
    524524        }
    525525    }

  • code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc

    r10542 r10768  
    4040namespace orxonox
    4141{
    42     CommandLineParser* CommandLineParser::singletonPtr_s = 0;
     42    CommandLineParser* CommandLineParser::singletonPtr_s = nullptr;
    4343
    4444    /**

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigFile.cc

    r10765 r10768  
    113113        if (file.is_open())
    114114        {
    115             ConfigFileSection* newsection = 0;
     115            ConfigFileSection* newsection = nullptr;
    116116
    117117            while (file.good() && !file.eof())
    … …  
    140140                }
    141141
    142                 if (newsection != 0)
     142                if (newsection != nullptr)
    143143                {
    144144                    if (isComment(line))

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigFileManager.cc

    r10765 r10768  
    4242    ///////////////////////
    4343
    44     ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
     44    ConfigFileManager* ConfigFileManager::singletonPtr_s = nullptr;
    4545
    4646    /// Constructor: Initializes the array of config files with nullptr.

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigValueContainer.cc

    r9559 r10768  
    5353        this->sectionname_ = sectionname;
    5454        this->varname_ = varname;
    55         this->callback_ = 0;
     55        this->callback_ = nullptr;
    5656        this->bContainerIsNew_ = true;
    5757        this->bDoInitialCallback_ = false;

  • code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.cc

    r10765 r10768  
    5757    SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
    5858
    59     SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
     59    SettingsConfigFile* SettingsConfigFile::singletonPtr_s = nullptr;
    6060
    6161    /**
    … …  
    7777    SettingsConfigFile::~SettingsConfigFile()
    7878    {
    79         ModifyConsoleCommand(__CC_load_name).setObject(0);
    80         ModifyConsoleCommand(__CC_setFilename_name).setObject(0);
    81         ModifyConsoleCommand(__CC_config_name).setObject(0);
    82         ModifyConsoleCommand(__CC_tconfig_name).setObject(0);
    83         ModifyConsoleCommand(__CC_getConfig_name).setObject(0);
     79        ModifyConsoleCommand(__CC_load_name).setObject(nullptr);
     80        ModifyConsoleCommand(__CC_setFilename_name).setObject(nullptr);
     81        ModifyConsoleCommand(__CC_config_name).setObject(nullptr);
     82        ModifyConsoleCommand(__CC_tconfig_name).setObject(nullptr);
     83        ModifyConsoleCommand(__CC_getConfig_name).setObject(nullptr);
    8484    }
    8585

  • code/branches/cpp11_v2/src/libraries/core/input/Button.cc

    r9983 r10768  
    5353    Button::Button()
    5454        : bButtonThresholdUser_(false)
    55         , paramCommandBuffer_(0)
     55        , paramCommandBuffer_(nullptr)
    5656    {
    5757        nCommands_[0]=0;
    … …  
    7575                    delete commands_[j][i];
    7676                delete[] commands_[j];
    77                 commands_[j] = 0;
     77                commands_[j] = nullptr;
    7878                nCommands_[j] = 0;
    7979            }
    … …  
    206206                        }
    207207                    }
    208                     if (cmd->paramCommand_ == 0)
     208                    if (cmd->paramCommand_ == nullptr)
    209209                    {
    210210                        cmd->paramCommand_ = new BufferedParamCommand();
    … …  
    239239            }
    240240            else
    241                 commands_[j] = 0;
     241                commands_[j] = nullptr;
    242242        }
    243243    }

  • code/branches/cpp11_v2/src/libraries/core/input/HalfAxis.h

    r7859 r10768  
    4949            : relVal_(0.0f)
    5050            , absVal_(0.0f)
    51             , paramCommands_(0)
     51            , paramCommands_(nullptr)
    5252            , nParamCommands_(0)
    5353            , pressed_(false)

  • code/branches/cpp11_v2/src/libraries/core/input/InputCommands.h

    r9978 r10768  
    103103    {
    104104    public:
    105         ParamCommand() : scale_(1.0f), paramCommand_(0) { }
     105        ParamCommand() : scale_(1.0f), paramCommand_(nullptr) { }
    106106        bool execute(float abs = 1.0f, float rel = 1.0f);
    107107        CommandEvaluation* getEvaluation();
    … …  
    118118            return &this->paramCommand_->evaluation_;
    119119        else
    120             return 0;
     120            return nullptr;
    121121    }
    122122}

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

    r10765 r10768  
    7272    InputHandler InputHandler::EMPTY;
    7373
    74     InputManager* InputManager::singletonPtr_s = 0;
     74    InputManager* InputManager::singletonPtr_s = nullptr;
    7575
    7676    //! Defines the |= operator for easier use.
    … …  
    9494    InputManager::InputManager()
    9595        : internalState_(Bad)
    96         , oisInputManager_(0)
     96        , oisInputManager_(nullptr)
    9797        , devices_(2)
    9898        , exclusiveMouse_(false)
    99         , emptyState_(0)
    100         , calibratorCallbackHandler_(0)
     99        , emptyState_(nullptr)
     100        , calibratorCallbackHandler_(nullptr)
    101101    {
    102102        RegisterObject(InputManager);
    … …  
    149149        // When loading the devices they should not already be loaded
    150150        assert(internalState_ & Bad);
    151         assert(devices_[InputDeviceEnumerator::Mouse] == 0);
    152         assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
     151        assert(devices_[InputDeviceEnumerator::Mouse] == nullptr);
     152        assert(devices_[InputDeviceEnumerator::Keyboard] == nullptr);
    153153        assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
    154154
    … …  
    294294
    295295        // Reset console commands
    296         ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
    297         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
     296        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(nullptr);
     297        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(nullptr);
    298298
    299299        orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
    … …  
    316316            const std::string& className = device->getClassName();
    317317            delete device;
    318             device = 0;
     318            device = nullptr;
    319319            orxout(verbose, context::input) << className << " destroyed." << endl;
    320320        }
    … …  
    526526    {
    527527        if (name.empty())
    528             return 0;
     528            return nullptr;
    529529        if (statesByName_.find(name) == statesByName_.end())
    530530        {
    … …  
    539539                        orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
    540540                            << static_cast<int>(priority) << "' != 0." << endl;
    541                         return 0;
     541                        return nullptr;
    542542                    }
    543543                }
    … …  
    551551        {
    552552            orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
    553             return 0;
     553            return nullptr;
    554554        }
    555555    }
    … …  
    561561            return it->second;
    562562        else
    563             return 0;
     563            return nullptr;
    564564    }
    565565

  • code/branches/cpp11_v2/src/libraries/core/input/InputState.cc

    r10765 r10768  
    4040        , bExpired_(true)
    4141        , handlers_(2)
    42         , joyStickHandlerAll_(0)
    43         , enterFunctor_(0)
    44         , leaveFunctor_(0)
     42        , joyStickHandlerAll_(nullptr)
     43        , enterFunctor_(nullptr)
     44        , leaveFunctor_(nullptr)
    4545    {
    4646        if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)

  • code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc

    r10765 r10768  
    439439                        {
    440440                            delete[] button->commands_[mode_index];
    441                             button->commands_[mode_index] = 0;
     441                            button->commands_[mode_index] = nullptr;
    442442                        }
    443443

  • code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.cc

    r10765 r10768  
    8080
    8181        // Reset console commands
    82         ModifyConsoleCommand(__CC_keybind_name ).setObject(0);
    83         ModifyConsoleCommand(__CC_tkeybind_name).setObject(0);
    84         ModifyConsoleCommand(__CC_unbind_name  ).setObject(0);
    85         ModifyConsoleCommand(__CC_tunbind_name ).setObject(0);
     82        ModifyConsoleCommand(__CC_keybind_name ).setObject(nullptr);
     83        ModifyConsoleCommand(__CC_tkeybind_name).setObject(nullptr);
     84        ModifyConsoleCommand(__CC_unbind_name  ).setObject(nullptr);
     85        ModifyConsoleCommand(__CC_tunbind_name ).setObject(nullptr);
    8686    }
    8787

  • code/branches/cpp11_v2/src/libraries/core/input/Mouse.cc

    r10624 r10768  
    6868    {
    6969#ifdef ORXONOX_PLATFORM_LINUX
    70         ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(0);
    71         ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(0);
     70        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(nullptr);
     71        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(nullptr);
    7272#endif
    7373    }

  • code/branches/cpp11_v2/src/libraries/core/module/DynLibManager.cc

    r10540 r10768  
    3838    //-----------------------------------------------------------------------
    3939    //! Static pointer to the singleton
    40     DynLibManager* DynLibManager::singletonPtr_s  = 0;
     40    DynLibManager* DynLibManager::singletonPtr_s  = nullptr;
    4141
    4242    //-----------------------------------------------------------------------

  • code/branches/cpp11_v2/src/libraries/core/module/PluginManager.cc

    r10765 r10768  
    4646    SetConsoleCommand("PluginManager", __CC_PluginManager_unload_name, &PluginManager::unloadPlugin);
    4747
    48     PluginManager* PluginManager::singletonPtr_s  = 0;
     48    PluginManager* PluginManager::singletonPtr_s  = nullptr;
    4949
    5050    PluginManager::PluginManager()

  • code/branches/cpp11_v2/src/libraries/core/module/StaticInitializationManager.cc

    r10542 r10768  
    3333namespace orxonox
    3434{
    35     StaticInitializationManager* StaticInitializationManager::singletonPtr_s = 0;
     35    StaticInitializationManager* StaticInitializationManager::singletonPtr_s = nullptr;
    3636
    3737    void StaticInitializationManager::addHandler(StaticInitializationHandler* handler)

  • code/branches/cpp11_v2/src/libraries/core/object/Context.cc

    r10765 r10768  
    4040    RegisterClass(Context);
    4141
    42     Context* Context::rootContext_s = 0;
     42    Context* Context::rootContext_s = nullptr;
    4343
    4444    Context* getContextForInitializationOfOtherContexts()

  • code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.cc

    r9975 r10768  
    5858    ObjectListBase::ObjectListBase()
    5959    {
    60         this->first_ = 0;
    61         this->last_ = 0;
     60        this->first_ = nullptr;
     61        this->last_ = nullptr;
    6262        this->size_ = 0;
    6363    }
    … …  
    7373            ObjectListBaseElement* next = current->next_;
    7474
    75             current->list_ = 0;
    76             current->next_ = 0;
    77             current->prev_ = 0;
     75            current->list_ = nullptr;
     76            current->next_ = nullptr;
     77            current->prev_ = nullptr;
    7878
    7979            current = next;
    … …  
    155155            this->first_ = element->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
    156156
    157         element->list_ = 0;
    158         element->next_ = 0;
    159         element->prev_ = 0;
     157        element->list_ = nullptr;
     158        element->next_ = nullptr;
     159        element->prev_ = nullptr;
    160160        --this->size_;
    161161    }

  • code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.h

    r10736 r10768  
    5757                @param objectBase The object to store
    5858            */
    59             ObjectListBaseElement(Listable* object) : next_(0), prev_(0), objectBase_(object), list_(0) {}
     59            ObjectListBaseElement(Listable* object) : next_(nullptr), prev_(nullptr), objectBase_(object), list_(nullptr) {}
    6060            virtual ~ObjectListBaseElement() { this->removeFromList(); }
    6161
    … …  
    136136            inline ObjectListBaseElement* begin() const { return this->first_; }
    137137            /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
    138             inline ObjectListBaseElement* end() const { return 0; }
     138            inline ObjectListBaseElement* end() const { return nullptr; }
    139139            /// Returns a pointer to the last element in the list. Works only with Iterator.
    140140            inline ObjectListBaseElement* rbegin() const { return this->last_; }
    141141            /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
    142             inline ObjectListBaseElement* rend() const { return 0; }
     142            inline ObjectListBaseElement* rend() const { return nullptr; }
    143143
    144144            inline void registerRemovalListener(ObjectListElementRemovalListener* listener) { this->listeners_.push_back(listener); }

  • code/branches/cpp11_v2/src/libraries/core/object/StrongPtr.h

    r10765 r10768  
    138138        public:
    139139            /// Constructor: Initializes the strong pointer with a null pointer.
    140             inline StrongPtr() : pointer_(0), base_(0)
     140            inline StrongPtr() : pointer_(nullptr), base_(nullptr)
    141141            {
    142142            }
    … …  
    237237            inline T* operator->() const
    238238            {
    239                 assert(this->pointer_ != 0);
     239                assert(this->pointer_ != nullptr);
    240240                return this->pointer_;
    241241            }
    … …  
    244244            inline T& operator*() const
    245245            {
    246                 assert(this->pointer_ != 0);
     246                assert(this->pointer_ != nullptr);
    247247                return *this->pointer_;
    248248            }
    … …  
    251251            inline bool operator!() const
    252252            {
    253                 return (this->pointer_ == 0);
     253                return (this->pointer_ == nullptr);
    254254            }
    255255

  • code/branches/cpp11_v2/src/libraries/core/object/WeakPtr.h

    r10765 r10768  
    100100        public:
    101101            /// Constructor: Initializes the weak pointer with a null pointer.
    102             inline WeakPtr() : pointer_(0), base_(0), callback_(0)
     102            inline WeakPtr() : pointer_(nullptr), base_(nullptr), callback_(nullptr)
    103103            {
    104104            }
    105105
    106106            /// Constructor: Initializes the weak pointer with a pointer to an object.
    107             inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
     107            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(nullptr)
    108108            {
    109109                this->registerAsDestructionListener(this->base_);
    … …  
    111111
    112112            /// Copy-constructor
    113             inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
     113            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(nullptr)
    114114            {
    115115                this->registerAsDestructionListener(this->base_);
    … …  
    118118            /// Copy-constructor for weak pointers to objects of another class.
    119119            template <class O>
    120             inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(0)
     120            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(nullptr)
    121121            {
    122122                this->registerAsDestructionListener(this->base_);
    … …  
    172172            inline T* operator->() const
    173173            {
    174                 assert(this->pointer_ != 0);
     174                assert(this->pointer_ != nullptr);
    175175                return this->pointer_;
    176176            }
    … …  
    179179            inline T& operator*() const
    180180            {
    181                 assert(this->pointer_ != 0);
     181                assert(this->pointer_ != nullptr);
    182182                return *this->pointer_;
    183183            }
    … …  
    186186            inline bool operator!() const
    187187            {
    188                 return (this->pointer_ == 0);
     188                return (this->pointer_ == nullptr);
    189189            }
    190190
    … …  
    232232            inline void objectDeleted()
    233233            {
    234                 this->base_ = 0;
    235                 this->pointer_ = 0;
     234                this->base_ = nullptr;
     235                this->pointer_ = nullptr;
    236236                if (this->callback_)
    237237                    (*this->callback_)();

  • code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.cc

    r10542 r10768  
    3838namespace orxonox
    3939{
    40     ScopeManager* ScopeManager::singletonPtr_s = 0;
     40    ScopeManager* ScopeManager::singletonPtr_s = nullptr;
    4141
    4242    void ScopeManager::addScope(ScopeID::Value scope)

  • code/branches/cpp11_v2/src/libraries/network/Connection.cc

    r8858 r10768  
    4646
    4747  Connection::Connection(uint32_t firstPeerID):
    48     host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
     48    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
    4949  {
    5050    enet_initialize();
    … …  
    8181  {
    8282//     this->overallMutex_->lock();
    83     outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
     83    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
    8484   
    8585    this->outgoingEventsMutex_->lock();
    … …  
    9191  void Connection::disconnectPeers()
    9292  {
    93     outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
     93    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
    9494   
    9595    this->outgoingEventsMutex_->lock();
    … …  
    323323   
    324324    // create new peerEvent and return it
    325     incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
     325    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
    326326    return inEvent;
    327327  }
    … …  
    338338   
    339339    // create new peerEvent and return it
    340     incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
     340    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
    341341    return inEvent;
    342342  }

  • code/branches/cpp11_v2/src/libraries/network/GamestateHandler.cc

    r7801 r10768  
    3232namespace orxonox {
    3333
    34 // GamestateHandler *GamestateHandler::instance_=0;
     34// GamestateHandler *GamestateHandler::instance_=nullptr;
    3535
    3636GamestateHandler::GamestateHandler()

  • code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc

    r8858 r10768  
    6060{
    6161  GamestateManager::GamestateManager() :
    62   currentGamestate_(0), id_(0)
     62  currentGamestate_(nullptr), id_(0)
    6363  {
    6464//     trafficControl_ = new TrafficControl();
    … …  
    140140
    141141  bool GamestateManager::getSnapshot(){
    142     if ( currentGamestate_ != 0 )
     142    if ( currentGamestate_ != nullptr )
    143143      delete currentGamestate_;
    144144    uint8_t gsMode;
    … …  
    165165    { //we have no data to send
    166166      delete currentGamestate_;
    167       currentGamestate_=0;
     167      currentGamestate_=nullptr;
    168168      return false;
    169169    }
    … …  
    191191      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
    192192
    193       packet::Gamestate* baseGamestate=0;
     193      packet::Gamestate* baseGamestate=nullptr;
    194194      if(lastAckedGamestateID != GAMESTATEID_INITIAL)
    195195      {
    … …  
    200200      }
    201201
    202       peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
     202      peerGamestates.push_back(nullptr);  // insert an empty gamestate* to be changed
    203203      finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
    204       if( peerGamestates.back()==0 )
     204      if( peerGamestates.back()==nullptr )
    205205        // nothing to send to remove pointer from vector
    206206        peerGamestates.pop_back();
    … …  
    243243      {
    244244        delete diffed1;
    245         destgamestate = 0;
     245        destgamestate = nullptr;
    246246        return;
    247247      }

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

    r10624 r10768  
    4444  SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
    4545
    46   // Host*               Host::instance_=0;
     46  // Host*               Host::instance_=nullptr;
    4747  uint32_t            Host::clientID_s=0;
    4848//   uint32_t            Host::shipID_s=-1;
    … …  
    5454  Host::Host()
    5555  {
    56   //   assert(instance_==0);
     56  //   assert(instance_==nullptr);
    5757    instances_s.push_back(this);
    5858    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
    … …  
    6262
    6363  /**
    64   * @brief Destructor: resets the instance pointer to 0
     64  * @brief Destructor: resets the instance pointer to nullptr
    6565  */
    6666  Host::~Host()
    … …  
    6868    assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
    6969    instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
    70     ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
     70    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
    7171  }
    7272
    … …  
    135135        ++it;
    136136    }
    137     return 0;
     137    return nullptr;
    138138  }
    139139

  • code/branches/cpp11_v2/src/libraries/network/LANDiscoverable.cc

    r10765 r10768  
    5151    this->setConfigValues();
    5252    //     this->setActivity(true);
    53     this->host_ = 0;
     53    this->host_ = nullptr;
    5454    this->bActive_ = false;
    5555  }
    … …  
    8383      bindAddress.host = ENET_HOST_ANY;
    8484      bindAddress.port = LAN_DISCOVERY_PORT;
    85       assert( this->host_ == 0 );
     85      assert( this->host_ == nullptr );
    8686      this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
    8787      if ( this->host_ == nullptr )
    … …  
    9191    {
    9292      enet_host_destroy( this->host_ );
    93       this->host_ = 0;
     93      this->host_ = nullptr;
    9494    }
    9595      this->bActive_ = bActive;

  • code/branches/cpp11_v2/src/libraries/network/NetworkFunction.h

    r10624 r10768  
    144144    inline bool call(uint32_t objectID)
    145145    {
    146       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     146      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    147147      {
    148148        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
    … …  
    154154    inline bool call(uint32_t objectID, const MultiType& mt1)
    155155    {
    156       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     156      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    157157      {
    158158        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
    … …  
    164164    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
    165165    {
    166       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     166      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    167167      {
    168168        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
    … …  
    174174    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
    175175    {
    176       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     176      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    177177      {
    178178        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
    … …  
    184184    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
    185185    {
    186       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     186      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    187187      {
    188188        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
    … …  
    194194    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
    195195    {
    196       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     196      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    197197      {
    198198        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);

  • code/branches/cpp11_v2/src/libraries/network/NetworkFunctionManager.cc

    r10765 r10768  
    3232namespace orxonox
    3333{
    34     NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
     34    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
    3535
    3636    void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)

  • code/branches/cpp11_v2/src/libraries/network/Server.cc

    r10765 r10768  
    194194  void Server::printRTT()
    195195  {
    196 //     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
     196//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=nullptr; temp=temp->next() )
    197197//       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
    198198  }

  • code/branches/cpp11_v2/src/libraries/network/TrafficControl.cc

    r9667 r10768  
    6464*Initializing protected members
    6565*/
    66     TrafficControl *TrafficControl::instance_=0;
     66    TrafficControl *TrafficControl::instance_=nullptr;
    6767
    6868    /**
    … …  
    7272    {
    7373    RegisterObject(TrafficControl);
    74       assert(instance_==0);
     74      assert(instance_==nullptr);
    7575      instance_=this;
    7676    this->setConfigValues();
    … …  
    7878
    7979    /**
    80     * @brief Destructor: resets the instance pointer to 0
     80    * @brief Destructor: resets the instance pointer to nullptr
    8181    */
    8282    TrafficControl::~TrafficControl()
    8383    {
    84       instance_=0;
     84      instance_=nullptr;
    8585    }
    8686

  • code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.cc

    r10765 r10768  
    106106{
    107107  uint32_t tempsize=0, currentsize=0;
    108   assert(data_==0);
     108  assert(data_==nullptr);
    109109  uint32_t size = calcGamestateSize(id, mode);
    110110

  • code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.h

    r7801 r10768  
    5454{
    5555  public:
    56     GamestateHeader(){ data_=0; }
     56    GamestateHeader(){ data_=nullptr; }
    5757    GamestateHeader(uint8_t* data)
    5858      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }

  • code/branches/cpp11_v2/src/libraries/network/packet/Packet.cc

    r10765 r10768  
    6969  packetDirection_ = Direction::Outgoing;
    7070  peerID_=0;
    71   data_=0;
    72   enetPacket_=0;
     71  data_=nullptr;
     72  enetPacket_=nullptr;
    7373  bDataENetAllocated_ = false;
    7474}
    … …  
    8080  peerID_=peerID;
    8181  data_=data;
    82   enetPacket_=0;
     82  enetPacket_=nullptr;
    8383  bDataENetAllocated_ = false;
    8484}
    … …  
    9595    memcpy(data_, p.data_, p.getSize());
    9696  }else
    97     data_=0;
     97    data_=nullptr;
    9898  bDataENetAllocated_ = p.bDataENetAllocated_;
    9999}
    … …  
    175175#endif
    176176//  ENetPacket *temp = enetPacket_;
    177 //  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
     177//  enetPacket_ = nullptr; // otherwise we have a double free because enet already handles the deallocation of the packet
    178178  if( this->flags_ & PacketFlag::Reliable )
    179179    host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
    … …  
    191191//   if( peerID==static_cast<unsigned int>(-2))
    192192//     peerID = NETWORK_PEER_ID_SERVER;
    193   Packet *p = 0;
     193  Packet *p = nullptr;
    194194//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
    195195  switch( *(Type::Value *)(data + _PACKETID) )
    … …  
    251251  assert(it != packetMap_.end());
    252252  // Make sure we don't delete it again in the destructor
    253   it->second->enetPacket_ = 0;
     253  it->second->enetPacket_ = nullptr;
    254254  delete it->second;
    255255  packetMap_.erase(it);

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc

    r10765 r10768  
    140140    {
    141141      mem += header.getDataSize() + header.getSize();
    142       return 0;
     142      return nullptr;
    143143    }
    144144//     assert( !header.isDiffed() );
    … …  
    156156    }
    157157    assert(id);
    158     Context* context = 0;
     158    Context* context = nullptr;
    159159    if (header.getContextID() != OBJECTID_UNKNOWN)
    160160    {
    … …  
    164164        mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
    165165        assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
    166         return 0;
     166        return nullptr;
    167167      }
    168168      else
    … …  
    172172      context = Context::getRootContext();
    173173
    174     assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
     174    assert(getSynchronisable(header.getObjectID())==nullptr);   //make sure no object with this id exists
    175175    BaseObject *bo = orxonox_cast<BaseObject*>(id->fabricate(context));
    176176    assert(bo);

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h

    r9667 r10768  
    171171  protected:
    172172    Synchronisable(Context* context);
    173     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
    174     template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     173    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
     174    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
    175175    template <class T> void unregisterVariable(T& var);
    176176

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/SynchronisableVariable.h

    r10624 r10768  
    7171  {
    7272    public:
    73       SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
     73      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=nullptr);
    7474      virtual ~SynchronisableVariable();
    7575
    … …  
    8989  {
    9090    public:
    91       SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
     91      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=nullptr);
    9292      virtual ~SynchronisableVariableBidirectional();
    9393

  • code/branches/cpp11_v2/src/libraries/tools/BillboardSet.cc

    r8858 r10768  
    4646    BillboardSet::BillboardSet()
    4747    {
    48         this->billboardSet_ = 0;
     48        this->billboardSet_ = nullptr;
    4949    }
    5050
    … …  
    8181        {
    8282            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    83             this->billboardSet_ = 0;
     83            this->billboardSet_ = nullptr;
    8484        }
    8585
    … …  
    104104        {
    105105            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    106             this->billboardSet_ = 0;
     106            this->billboardSet_ = nullptr;
    107107        }
    108108
    … …  
    114114        if (this->billboardSet_ && this->scenemanager_)
    115115            this->scenemanager_->destroyBillboardSet(this->billboardSet_);
    116         this->billboardSet_ = 0;
     116        this->billboardSet_ = nullptr;
    117117    }
    118118

  • code/branches/cpp11_v2/src/libraries/tools/DebugDrawer.cc

    r10262 r10768  
    2121{
    2222    DebugDrawer::DebugDrawer(Ogre::SceneManager *_sceneManager, float _fillAlpha) :
    23             sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(0), isEnabled(true), linesIndex(0), trianglesIndex(0)
     23            sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(nullptr), isEnabled(true), linesIndex(0), trianglesIndex(0)
    2424    {
    2525        initialise();

  • code/branches/cpp11_v2/src/libraries/tools/Mesh.cc

    r8858 r10768  
    4444    Mesh::Mesh()
    4545    {
    46         this->entity_ = 0;
     46        this->entity_ = nullptr;
    4747        this->bCastShadows_ = true;
    4848    }
    … …  
    7373            {
    7474                orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
    75                 this->entity_ = 0;
     75                this->entity_ = nullptr;
    7676            }
    7777        }

  • code/branches/cpp11_v2/src/libraries/tools/ParticleInterface.cc

    r10624 r10768  
    5959
    6060        this->scenemanager_ = scenemanager;
    61         this->particleSystem_ = 0;
     61        this->particleSystem_ = nullptr;
    6262
    6363        this->bEnabled_ = true;
    … …  
    8080            {
    8181                orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
    82                 this->particleSystem_ = 0;
     82                this->particleSystem_ = nullptr;
    8383            }
    8484        }
    … …  
    110110        }
    111111        else
    112             return 0;
     112            return nullptr;
    113113    }
    114114    Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
    … …  
    117117            return this->particleSystem_->getEmitter(emitterNr);
    118118        else
    119             return 0;
     119            return nullptr;
    120120    }
    121121    void ParticleInterface::removeEmitter(unsigned int emitterNr)
    … …  
    142142            return this->particleSystem_->addAffector(name);
    143143        else
    144             return 0;
     144            return nullptr;
    145145    }
    146146    Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr)
    … …  
    149149            return this->particleSystem_->getAffector(affectorNr);
    150150        else
    151             return 0;
     151            return nullptr;
    152152    }
    153153    void ParticleInterface::removeAffector(unsigned int affectorNr)

  • code/branches/cpp11_v2/src/libraries/tools/Shader.cc

    r10765 r10768  
    4444        @brief Initializes the values and sets the scene manager.
    4545    */
    46     Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(0)
     46    Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(nullptr)
    4747    {
    4848        RegisterObject(Shader);
    … …  
    127127                Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
    128128                this->compositorInstance_->removeListener(this);
    129                 this->compositorInstance_ = 0;
     129                this->compositorInstance_ = nullptr;
    130130            }
    131131            if (!this->compositorName_.empty())

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

    r10727 r10768  
    4848    {
    4949        public:
    50             Shader(Ogre::SceneManager* scenemanager = 0);
     50            Shader(Ogre::SceneManager* scenemanager = nullptr);
    5151            virtual ~Shader();
    5252

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

    r10624 r10768  
    163163    void Timer::init()
    164164    {
    165         this->executor_ = 0;
     165        this->executor_ = nullptr;
    166166        this->interval_ = 0;
    167167        this->bLoop_ = false;

  • code/branches/cpp11_v2/src/libraries/util/Math.h

    r10742 r10768  
    200200    template <> inline long double          zeroise<long double>()          { return 0; }
    201201    template <> inline bool                 zeroise<bool>()                 { return 0; }
    202     template <> inline void*                zeroise<void*>()                { return 0; }
     202    template <> inline void*                zeroise<void*>()                { return nullptr; }
    203203    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
    204204    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }

  • code/branches/cpp11_v2/src/libraries/util/MultiType.h

    r10197 r10768  
    266266
    267267            /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
    268             inline MultiType()                       : value_(0) { }
     268            inline MultiType()                       : value_(nullptr) { }
    269269            /// Constructor: Assigns the given value and sets the type.
    270270            template <typename V>
    271             inline MultiType(const V& value)         : value_(0) { this->set(value); }
     271            inline MultiType(const V& value)         : value_(nullptr) { this->set(value); }
    272272            /// Copyconstructor: Assigns value and type of the other MultiType.
    273             inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
     273            inline MultiType(const MultiType& other) : value_(nullptr) { this->set(other); }
    274274
    275275            /// Destructor: Deletes the MT_Value.
    … …  
    325325                if (this->value_)
    326326                    delete this->value_;
    327                 this->value_ = (other.value_) ? other.value_->clone() : 0;
     327                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
    328328            }
    329329
    … …  
    332332
    333333            /// Resets value and type. Type will be void afterwards and null() returns true.
    334             inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
     334            inline void reset() { if (this->value_) delete this->value_; this->value_ = nullptr; }
    335335            /// Resets the value and changes the internal type to T.
    336336            template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
    … …  
    486486    template <> inline long double          MultiType::get() const { return (this->value_ ? this->value_->get<long double>()          : 0); }
    487487    template <> inline bool                 MultiType::get() const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
    488     template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : 0); }
     488    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : nullptr); }
    489489    template <> inline std::string          MultiType::get() const { return (this->value_ ? this->value_->get<std::string>()          : NilValue<std::string>()); }
    490490    template <> inline orxonox::Vector2     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector2>()     : NilValue<orxonox::Vector2>()); }

  • code/branches/cpp11_v2/src/libraries/util/MultiTypeValue.h

    r9550 r10768  
    7777        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    7878        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    79         inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
     79        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, nullptr); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    8080        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    8181        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.

  • code/branches/cpp11_v2/src/libraries/util/SharedPtr.h

    r10765 r10768  
    216216        public:
    217217            /// Default constructor, the pointer is set to nullptr.
    218             inline SharedPtr() : pointer_(0), counter_(0)
     218            inline SharedPtr() : pointer_(nullptr), counter_(nullptr)
    219219            {
    220220            }
    221221
    222222            /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
    223             inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
     223            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(nullptr)
    224224            {
    225225                if (this->pointer_)
    … …  
    293293            inline T* operator->() const
    294294            {
    295                 assert(this->pointer_ != 0);
     295                assert(this->pointer_ != nullptr);
    296296                return this->pointer_;
    297297            }
    … …  
    300300            inline T& operator*() const
    301301            {
    302                 assert(this->pointer_ != 0);
     302                assert(this->pointer_ != nullptr);
    303303                return *this->pointer_;
    304304            }
    … …  
    313313            inline operator bool() const
    314314            {
    315                 return (this->pointer_ != 0);
     315                return (this->pointer_ != nullptr);
    316316            }
    317317

  • code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc

    r10765 r10768  
    127127      }
    128128      // if the signalhandler has already been destroyed then don't do anything
    129       if( SignalHandler::singletonPtr_s == 0 )
     129      if( SignalHandler::singletonPtr_s == nullptr )
    130130      {
    131131        orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
    … …  
    430430
    431431            // if the signalhandler has already been destroyed then don't do anything
    432             if (SignalHandler::singletonPtr_s == 0)
     432            if (SignalHandler::singletonPtr_s == nullptr)
    433433            {
    434434                orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;

  • code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc

    r10765 r10768  
    4545        this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
    4646        this->numChunksPerBlock_ = numObjects;
    47         this->first_ = 0;
     47        this->first_ = nullptr;
    4848    }
    4949
    … …  
    9898
    9999            // the next_ pointer of the last chunk must point to nullptr
    100             setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
     100            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, nullptr);
    101101
    102102            // The second chunk in the block is assigned to the first_ pointer

  • code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc

    r9550 r10768  
    5757
    5858        this->isInitialized_ = false;
    59         this->memoryWriterInstance_ = 0;
    60         this->consoleWriterInstance_ = 0;
    61         this->logWriterInstance_ = 0;
     59        this->memoryWriterInstance_ = nullptr;
     60        this->consoleWriterInstance_ = nullptr;
     61        this->logWriterInstance_ = nullptr;
    6262
    6363        // register 'undefined' context in order to give it always the first context-ID

  • code/branches/cpp11_v2/src/modules/dodgerace/DodgeRace.cc

    r10765 r10768  
    5959        comboTimer.setTimer(3.0f, true, createExecutor(createFunctor(&DodgeRace::comboControll, this)));
    6060        this->numberOfBots_ = 0; //sets number of default bots temporarly to 0
    61         this->center_ = 0;
     61        this->center_ = nullptr;
    6262
    6363        this->setHUDTemplate("DodgeRaceHUD");

  • code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceHUDinfo.cc

    r10624 r10768  
    4040        RegisterObject(DodgeRaceHUDinfo);
    4141
    42         this->DodgeRaceGame = 0;
     42        this->DodgeRaceGame = nullptr;
    4343        this->bShowPoints_ = true;
    4444    }
    … …  
    8686        else
    8787        {
    88             this->DodgeRaceGame = 0;
     88            this->DodgeRaceGame = nullptr;
    8989        }
    9090    }

  • code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc

    r10765 r10768  
    416416        for (std::vector<StaticEntity*>::const_iterator it = allObjects.begin(); it != allObjects.end(); ++it)
    417417        {
    418             for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
     418            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
    419419            {
    420420                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
    … …  
    444444        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
    445445        {
    446             for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
     446            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
    447447            {
    448448                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
    … …  
    540540        //                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
    541541        //                    //TODO: Probably it points on a wrong object
    542         //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
     542        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
    543543        //                    {
    544544        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
    … …  
    572572        //                        if((*it)==nullptr)
    573573        //                        {   orxout()<<"Problempoint 1"<<endl; continue;}
    574         //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
     574        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
    575575        //                        {
    576576        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)

  • code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc

    r10765 r10768  
    100100        return this->checkpoints_[index];
    101101        else
    102         return 0;
     102        return nullptr;
    103103    }
    104104
    … …  
    116116        if (this->checkpoints_[i]->getCheckpointIndex() == index)
    117117        return this->checkpoints_[i];
    118         return 0;
     118        return nullptr;
    119119    }
    120120

  • code/branches/cpp11_v2/src/modules/invader/Invader.cc

    r10765 r10768  
    6161        RegisterObject(Invader);
    6262        this->numberOfBots_ = 0; //sets number of default bots temporarly to 0
    63         this->center_ = 0;
     63        this->center_ = nullptr;
    6464        bEndGame = false;
    6565        lives = 3;

  • code/branches/cpp11_v2/src/modules/invader/InvaderHUDinfo.cc

    r10733 r10768  
    4040        RegisterObject(InvaderHUDinfo);
    4141
    42         this->InvaderGame = 0;
     42        this->InvaderGame = nullptr;
    4343        this->bShowLives_ = false;
    4444        this->bShowLevel_ = false;
    … …  
    132132        else
    133133        {
    134             this->InvaderGame = 0;
     134            this->InvaderGame = nullptr;
    135135        }
    136136    }

  • code/branches/cpp11_v2/src/modules/jump/Jump.cc

    r10765 r10768  
    6565        RegisterObject(Jump);
    6666
    67         center_ = 0;
    68         figure_ = 0;
    69         camera = 0;
     67        center_ = nullptr;
     68        figure_ = nullptr;
     69        camera = nullptr;
    7070        setHUDTemplate("JumpHUD");
    7171    }
    … …  
    270270    void Jump::cleanup()
    271271    {
    272         camera = 0;
     272        camera = nullptr;
    273273    }
    274274
    … …  
    340340        else
    341341        {
    342             return 0;
     342            return nullptr;
    343343        }
    344344    }

  • code/branches/cpp11_v2/src/modules/jump/JumpEnemy.cc

    r10765 r10768  
    5151
    5252        dead_ = false;
    53         figure_ = 0;
     53        figure_ = nullptr;
    5454        width_ = 0.0;
    5555        height_ = 0.0;

  • code/branches/cpp11_v2/src/modules/jump/JumpItem.cc

    r10733 r10768  
    4848        attachedToFigure_ = false;
    4949
    50         figure_ = 0;
     50        figure_ = nullptr;
    5151        height_ = 0.0;
    5252        width_ = 0.0;

  • code/branches/cpp11_v2/src/modules/jump/JumpPlatform.cc

    r10765 r10768  
    4848        RegisterObject(JumpPlatform);
    4949
    50         figure_ = 0;
     50        figure_ = nullptr;
    5151
    5252        setPosition(Vector3(0,0,0));

  • code/branches/cpp11_v2/src/modules/jump/JumpProjectile.cc

    r10733 r10768  
    4747        RegisterObject(JumpProjectile);
    4848
    49         figure_ = 0;
     49        figure_ = nullptr;
    5050        setPosition(Vector3(0,0,0));
    5151        setVelocity(Vector3(0,0,250.0));

  • code/branches/cpp11_v2/src/modules/jump/JumpSpring.cc

    r10765 r10768  
    100100    void JumpSpring::accelerateFigure()
    101101    {
    102         if (figure_ != 0)
     102        if (figure_ != nullptr)
    103103        {
    104104            figure_->JumpFromSpring(this);

  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc

    r10765 r10768  
    6666        RegisterObject(Mini4Dgame);
    6767
    68         this->board_ = 0;
     68        this->board_ = nullptr;
    6969
    7070        // Set the type of Bots for this particular Gametype.
    … …  
    9191        {
    9292            //this->board_->destroy();
    93             this->board_ = 0;
     93            this->board_ = nullptr;
    9494        }
    9595    }

  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4DgameAI.cc

    r10230 r10768  
    6060
    6161        this->setConfigValues();
    62         this->center_ = 0;
     62        this->center_ = nullptr;
    6363    }
    6464

  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4DgameBoard.cc

    r10765 r10768  
    6464                    for(int l=0;l<4;l++){
    6565                        this->board[i][j][k][l]=mini4DgamePlayerColor::none;
    66                         this->blinkingBillboards[i][j][k][l] = 0;
     66                        this->blinkingBillboards[i][j][k][l] = nullptr;
    6767                    }
    6868                }
    … …  
    9797        this->board[move.x][move.y][move.z][move.w] = mini4DgamePlayerColor::none;
    9898        this->blinkingBillboards[move.x][move.y][move.z][move.w]->destroy();
    99         this->blinkingBillboards[move.x][move.y][move.z][move.w] = 0;
     99        this->blinkingBillboards[move.x][move.y][move.z][move.w] = nullptr;
    100100        if(player_toggle_){
    101101            this->player_toggle_ = false;

  • code/branches/cpp11_v2/src/modules/objects/Attacher.cc

    r9667 r10768  
    4040        RegisterObject(Attacher);
    4141
    42         this->target_ = 0;
     42        this->target_ = nullptr;
    4343    }
    4444
    … …  
    9090            ++i;
    9191        }
    92         return 0;
     92        return nullptr;
    9393    }
    9494
    … …  
    9696    {
    9797        this->targetname_ = target;
    98         this->target_ = 0;
     98        this->target_ = nullptr;
    9999
    100100        if (this->targetname_.empty())

  • code/branches/cpp11_v2/src/modules/objects/controllers/TurretController.cc

    r10622 r10768  
    8181        {
    8282            this->forgetTarget();
    83             turret->setTarget(0);
     83            turret->setTarget(nullptr);
    8484        }
    8585
    … …  
    9999        float minScore = FLT_MAX;
    100100        float tempScore;
    101         Pawn* minScorePawn = 0;
     101        Pawn* minScorePawn = nullptr;
    102102
    103103        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)

  • code/branches/cpp11_v2/src/modules/objects/eventsystem/EventDispatcher.cc

    r9667 r10768  
    7979            ++i;
    8080        }
    81         return 0;
     81        return nullptr;
    8282    }
    8383}

  • code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc

    r9667 r10768  
    102102            ++i;
    103103        }
    104         return 0;
     104        return nullptr;
    105105    }
    106106
    … …  
    119119            ++i;
    120120        }
    121         return 0;
     121        return nullptr;
    122122    }
    123123}

  • code/branches/cpp11_v2/src/modules/overlays/hud/AnnounceMessage.cc

    r9667 r10768  
    4040        RegisterObject(AnnounceMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(3.0f);

  • code/branches/cpp11_v2/src/modules/overlays/hud/CountDown.cc

    r9943 r10768  
    7171        RegisterObject(CountDown);
    7272
    73         this->owner_ = 0;
     73        this->owner_ = nullptr;
    7474        this->hasStopped_ = false;
    7575    }

  • code/branches/cpp11_v2/src/modules/overlays/hud/DeathMessage.cc

    r9667 r10768  
    4040        RegisterObject(DeathMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(2.0f);

  • code/branches/cpp11_v2/src/modules/overlays/hud/GametypeFadingMessage.cc

    r9667 r10768  
    4040        RegisterObject(GametypeFadingMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343        this->setDelay(2.0f);
    4444        this->setFadeouttime(0.5f);

  • code/branches/cpp11_v2/src/modules/overlays/hud/GametypeStaticMessage.cc

    r9667 r10768  
    4242    {
    4343        RegisterObject(GametypeStaticMessage);
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545    }
    4646

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDBar.cc

    r9667 r10768  
    191191            return barColours_[index];
    192192        else
    193             return 0;
     193            return nullptr;
    194194    }
    195195

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDBoostBar.cc

    r9667 r10768  
    4242        RegisterObject(HUDBoostBar);
    4343
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545        this->flashInterval_ = 0.25f;
    4646        this->flashDt_ = 0.0f;

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDEnemyHealthBar.cc

    r10765 r10768  
    4141
    4242        this->setConfigValues();
    43         this->owner_ = 0;
     43        this->owner_ = nullptr;
    4444    }
    4545

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDHealthBar.cc

    r9667 r10768  
    4343        RegisterObject(HUDHealthBar);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646        this->bUseBarColour_ = false;
    4747
    … …  
    5858        {
    5959            this->textoverlay_->destroy();
    60             this->textoverlay_ = 0;
     60            this->textoverlay_ = nullptr;
    6161        }
    6262    }

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc

    r10765 r10768  
    6969    RegisterClass ( HUDNavigation );
    7070
    71     HUDNavigation* HUDNavigation::localHUD_s = 0;
     71    HUDNavigation* HUDNavigation::localHUD_s = nullptr;
    7272
    7373    HUDNavigation::HUDNavigation(Context* context) :

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc

    r9945 r10768  
    6868        this->shapeMaterials_[RadarViewable::Triangle] = "RadarTriangle.png";
    6969        this->shapeMaterials_[RadarViewable::Square]   = "RadarSquare.png";
    70         this->owner_ = 0;
     70        this->owner_ = nullptr;
    7171
    7272        this->map3DFront_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDSpeedBar.cc

    r9667 r10768  
    4343        RegisterObject(HUDSpeedBar);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646    }
    4747

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDTimer.cc

    r9667 r10768  
    4242        RegisterObject(HUDTimer);
    4343
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545    }
    4646

  • code/branches/cpp11_v2/src/modules/overlays/hud/KillMessage.cc

    r9667 r10768  
    4040        RegisterObject(KillMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(2.0f);

  • code/branches/cpp11_v2/src/modules/overlays/hud/LastManStandingInfos.cc

    r10624 r10768  
    4343        RegisterObject(LastManStandingInfos);
    4444
    45         this->lms_ = 0;
    46         this->player_ = 0;
     45        this->lms_ = nullptr;
     46        this->player_ = nullptr;
    4747        this->bShowLives_ = false;
    4848        this->bShowPlayers_ = false;
    … …  
    9191        else
    9292        {
    93             this->player_ = 0;
    94             this->lms_ = 0;
     93            this->player_ = nullptr;
     94            this->lms_ = nullptr;
    9595        }
    9696    }

  • code/branches/cpp11_v2/src/modules/overlays/hud/LastTeamStandingInfos.cc

    r10624 r10768  
    4343        RegisterObject(LastTeamStandingInfos);
    4444
    45         this->lts_ = 0;
    46         this->player_ = 0;
     45        this->lts_ = nullptr;
     46        this->player_ = nullptr;
    4747        this->bShowLives_ = false;
    4848        this->bShowTeams_ = false;
    … …  
    9191        else
    9292        {
    93             this->player_ = 0;
    94             this->lts_ = 0;
     93            this->player_ = nullptr;
     94            this->lts_ = nullptr;
    9595        }
    9696    }

  • code/branches/cpp11_v2/src/modules/overlays/hud/PauseNotice.cc

    r9667 r10768  
    4040        RegisterObject(PauseNotice);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343    }
    4444

  • code/branches/cpp11_v2/src/modules/overlays/hud/TeamBaseMatchScore.cc

    r10624 r10768  
    4343        RegisterObject(TeamBaseMatchScore);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646
    4747        this->bShowBases_ = false;
    … …  
    120120            this->owner_ = orxonox_cast<TeamBaseMatch*>(this->getOwner()->getGametype());
    121121        else
    122             this->owner_ = 0;
     122            this->owner_ = nullptr;
    123123    }
    124124}

  • code/branches/cpp11_v2/src/modules/overlays/stats/CreateLines.cc

    r6502 r10768  
    3737    CreateLines::CreateLines(float leftOffset, float topOffset, float width, float height)
    3838    {
    39         playerNameText_ = new OverlayText(0);
     39        playerNameText_ = new OverlayText(nullptr);
    4040        playerNameText_->setTextSize(0.04f);
    4141        playerNameText_->setColour(ColourValue(0.0f, 0.75f, 0.2f, 1.0f));
    4242        playerNameText_->setPosition(Vector2(0.1f, topOffset + 0.01f));
    4343
    44         scoreText_ = new OverlayText(0);
     44        scoreText_ = new OverlayText(nullptr);
    4545        scoreText_->setTextSize(0.04f);
    4646        scoreText_->setColour(ColourValue(0.0f, 0.75f, 0.2f, 1.0f));
    4747        scoreText_->setPosition(Vector2(0.6f, topOffset + 0.01f));
    4848
    49         deathsText_ = new OverlayText(0);
     49        deathsText_ = new OverlayText(nullptr);
    5050        deathsText_->setTextSize(0.04f);
    5151        deathsText_->setColour(ColourValue(0, 0.75f, 0.2f, 1.0f));
    5252        deathsText_->setPosition(Vector2(0.8f, topOffset + 0.01f));
    5353
    54         background_ = new Stats(0);
     54        background_ = new Stats(nullptr);
    5555        background_->setPosition(Vector2(leftOffset, topOffset));
    5656        background_->setSize(Vector2(width, height));

  • code/branches/cpp11_v2/src/modules/overlays/stats/Stats.cc

    r9667 r10768  
    4646    Stats::Stats(Context* context)
    4747        : OrxonoxOverlay(context)
    48         , statsOverlayNoise_(0)
    49         , statsOverlayBorder_(0)
     48        , statsOverlayNoise_(nullptr)
     49        , statsOverlayBorder_(nullptr)
    5050    {
    5151        RegisterObject(Stats);

  • code/branches/cpp11_v2/src/modules/pong/Pong.cc

    r10765 r10768  
    6464        RegisterObject(Pong);
    6565
    66         this->center_ = 0;
    67         this->ball_ = 0;
    68         this->bat_[0] = 0;
    69         this->bat_[1] = 0;
     66        this->center_ = nullptr;
     67        this->ball_ = nullptr;
     68        this->bat_[0] = nullptr;
     69        this->bat_[1] = nullptr;
    7070
    7171        this->setHUDTemplate("PongHUD");
    … …  
    106106        {
    107107            this->ball_->destroy();
    108             this->ball_ = 0;
     108            this->ball_ = nullptr;
    109109        }
    110110
    … …  
    115115            {
    116116                this->bat_[0]->destroy();
    117                 this->bat_[0] = 0;
     117                this->bat_[0] = nullptr;
    118118            }
    119119        }
    … …  
    329329            return this->bat_[0]->getPlayer();
    330330        else
    331             return 0;
     331            return nullptr;
    332332    }
    333333
    … …  
    343343            return this->bat_[1]->getPlayer();
    344344        else
    345             return 0;
     345            return nullptr;
    346346    }
    347347}

  • code/branches/cpp11_v2/src/modules/pong/PongAI.cc

    r10765 r10768  
    5757        RegisterObject(PongAI);
    5858
    59         this->ball_ = 0;
     59        this->ball_ = nullptr;
    6060        this->ballDirection_ = Vector2::ZERO;
    6161        this->ballEndPosition_ = 0;

  • code/branches/cpp11_v2/src/modules/pong/PongBall.cc

    r10765 r10768  
    6161        this->speed_ = 0;
    6262        this->accelerationFactor_ = 1.0f;
    63         this->bat_ = 0;
     63        this->bat_ = nullptr;
    6464        this->bDeleteBats_ = false;
    6565        this->batID_ = new unsigned int[2];
    … …  
    8282             else
    8383             {
    84                  this->defScoreSound_ = 0;
    85                  this->defBatSound_ = 0;
    86                  this->defBoundarySound_ = 0;
     84                 this->defScoreSound_ = nullptr;
     85                 this->defBatSound_ = nullptr;
     86                 this->defBoundarySound_ = nullptr;
    8787             }
    8888    }

  • code/branches/cpp11_v2/src/modules/pong/PongScore.cc

    r10765 r10768  
    5555        RegisterObject(PongScore);
    5656
    57         this->owner_ = 0;
     57        this->owner_ = nullptr;
    5858
    5959        this->bShowName_ = false;
    … …  
    172172            this->owner_ = orxonox_cast<Pong*>(this->getOwner()->getGametype());
    173173        else
    174             this->owner_ = 0;
     174            this->owner_ = nullptr;
    175175    }
    176176}

  • code/branches/cpp11_v2/src/modules/portals/PortalEndPoint.cc

    r10765 r10768  
    106106
    107107        MultiTriggerContainer * cont = orxonox_cast<MultiTriggerContainer *>(trigger);
    108         if(cont == 0)
     108        if(cont == nullptr)
    109109            return true;
    110110
    111111        DistanceMultiTrigger * originatingTrigger = orxonox_cast<DistanceMultiTrigger *>(cont->getOriginator());
    112         if(originatingTrigger == 0)
     112        if(originatingTrigger == nullptr)
    113113        {
    114114            return true;
    … …  
    116116
    117117        MobileEntity * entity = orxonox_cast<MobileEntity *>(cont->getData());
    118         if(entity == 0)
     118        if(entity == nullptr)
    119119            return true;
    120120

  • code/branches/cpp11_v2/src/modules/portals/PortalLink.cc

    r9667 r10768  
    4040    std::map<PortalEndPoint *, PortalEndPoint *> PortalLink::links_s;
    4141
    42     PortalLink::PortalLink(Context* context) : BaseObject(context), fromID_(0), toID_(0), from_(0), to_(0)
     42    PortalLink::PortalLink(Context* context) : BaseObject(context), fromID_(0), toID_(0), from_(nullptr), to_(nullptr)
    4343    {
    4444        RegisterObject(PortalLink);
    … …  
    6767    void PortalLink::use(MobileEntity* entity, PortalEndPoint * entrance)
    6868    {
    69         if(entrance == 0)
     69        if(entrance == nullptr)
    7070            return;
    7171

  • code/branches/cpp11_v2/src/modules/tetris/Tetris.cc

    r10765 r10768  
    6666        RegisterObject(Tetris);
    6767
    68         this->activeBrick_ = 0;
     68        this->activeBrick_ = nullptr;
    6969
    7070        // Pre-set the timer, but don't start it yet.
    … …  
    7474        this->player_ = nullptr;
    7575        this->setHUDTemplate("TetrisHUD");
    76         this->futureBrick_ = 0;
     76        this->futureBrick_ = nullptr;
    7777    }
    7878
    … …  
    9696        {
    9797            this->activeBrick_->destroy();
    98             this->activeBrick_ = 0;
     98            this->activeBrick_ = nullptr;
    9999        }
    100100        if (this->futureBrick_)
    101101        {
    102102            this->futureBrick_->destroy();
    103             this->futureBrick_ = 0;
     103            this->futureBrick_ = nullptr;
    104104        }
    105105
    … …  
    396396        // Make the last brick to be created the active brick.
    397397        this->activeBrick_ = this->futureBrick_;
    398         this->futureBrick_ = 0;
     398        this->futureBrick_ = nullptr;
    399399
    400400        // set its position

  • code/branches/cpp11_v2/src/modules/tetris/TetrisScore.cc

    r10765 r10768  
    5656        RegisterObject(TetrisScore);
    5757
    58         this->owner_ = 0;
     58        this->owner_ = nullptr;
    5959        this->player_ = nullptr;
    6060    }
    … …  
    120120            this->owner_ = orxonox_cast<Tetris*>(this->getOwner()->getGametype());
    121121        else
    122             this->owner_ = 0;
     122            this->owner_ = nullptr;
    123123    }
    124124}

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseHUDController.cc

    r10629 r10768  
    3939    {
    4040        RegisterObject(TowerDefenseHUDController);
    41         this->td = 0;
     41        this->td = nullptr;
    4242    }
    4343
    … …  
    8989                    else
    9090                    {
    91                         this->td = 0;
     91                        this->td = nullptr;
    9292                    }
    9393                }

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/ParticleProjectile.cc

    r10624 r10768  
    5858        }
    5959        else
    60             this->particles_ = 0;
     60            this->particles_ = nullptr;
    6161    }
    6262

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/Rocket.cc

    r10622 r10768  
    117117        else
    118118        {
    119             this->defSndWpnEngine_ = 0;
    120             this->defSndWpnLaunch_ = 0;
     119            this->defSndWpnEngine_ = nullptr;
     120            this->defSndWpnLaunch_ = nullptr;
    121121        }
    122122

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/RocketOld.cc

    r10622 r10768  
    117117        else
    118118        {
    119             this->defSndWpnEngine_ = 0;
    120             this->defSndWpnLaunch_ = 0;
     119            this->defSndWpnEngine_ = nullptr;
     120            this->defSndWpnLaunch_ = nullptr;
    121121        }
    122122

  • code/branches/cpp11_v2/src/orxonox/CameraManager.cc

    r10765 r10768  
    6060            return this->cameraList_.front();
    6161        else
    62             return 0;
     62            return nullptr;
    6363    }
    6464

  • code/branches/cpp11_v2/src/orxonox/Level.cc

    r10624 r10768  
    5454        this->registerVariables();
    5555        this->xmlfilename_ = this->getFilename();
    56         this->xmlfile_ = 0;
     56        this->xmlfile_ = nullptr;
    5757    }
    5858
    … …  
    178178            ++i;
    179179        }
    180         return 0;
     180        return nullptr;
    181181    }
    182182
    … …  
    195195            return this->lodInformation_.find(meshName)->second;
    196196
    197         return 0;
     197        return nullptr;
    198198    }
    199199
    … …  
    207207    {
    208208        orxout(internal_info) << "player left level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << endl;
    209         player->switchGametype(0);
     209        player->switchGametype(nullptr);
    210210    }
    211211}

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

    r10765 r10768  
    161161            return this->levels_.front();
    162162        else
    163             return 0;
     163            return nullptr;
    164164    }
    165165

  • code/branches/cpp11_v2/src/orxonox/PlayerManager.cc

    r10624 r10768  
    6262
    6363            // create new HumanPlayer instance
    64             HumanPlayer* player = new HumanPlayer(0);
     64            HumanPlayer* player = new HumanPlayer(nullptr);
    6565            player->setClientID(clientID);
    6666
    … …  
    115115                    return (*it);
    116116        }
    117         return 0;
     117        return nullptr;
    118118    }
    119119}

  • code/branches/cpp11_v2/src/orxonox/Radar.cc

    r10624 r10768  
    4949
    5050    Radar::Radar()
    51         : itFocus_(0)
    52         , focus_(0)
     51        : itFocus_(nullptr)
     52        , focus_(nullptr)
    5353        , objectTypeCounter_(0)
    5454    {
    … …  
    106106            return *(this->itFocus_);
    107107        else
    108             return 0;
     108            return nullptr;
    109109    }
    110110
    … …  
    126126        {
    127127            // focus object was deleted, release focus
    128             this->focus_ = 0;
    129             this->itFocus_ = 0;
     128            this->focus_ = nullptr;
     129            this->itFocus_ = nullptr;
    130130        }
    131131
    … …  
    141141        {
    142142            // list is empty
    143             this->itFocus_ = 0;
    144             this->focus_ = 0;
     143            this->itFocus_ = nullptr;
     144            this->focus_ = nullptr;
    145145        }
    146146
    … …  
    156156            float nextDistance = FLT_MAX;
    157157            float minimumDistance = FLT_MAX;
    158             ObjectList<RadarViewable>::iterator itFallback = 0;
     158            ObjectList<RadarViewable>::iterator itFallback = nullptr;
    159159
    160160            for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it)
    … …  
    191191    void Radar::releaseFocus()
    192192    {
    193         this->itFocus_ = 0;
    194         this->focus_ = 0;
     193        this->itFocus_ = nullptr;
     194        this->focus_ = nullptr;
    195195    }
    196196

  • code/branches/cpp11_v2/src/orxonox/Scene.cc

    r10765 r10768  
    8484            this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
    8585
    86             this->radar_ = 0;
     86            this->radar_ = nullptr;
    8787        }
    8888
    … …  
    9292        this->positiveWorldRange_ = Vector3::UNIT_SCALE *  defaultMaxWorldSize;
    9393        this->gravity_ = Vector3::ZERO;
    94         this->physicalWorld_   = 0;
    95         this->solver_          = 0;
    96         this->dispatcher_      = 0;
    97         this->collisionConfig_ = 0;
    98         this->broadphase_      = 0;
     94        this->physicalWorld_   = nullptr;
     95        this->solver_          = nullptr;
     96        this->dispatcher_      = nullptr;
     97        this->collisionConfig_ = nullptr;
     98        this->broadphase_      = nullptr;
    9999
    100100        this->registerVariables();
    … …  
    234234            delete this->collisionConfig_;
    235235            delete this->broadphase_;
    236             this->physicalWorld_   = 0;
    237             this->solver_          = 0;
    238             this->dispatcher_      = 0;
    239             this->collisionConfig_ = 0;
    240             this->broadphase_      = 0;
     236            this->physicalWorld_   = nullptr;
     237            this->solver_          = nullptr;
     238            this->dispatcher_      = nullptr;
     239            this->collisionConfig_ = nullptr;
     240            this->broadphase_      = nullptr;
    241241        }
    242242    }
    … …  
    327327            ++i;
    328328        }
    329         return 0;
     329        return nullptr;
    330330    }
    331331

  • code/branches/cpp11_v2/src/orxonox/Scene.h

    r10624 r10768  
    111111        public:
    112112            inline bool hasPhysics() const
    113                 { return this->physicalWorld_ != 0; }
     113                { return this->physicalWorld_ != nullptr; }
    114114            void setPhysicalWorld(bool wantsPhysics);
    115115

  • code/branches/cpp11_v2/src/orxonox/Test.cc

    r10624 r10768  
    5454    registerMemberNetworkFunction( Test, printBlaBla );
    5555
    56     Test* Test::instance_ = 0;
     56    Test* Test::instance_ = nullptr;
    5757
    5858    Test::Test(Context* context) : BaseObject(context), Synchronisable(context)
    5959    {
    60         assert(instance_==0);
     60        assert(instance_==nullptr);
    6161        instance_=this;
    6262        RegisterObject ( Test );
    … …  
    6464        registerVariables();
    6565        setSyncMode(0x3);
    66         this->pointer_ = 0;
     66        this->pointer_ = nullptr;
    6767    }
    6868
    6969    Test::~Test()
    7070    {
    71         instance_=0;
     71        instance_=nullptr;
    7272    }
    7373

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CollisionShape.cc

    r10624 r10768  
    5757        RegisterObject(CollisionShape);
    5858
    59         this->parent_ = 0;
     59        this->parent_ = nullptr;
    6060        this->parentID_ = OBJECTID_UNKNOWN;
    61         this->collisionShape_ = 0;
     61        this->collisionShape_ = nullptr;
    6262        this->position_ = Vector3::ZERO;
    6363        this->orientation_ = Quaternion::IDENTITY;
    … …  
    154154    void CollisionShape::notifyDetached()
    155155    {
    156         this->parent_ = 0;
     156        this->parent_ = nullptr;
    157157        this->parentID_ = OBJECTID_UNKNOWN;
    158158    }

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc

    r10765 r10768  
    197197    void CompoundCollisionShape::updatePublicShape()
    198198    {
    199         btCollisionShape* primitive = 0; // The primitive shape, if there is one.
     199        btCollisionShape* primitive = nullptr; // The primitive shape, if there is one.
    200200        bool bPrimitive = true; // Whether the CompoundCollisionShape has just one non-empty CollisionShape. And that shape also has no transformation.
    201201        bool bEmpty = true; // Whether the CompoundCollisionShape is empty.
    … …  
    221221        {
    222222            // If there was none all along, nothing needs to be changed.
    223             if (this->collisionShape_ == 0)
     223            if (this->collisionShape_ == nullptr)
    224224                return;
    225             this->collisionShape_ = 0;
     225            this->collisionShape_ = nullptr;
    226226        }
    227227        // If the CompoundCollisionShape is just a primitive.
    … …  
    253253            ++i;
    254254        }
    255         return 0;
     255        return nullptr;
    256256    }
    257257

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.h

    r9667 r10768  
    7575            void updatePublicShape();
    7676            inline virtual btCollisionShape* createNewShape() const
    77                 { assert(false); return 0; }
     77                { assert(false); return nullptr; }
    7878
    7979            btCompoundShape* compoundShape_;

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/WorldEntityCollisionShape.cc

    r10765 r10768  
    5454        CollisionShape::updateParent();
    5555
    56         assert(this->worldEntityOwner_ != 0);
     56        assert(this->worldEntityOwner_ != nullptr);
    5757        this->worldEntityOwner_->notifyCollisionShapeChanged();
    5858    }

  • code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc

    r10765 r10768  
    177177            {
    178178                this->weaponModes_.clear(); // reset previous weapon information
    179                 WeaponSlot* wSlot = 0;
     179                WeaponSlot* wSlot = nullptr;
    180180                for(int l=0; (wSlot = pawn->getWeaponSlot(l)) ; l++)
    181181                {
    182                     WeaponMode* wMode = 0;
     182                    WeaponMode* wMode = nullptr;
    183183                    for(int i=0; (wMode = wSlot->getWeapon()->getWeaponmode(i)) ; i++)
    184184                    {
    … …  
    249249            return this->waypoints_[index];
    250250        else
    251             return 0;
     251            return nullptr;
    252252    }
    253253

  • code/branches/cpp11_v2/src/orxonox/controllers/Controller.cc

    r9797 r10768  
    4040        RegisterObject(Controller);
    4141
    42         this->player_ = 0;
    43         this->controllableEntity_ = 0;
     42        this->player_ = nullptr;
     43        this->controllableEntity_ = nullptr;
    4444        this->bGodMode_ = false;
    4545        this->team_=-1;

  • code/branches/cpp11_v2/src/orxonox/controllers/DroneController.cc

    r9667 r10768  
    4949        RegisterObject(DroneController);
    5050
    51         this->owner_ = 0;
    52         this->drone_ = 0;
     51        this->owner_ = nullptr;
     52        this->drone_ = nullptr;
    5353        this->isShooting_ = false;
    5454        this->setAccuracy(10);

  • code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc

    r10765 r10768  
    7272        RegisterObject(FormationController);
    7373
    74         this->target_ = 0;
     74        this->target_ = nullptr;
    7575        this->formationFlight_ = false;
    7676        this->passive_ = false;
    7777        this->maxFormationSize_ = STANDARD_MAX_FORMATION_SIZE;
    78         this->myMaster_ = 0;
     78        this->myMaster_ = nullptr;
    7979        this->freedomCount_ = 0;
    8080
    … …  
    104104                    {
    105105                        orxout(internal_error) << this << " is still master in " << (*it) << endl;
    106                         it->myMaster_ = 0;
     106                        it->myMaster_ = nullptr;
    107107                    }
    108108
    … …  
    142142        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    143143        {
    144             Controller* controller = 0;
     144            Controller* controller = nullptr;
    145145
    146146            if (it->getController())
    … …  
    173173        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    174174        {
    175             Controller* controller = 0;
     175            Controller* controller = nullptr;
    176176
    177177            if (it->getController())
    … …  
    203203        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    204204        {
    205             Controller* controller = 0;
     205            Controller* controller = nullptr;
    206206
    207207            if (it->getController())
    … …  
    230230        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    231231        {
    232             Controller* controller = 0;
     232            Controller* controller = nullptr;
    233233
    234234            if (it->getController())
    … …  
    383383        }
    384384
    385         this->myMaster_ = 0;
     385        this->myMaster_ = nullptr;
    386386        this->state_ = FREE;
    387387    }
    … …  
    411411
    412412            //has it an FormationController?
    413             Controller* controller = 0;
     413            Controller* controller = nullptr;
    414414
    415415            if (it->getController())
    … …  
    458458        {
    459459            this->state_ = MASTER;
    460             this->myMaster_ = 0;
     460            this->myMaster_ = nullptr;
    461461        }
    462462    }
    … …  
    518518            newMaster->state_ = MASTER;
    519519            newMaster->slaves_ = this->slaves_;
    520             newMaster->myMaster_ = 0;
     520            newMaster->myMaster_ = nullptr;
    521521
    522522            for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
    … …  
    547547                newMaster->state_ = MASTER;
    548548                newMaster->slaves_ = this->slaves_;
    549                 newMaster->myMaster_ = 0;
     549                newMaster->myMaster_ = nullptr;
    550550
    551551                for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
    … …  
    572572        {
    573573            (*it)->state_ = FREE;
    574             (*it)->myMaster_ = 0;
     574            (*it)->myMaster_ = nullptr;
    575575        }
    576576        this->slaves_.clear();
    … …  
    629629
    630630        //search new Master, then take lead
    631         if (this->state_==FREE && this->myMaster_==0)
     631        if (this->state_==FREE && this->myMaster_==nullptr)
    632632        {
    633633          searchNewMaster();
    … …  
    654654                 (*it)->myMaster_=this;
    655655            }
    656             this->myMaster_=0;
     656            this->myMaster_=nullptr;
    657657            this->state_=MASTER;
    658658        }
    … …  
    779779        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    780780        {
    781             Controller* controller = 0;
     781            Controller* controller = nullptr;
    782782
    783783            if (it->getController())
    … …  
    943943    void FormationController::forgetTarget()
    944944    {
    945         this->target_ = 0;
     945        this->target_ = nullptr;
    946946        this->bShooting_ = false;
    947947    }
    … …  
    963963        int team2 = entity2->getTeam();
    964964
    965         Controller* controller = 0;
     965        Controller* controller = nullptr;
    966966        if (entity1->getController())
    967967            controller = entity1->getController();
    … …  
    996996        }
    997997
    998         TeamBaseMatchBase* base = 0;
     998        TeamBaseMatchBase* base = nullptr;
    999999        base = orxonox_cast<TeamBaseMatchBase*>(entity1);
    10001000        if (base)
    … …  
    10301030        }
    10311031
    1032         DroneController* droneController = 0;
     1032        DroneController* droneController = nullptr;
    10331033        droneController = orxonox_cast<DroneController*>(entity1->getController());
    10341034        if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity2)

  • code/branches/cpp11_v2/src/orxonox/controllers/HumanController.cc

    r10765 r10768  
    6565    RegisterUnloadableClass(HumanController);
    6666
    67     HumanController* HumanController::localController_s = 0;
     67    HumanController* HumanController::localController_s = nullptr;
    6868
    6969    HumanController::HumanController(Context* context) : FormationController(context)
    … …  
    8181            HumanController::localController_s->removeFromFormation();
    8282        }
    83         HumanController::localController_s = 0;
     83        HumanController::localController_s = nullptr;
    8484    }
    8585

  • code/branches/cpp11_v2/src/orxonox/controllers/NewHumanController.cc

    r10765 r10768  
    5858    RegisterUnloadableClass(NewHumanController);
    5959
    60     NewHumanController* NewHumanController::localController_s = 0;
     60    NewHumanController* NewHumanController::localController_s = nullptr;
    6161
    6262    NewHumanController::NewHumanController(Context* context)
    … …  
    445445            pawn->setAimPosition( mouseRay.getOrigin() + mouseRay.getDirection() * 3000 );
    446446
    447         if( this->getControllableEntity() && this->getControllableEntity()->getTarget() != 0 )
    448             this->getControllableEntity()->setTarget( 0 );
     447        if( this->getControllableEntity() && this->getControllableEntity()->getTarget() != nullptr )
     448            this->getControllableEntity()->setTarget( nullptr );
    449449
    450450        //return this->controllableEntity_->getWorldPosition() + (this->controllableEntity_->getWorldOrientation() * Vector3::NEGATIVE_UNIT_Z * 2000);

  • code/branches/cpp11_v2/src/orxonox/controllers/WaypointPatrolController.cc

    r9716 r10768  
    101101
    102102        if (shortestsqdistance > (this->alertnessradius_ * this->alertnessradius_))
    103             this->target_ = 0;
     103            this->target_ = nullptr;
    104104    }
    105105}

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

    r10765 r10768  
    6565    GSLevel::GSLevel(const GameStateInfo& info)
    6666        : GameState(info)
    67         , gameInputState_(0)
    68         , guiMouseOnlyInputState_(0)
    69         , guiKeysOnlyInputState_(0)
    70         , startFile_(0)
     67        , gameInputState_(nullptr)
     68        , guiMouseOnlyInputState_(nullptr)
     69        , guiKeysOnlyInputState_(nullptr)
     70        , startFile_(nullptr)
    7171        , bShowIngameGUI_(false)
    7272    {
    … …  
    143143#endif
    144144
    145             gameInputState_->setHandler(0);
    146             guiMouseOnlyInputState_->setHandler(0);
    147             guiKeysOnlyInputState_->setHandler(0);
     145            gameInputState_->setHandler(nullptr);
     146            guiMouseOnlyInputState_->setHandler(nullptr);
     147            guiKeysOnlyInputState_->setHandler(nullptr);
    148148            InputManager::getInstance().destroyState("game");
    149149            InputManager::getInstance().destroyState("guiKeysOnly");

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

    r10765 r10768  
    132132        InputManager::getInstance().leaveState("MainMenuHackery");
    133133
    134         GraphicsManager::getInstance().setCamera(0);
     134        GraphicsManager::getInstance().setCamera(nullptr);
    135135        GUIManager::getInstance().setBackgroundImage("");
    136136        GUIManager::hideGUI("MainMenu");
    … …  
    140140        ModifyConsoleCommand(__CC_startClient_name    ).deactivate();
    141141        ModifyConsoleCommand(__CC_startDedicated_name ).deactivate();
    142         ModifyConsoleCommand(__CC_setMainMenuSoundPath_name).setObject(0);
     142        ModifyConsoleCommand(__CC_setMainMenuSoundPath_name).setObject(nullptr);
    143143    }
    144144

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

    r10624 r10768  
    9898    void GSRoot::deactivate()
    9999    {
    100         ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(0);
    101         ModifyConsoleCommand(__CC_getTimeFactor_name).setObject(0);
    102         ModifyConsoleCommand(__CC_setPause_name).setObject(0);
    103         ModifyConsoleCommand(__CC_pause_name).setObject(0);
     100        ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(nullptr);
     101        ModifyConsoleCommand(__CC_getTimeFactor_name).setObject(nullptr);
     102        ModifyConsoleCommand(__CC_setPause_name).setObject(nullptr);
     103        ModifyConsoleCommand(__CC_pause_name).setObject(nullptr);
    104104    }
    105105

  • code/branches/cpp11_v2/src/orxonox/gamestates/GSServer.cc

    r10624 r10768  
    4444    GSServer::GSServer(const GameStateInfo& info)
    4545        : GameState(info)
    46         , server_(0)
     46        , server_(nullptr)
    4747    {
    4848    }

  • code/branches/cpp11_v2/src/orxonox/gametypes/Asteroids.h

    r9667 r10768  
    5050
    5151        protected:
    52             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
     52            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
    5353
    5454        private:

  • code/branches/cpp11_v2/src/orxonox/gametypes/Deathmatch.h

    r9667 r10768  
    4747            virtual bool playerChangedName(PlayerInfo* player);
    4848
    49             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
     49            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
    5050            virtual void playerScored(PlayerInfo* player, int score = 1);
    5151    };

  • code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.cc

    r10624 r10768  
    685685        }
    686686
    687         return 0;
     687        return nullptr;
    688688    }
    689689

  • code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.h

    r10624 r10768  
    6464            bool tutorial; //goal: new players receive messages how the new gametype works - later it can be switched off.
    6565
    66             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //ok - score function and management of parties
    67             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //ok - simple
     66            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr); //ok - score function and management of parties
     67            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr); //ok - simple
    6868            virtual void start();
    6969            virtual void end(); //Wie geht das mit der Punkteausgabe aendern? Z.B: Persoenliche Nachricht?

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

    r10765 r10768  
    6666
    6767        this->defaultControllableEntity_ = Class(Spectator);
    68         this->scoreboard_ = 0;
     68        this->scoreboard_ = nullptr;
    6969
    7070        this->bAutoStart_ = false;
    … …  
    361361            return fallbackSpawnPoint;
    362362        }
    363         return 0;
     363        return nullptr;
    364364    }
    365365

  • code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.h

    r10624 r10768  
    9696            virtual void playerScored(PlayerInfo* player, int score = 1);
    9797
    98             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
    99             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
    100             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
    101 
    102             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
     98            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr);
     99            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr);
     100            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
     101
     102            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
    103103            virtual void pawnPreSpawn(Pawn* pawn);
    104104            virtual void pawnPostSpawn(Pawn* pawn);

  • code/branches/cpp11_v2/src/orxonox/gametypes/LastManStanding.h

    r9667 r10768  
    6969            void setConfigValues(); //!< Makes values configurable.
    7070
    71             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
    72             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //!< Manages each players lives.
     71            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
     72            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr); //!< Manages each players lives.
    7373
    7474            virtual void end(); //!< Sends an end message.

  • code/branches/cpp11_v2/src/orxonox/gametypes/LastTeamStanding.h

    r9667 r10768  
    7777            virtual bool playerLeft(PlayerInfo* player); //!< Manages all local variables.
    7878
    79             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //!< Manages each player's lost lives.
    80             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
     79            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr); //!< Manages each player's lost lives.
     80            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
    8181            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn); //!< Resets punishment time and respawn delay.
    8282            void tick (float dt); //!< used to end the game

  • code/branches/cpp11_v2/src/orxonox/gametypes/Mission.h

    r9729 r10768  
    5858
    5959        protected:
    60             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
     60            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
    6161            bool missionAccomplished_; //<! indicates if player successfully finsihed the mission;
    6262            int lives_; //<! amount of player's lives <-> nr. of retries

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.cc

    r9667 r10768  
    264264                return (*it);
    265265        }
    266         return 0;
     266        return nullptr;
    267267    }
    268268

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.h

    r9667 r10768  
    4444            virtual ~TeamBaseMatch() {}
    4545
    46             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
     46            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
    4747            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator);
    4848

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamDeathmatch.h

    r9941 r10768  
    4848            virtual bool playerChangedName(PlayerInfo* player);
    4949
    50             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
     50            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
    5151            virtual void playerScored(PlayerInfo* player, int score = 1);
    5252       protected:

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc

    r10765 r10768  
    277277        }
    278278
    279         return 0;
     279        return nullptr;
    280280    }
    281281
    … …  
    340340        ControllableEntity* entity = orxonox_cast<ControllableEntity*>(pawn);
    341341
    342         Controller* controller = 0;
     342        Controller* controller = nullptr;
    343343        if (entity->getController())
    344344            controller = entity->getController();

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.h

    r9941 r10768  
    5151            virtual void spawnDeadPlayersIfRequested(); //!< Prevents players to respawn.
    5252
    53             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
    54             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
    55             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
     53            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr);
     54            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr);
     55            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
    5656
    5757            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);

  • code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.cc

    r9941 r10768  
    4848        this->gameTime_ = 180;
    4949        this->teams_ = 2;
    50         this->destroyer_ = 0;
     50        this->destroyer_ = nullptr;
    5151        this->destroyer_.setCallback(createFunctor(&UnderAttack::killedDestroyer, this));
    5252        this->gameEnded_ = false;
    … …  
    202202    void UnderAttack::setTransporterHealth()
    203203    {
    204         if (this->destroyer_ != 0)
     204        if (this->destroyer_ != nullptr)
    205205        {
    206206            //Calculation: Each attacker deals about 3500 damage. A human attacker deals 1500 damage additionally.

  • code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.h

    r9941 r10768  
    4848                { return this->destroyer_; }
    4949
    50             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
    51             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
    52             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
     50            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr);
     51            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr);
     52            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
    5353            virtual void playerEntered(PlayerInfo* player);
    5454

  • code/branches/cpp11_v2/src/orxonox/graphics/Backlight.cc

    r9667 r10768  
    5151        RegisterObject(Backlight);
    5252
    53         this->ribbonTrail_ = 0;
    54         this->ribbonTrailNode_ = 0;
     53        this->ribbonTrail_ = nullptr;
     54        this->ribbonTrailNode_ = nullptr;
    5555
    5656        this->width_ = 0;

  • code/branches/cpp11_v2/src/orxonox/graphics/Light.cc

    r9667 r10768  
    5353        RegisterObject(Light);
    5454
    55         this->light_ = 0;
     55        this->light_ = nullptr;
    5656        this->diffuse_ = ColourValue::White;
    5757        this->specular_ = ColourValue::White;

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

    r10765 r10768  
    134134            Level* level = this->getLevel();
    135135
    136             assert( level != 0 );
     136            assert( level != nullptr );
    137137
    138138            MeshLodInformation* lodInfo = level->getLodInfo(this->meshSrc_);

  • code/branches/cpp11_v2/src/orxonox/graphics/ParticleEmitter.cc

    r9950 r10768  
    5252            ThrowException(AbortLoading, "Can't create ParticleEmitter, no scene or no scene manager given.");
    5353
    54         this->particles_ = 0;
     54        this->particles_ = nullptr;
    5555        this->LOD_ = LODParticle::Normal;
    5656
    … …  
    102102        {
    103103            delete this->particles_;
    104             this->particles_ = 0;
     104            this->particles_ = nullptr;
    105105        }
    106106

  • code/branches/cpp11_v2/src/orxonox/infos/HumanPlayer.cc

    r10624 r10768  
    5353        this->defaultController_ = Class(NewHumanController);
    5454
    55         this->humanHud_ = 0;
    56         this->gametypeHud_ = 0;
     55        this->humanHud_ = nullptr;
     56        this->gametypeHud_ = nullptr;
    5757
    5858        this->setConfigValues();
    … …  
    178178        {
    179179            this->humanHud_->destroy();
    180             this->humanHud_ = 0;
     180            this->humanHud_ = nullptr;
    181181        }
    182182
    … …  
    194194        {
    195195            this->gametypeHud_->destroy();
    196             this->gametypeHud_ = 0;
     196            this->gametypeHud_ = nullptr;
    197197        }
    198198

  • code/branches/cpp11_v2/src/orxonox/infos/PlayerInfo.cc

    r10765 r10768  
    5151        this->bReadyToSpawn_ = false;
    5252        this->bSetUnreadyAfterSpawn_ = true;
    53         this->controller_ = 0;
    54         this->controllableEntity_ = 0;
     53        this->controller_ = nullptr;
     54        this->controllableEntity_ = nullptr;
    5555        this->controllableEntityID_ = OBJECTID_UNKNOWN;
    5656
    57         this->gtinfo_ = 0;
     57        this->gtinfo_ = nullptr;
    5858        this->gtinfoID_ = OBJECTID_UNKNOWN;
    5959        this->updateGametypeInfo(this->getGametype());
    … …  
    7272            {
    7373                this->controller_->destroy();
    74                 this->controller_ = 0;
     74                this->controller_ = nullptr;
    7575            }
    7676
    … …  
    126126    void PlayerInfo::updateGametypeInfo(Gametype* gametype)
    127127    {
    128         this->gtinfo_ = 0;
     128        this->gtinfo_ = nullptr;
    129129        this->gtinfoID_ = OBJECTID_UNKNOWN;
    130130
    … …  
    141141        {
    142142            this->controller_->destroy();
    143             this->controller_ = 0;
     143            this->controller_ = nullptr;
    144144        }
    145145        this->controller_ = this->defaultController_.fabricate(this->getContext());
    … …  
    214214            return;
    215215
    216         this->controllableEntity_->setController(0);
    217         this->controllableEntity_ = 0;
     216        this->controllableEntity_->setController(nullptr);
     217        this->controllableEntity_ = nullptr;
    218218        this->controllableEntityID_ = OBJECTID_UNKNOWN;
    219219
    220220        if (this->controller_)
    221             this->controller_->setControllableEntity(0);
     221            this->controller_->setControllableEntity(nullptr);
    222222
    223223        if ( GameMode::isMaster() )
    … …  
    242242        tmp->setActive(false);
    243243        //this->controllableEntity_->getController()->setControllableEntity(nullptr);
    244         this->controllableEntity_->setController(0);
     244        this->controllableEntity_->setController(nullptr);
    245245    }
    246246
    … …  
    253253            return;
    254254
    255         this->controllableEntity_->setController(0);
     255        this->controllableEntity_->setController(nullptr);
    256256        if(this->isHumanPlayer()) // TODO: Multiplayer?
    257257            this->controllableEntity_->destroyHud(); // HACK-ish

  • code/branches/cpp11_v2/src/orxonox/interfaces/RadarViewable.h

    r10624 r10768  
    6666                if (name == "HIDDEN")
    6767                {
    68                     this->bVisibility_ = 0;
     68                    this->bVisibility_ = false;
    6969                    this->settingsChanged();
    7070                }

  • code/branches/cpp11_v2/src/orxonox/items/Engine.cc

    r10765 r10768  
    5050        RegisterObject(Engine);
    5151
    52         this->ship_ = 0;
     52        this->ship_ = nullptr;
    5353        this->shipID_ = OBJECTID_UNKNOWN;
    5454        this->relativePosition_ = Vector3::ZERO;
    … …  
    136136    void Engine::networkcallback_shipID()
    137137    {
    138         this->ship_ = 0;
     138        this->ship_ = nullptr;
    139139
    140140        if (this->shipID_ != OBJECTID_UNKNOWN)

  • code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc

    r10765 r10768  
    6767        else
    6868        {
    69             this->defEngineSndBoost_ = 0;
    70             this->defEngineSndNormal_ = 0;
    71             this->lua_ = 0;
     69            this->defEngineSndBoost_ = nullptr;
     70            this->defEngineSndNormal_ = nullptr;
     71            this->lua_ = nullptr;
    7272        }
    7373        this->state_ = 0;

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

    r10624 r10768  
    7575        : shell_(new Shell("InGameConsole", true))
    7676        , bShowCursor_(false)
    77         , consoleOverlay_(0)
    78         , consoleOverlayContainer_(0)
    79         , consoleOverlayNoise_(0)
    80         , consoleOverlayCursor_(0)
    81         , consoleOverlayBorder_(0)
    82         , consoleOverlayTextAreas_(0)
    83         , inputState_(0)
     77        , consoleOverlay_(nullptr)
     78        , consoleOverlayContainer_(nullptr)
     79        , consoleOverlayNoise_(nullptr)
     80        , consoleOverlayCursor_(nullptr)
     81        , consoleOverlayBorder_(nullptr)
     82        , consoleOverlayTextAreas_(nullptr)
     83        , inputState_(nullptr)
    8484    {
    8585        RegisterObject(InGameConsole);
    … …  
    130130                    if (this->consoleOverlayTextAreas_[i])
    131131                        Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->consoleOverlayTextAreas_[i]);
    132                     this->consoleOverlayTextAreas_[i] = 0;
     132                    this->consoleOverlayTextAreas_[i] = nullptr;
    133133                }
    134134
    … …  
    140140        {
    141141            delete[] this->consoleOverlayTextAreas_;
    142             this->consoleOverlayTextAreas_ = 0;
     142            this->consoleOverlayTextAreas_ = nullptr;
    143143        }
    144144
    … …  
    175175            else
    176176            {
    177                 inputState_->setMouseHandler(0);
    178                 inputState_->setJoyStickHandler(0);
     177                inputState_->setMouseHandler(nullptr);
     178                inputState_->setJoyStickHandler(nullptr);
    179179            }
    180180        }

  • code/branches/cpp11_v2/src/orxonox/overlays/OrxonoxOverlay.cc

    r10624 r10768  
    7070        RegisterObject(OrxonoxOverlay);
    7171
    72         this->owner_ = 0;
    73         this->group_ = 0;
     72        this->owner_ = nullptr;
     73        this->group_ = nullptr;
    7474
    7575        if (!GameMode::showsGraphics())

  • code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc

    r10624 r10768  
    5454        RegisterObject(OverlayGroup);
    5555
    56         this->owner_ = 0;
     56        this->owner_ = nullptr;
    5757
    5858        setScale(Vector2(1.0, 1.0));
    … …  
    139139        }
    140140        else
    141             return 0;
     141            return nullptr;
    142142    }
    143143

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/Munition.cc

    r9667 r10768  
    6565            // For separated magazines we definitively need a given user
    6666            if (!user)
    67                 return 0;
     67                return nullptr;
    6868
    6969            // Use the map to get the magazine assigned to the given user
    … …  
    7979        }
    8080
    81         return 0;
     81        return nullptr;
    8282    }
    8383
    … …  
    236236        // If we don't use separate magazines, set user to 0
    237237        if (!this->bUseSeparateMagazines_)
    238             user = 0;
     238            user = nullptr;
    239239
    240240        // Remove the current magazine for the given user
    … …  
    442442        // If we don't use separate magazines, set user to 0
    443443        if (!this->bUseSeparateMagazines_)
    444             user = 0;
     444            user = nullptr;
    445445
    446446        // Remove the current magazine for the given user

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/Weapon.cc

    r10650 r10768  
    4545        RegisterObject(Weapon);
    4646
    47         this->weaponPack_ = 0;
    48         this->weaponSlot_ = 0;
     47        this->weaponPack_ = nullptr;
     48        this->weaponSlot_ = nullptr;
    4949        this->bReloading_ = false;
    5050        this->reloadingWeaponmode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
    … …  
    9292            ++i;
    9393        }
    94         return 0;
     94        return nullptr;
    9595    }
    9696

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponMode.cc

    r10650 r10768  
    5151        RegisterObject(WeaponMode);
    5252
    53         this->weapon_ = 0;
     53        this->weapon_ = nullptr;
    5454        this->mode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
    5555
    56         this->munition_ = 0;
     56        this->munition_ = nullptr;
    5757        this->initialMunition_ = 0;
    5858        this->initialMagazines_ = 0;
    … …  
    232232        }
    233233        else
    234             this->munition_ = 0;
     234            this->munition_ = nullptr;
    235235    }
    236236

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc

    r10650 r10768  
    4444        RegisterObject(WeaponPack);
    4545
    46         this->weaponSystem_ = 0;
     46        this->weaponSystem_ = nullptr;
    4747    }
    4848
    … …  
    107107        assert(it != this->weapons_.end());
    108108        this->weapons_.erase(it);
    109         weapon->setWeaponPack(0);
     109        weapon->setWeaponPack(nullptr);
    110110    }
    111111
    … …  
    121121        }
    122122
    123         return 0;
     123        return nullptr;
    124124    }
    125125
    … …  
    139139            ++i;
    140140        }
    141         return 0;
     141        return nullptr;
    142142    }
    143143

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSet.cc

    r10650 r10768  
    4343        RegisterObject(WeaponSet);
    4444
    45         this->weaponSystem_ = 0;
     45        this->weaponSystem_ = nullptr;
    4646        this->desiredFiremode_ = WeaponSystem::FIRE_MODE_UNASSIGNED;
    4747    }

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSlot.cc

    r10648 r10768  
    4343        RegisterObject(WeaponSlot);
    4444
    45         this->weaponSystem_ = 0;
    46         this->weapon_ = 0;
     45        this->weaponSystem_ = nullptr;
     46        this->weapon_ = nullptr;
    4747
    4848        this->setSyncMode(ObjectDirection::None);
    … …  
    8888        if (this->weapon_)
    8989        {
    90             this->weapon_->setWeaponSlot(0);
    91             this->weapon_ = 0;
     90            this->weapon_->setWeaponSlot(nullptr);
     91            this->weapon_ = nullptr;
    9292        }
    9393    }

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSlot.h

    r10650 r10768  
    7474            */
    7575            inline bool isOccupied() const
    76                 { return (this->weapon_ != 0); }
     76                { return (this->weapon_ != nullptr); }
    7777
    7878            inline void setWeaponSystem(WeaponSystem * weaponSystem)

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSystem.cc

    r10650 r10768  
    5252        RegisterObject(WeaponSystem);
    5353
    54         this->pawn_ = 0;
     54        this->pawn_ = nullptr;
    5555    }
    5656
    … …  
    6060        {
    6161            if (this->pawn_)
    62                 this->pawn_->setWeaponSystem(0);
     62                this->pawn_->setWeaponSystem(nullptr);
    6363
    6464            while (!this->weaponSets_.empty())
    … …  
    112112                return (*it);
    113113        }
    114         return 0;
     114        return nullptr;
    115115    }
    116116
    … …  
    159159                return it->second;
    160160        }
    161         return 0;
     161        return nullptr;
    162162    }
    163163
    … …  
    213213        // Remove all weapons from their WeaponSlot
    214214        unsigned int i = 0;
    215         Weapon* weapon = 0;
     215        Weapon* weapon = nullptr;
    216216        while ((weapon = wPack->getWeapon(i++)))
    217217            if (weapon->getWeaponSlot())
    … …  
    237237                return (*it);
    238238        }
    239         return 0;
     239        return nullptr;
    240240    }
    241241
    … …  
    303303    {
    304304        if (!identifier || !identifier->getIdentifier())
    305             return 0;
     305            return nullptr;
    306306
    307307        std::map<Identifier *, Munition *>::iterator it = this->munitions_.find(identifier->getIdentifier());
    … …  
    318318        else
    319319        {
    320             return 0;
     320            return nullptr;
    321321        }
    322322    }

  • code/branches/cpp11_v2/src/orxonox/worldentities/BigExplosion.cc

    r9952 r10768  
    204204    void BigExplosion::initZero()
    205205    {
    206         this->debrisFire1_ = 0;
    207         this->debrisFire2_ = 0;
    208         this->debrisFire3_ = 0;
    209         this->debrisFire4_ = 0;
    210 
    211         this->debrisSmoke1_ = 0;
    212         this->debrisSmoke2_ = 0;
    213         this->debrisSmoke3_ = 0;
    214         this->debrisSmoke4_ = 0;
    215 
    216         this->explosionSmoke_=0;
    217         this->explosionFire_=0;
     206        this->debrisFire1_ = nullptr;
     207        this->debrisFire2_ = nullptr;
     208        this->debrisFire3_ = nullptr;
     209        this->debrisFire4_ = nullptr;
     210
     211        this->debrisSmoke1_ = nullptr;
     212        this->debrisSmoke2_ = nullptr;
     213        this->debrisSmoke3_ = nullptr;
     214        this->debrisSmoke4_ = nullptr;
     215
     216        this->explosionSmoke_=nullptr;
     217        this->explosionFire_=nullptr;
    218218    }
    219219

  • code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc

    r10765 r10768  
    6161        this->server_overwrite_ = 0;
    6262        this->client_overwrite_ = 0;
    63         this->player_ = 0;
     63        this->player_ = nullptr;
    6464        this->formerPlayer_ = nullptr;
    6565        this->playerID_ = OBJECTID_UNKNOWN;
    66         this->hud_ = 0;
    67         this->camera_ = 0;
    68         this->xmlcontroller_ = 0;
    69         //this->controller_ = 0;
    70         this->reverseCamera_ = 0;
     66        this->hud_ = nullptr;
     67        this->camera_ = nullptr;
     68        this->xmlcontroller_ = nullptr;
     69        //this->controller_ = nullptr;
     70        this->reverseCamera_ = nullptr;
    7171        this->bDestroyWhenPlayerLeft_ = false;
    7272        this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
    73         this->currentCameraPosition_ = 0;
     73        this->currentCameraPosition_ = nullptr;
    7474        this->bMouseLook_ = false;
    7575        this->mouseLookSpeed_ = 200;
    … …  
    171171            ++i;
    172172        }
    173         return 0;
     173        return nullptr;
    174174    }
    175175
    … …  
    241241            {
    242242                this->camera_->attachToNode(this->cameraPositionRootNode_);
    243                 this->currentCameraPosition_ = 0;
     243                this->currentCameraPosition_ = nullptr;
    244244            }
    245245
    … …  
    321321        if ( !GameMode::isMaster() )
    322322        {
    323             if ( target != 0 )
     323            if ( target != nullptr )
    324324            {
    325325                callMemberNetworkFunction(&ControllableEntity::setTargetInternal, this->getObjectID(), 0, target->getObjectID() );
    … …  
    372372            this->stopLocalHumanControl();
    373373
    374         this->player_ = 0;
     374        this->player_ = nullptr;
    375375        this->playerID_ = OBJECTID_UNKNOWN;
    376376        this->bHasLocalController_ = false;
    … …  
    411411            {
    412412                this->camera_->attachToNode(this->cameraPositionRootNode_);
    413                 this->currentCameraPosition_ = 0;
     413                this->currentCameraPosition_ = nullptr;
    414414            }
    415415        }
    … …  
    447447            this->camera_->detachFromParent();
    448448            this->camera_->destroy();
    449             this->camera_ = 0;
     449            this->camera_ = nullptr;
    450450        }
    451451
    … …  
    453453        {
    454454            this->hud_->destroy();
    455             this->hud_ = 0;
     455            this->hud_ = nullptr;
    456456        }
    457457    }

  • code/branches/cpp11_v2/src/orxonox/worldentities/Drone.cc

    r9667 r10768  
    4343        RegisterObject(Drone);
    4444
    45         this->myController_ = 0;
     45        this->myController_ = nullptr;
    4646
    4747        this->localLinearAcceleration_.setValue(0, 0, 0);

  • code/branches/cpp11_v2/src/orxonox/worldentities/ExplosionChunk.cc

    r9667 r10768  
    6262            {
    6363                orxout(internal_error) << "Couldn't load particle effect in ExplosionChunk: " << ex.what() << endl;
    64                 this->fire_ = 0;
    65                 this->smoke_ = 0;
     64                this->fire_ = nullptr;
     65                this->smoke_ = nullptr;
    6666            }
    6767        }
    6868        else
    6969        {
    70             this->fire_ = 0;
    71             this->smoke_ = 0;
     70            this->fire_ = nullptr;
     71            this->smoke_ = nullptr;
    7272        }
    7373

  • code/branches/cpp11_v2/src/orxonox/worldentities/MovableEntity.cc

    r10216 r10768  
    5050        this->overwrite_orientation_ = Quaternion::IDENTITY;
    5151
    52         this->continuousResynchroTimer_ = 0;
     52        this->continuousResynchroTimer_ = nullptr;
    5353
    5454        this->setPriority(Priority::Low);
    … …  
    8080            {
    8181                float damage = this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length();
    82                 victim->hit(0, contactPoint, ownCollisionShape, damage);
     82                victim->hit(nullptr, contactPoint, ownCollisionShape, damage);
    8383            }
    8484        }

  • code/branches/cpp11_v2/src/orxonox/worldentities/SpawnPoint.cc

    r9667 r10768  
    4343        RegisterObject(SpawnPoint);
    4444
    45         this->template_ = 0;
     45        this->template_ = nullptr;
    4646
    4747        if (this->getGametype())

  • code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc

    r10765 r10768  
    7777        this->node_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
    7878
    79         this->parent_ = 0;
     79        this->parent_ = nullptr;
    8080        this->parentID_ = OBJECTID_UNKNOWN;
    8181        this->bDeleteWithParent_ = true;
    … …  
    9090
    9191        // Default behaviour does not include physics
    92         this->physicalBody_   = 0;
     92        this->physicalBody_   = nullptr;
    9393        this->bPhysicsActive_ = false;
    9494        this->bPhysicsActiveSynchronised_    = false;
    … …  
    498498    void WorldEntity::notifyDetached()
    499499    {
    500         this->parent_ = 0;
     500        this->parent_ = nullptr;
    501501        this->parentID_ = OBJECTID_UNKNOWN;
    502502
    … …  
    525525            ++i;
    526526        }
    527         return 0;
     527        return nullptr;
    528528    }
    529529
    … …  
    856856            deactivatePhysics();
    857857            delete this->physicalBody_;
    858             this->physicalBody_ = 0;
     858            this->physicalBody_ = nullptr;
    859859            this->collisionType_ = None;
    860860            this->collisionTypeSynchronised_ = None;

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc

    r10765 r10768  
    5353    RegisterClass(ModularSpaceShip);
    5454
    55     std::map<StaticEntity*, ShipPart*>* ModularSpaceShip::partMap_s = 0;
     55    std::map<StaticEntity*, ShipPart*>* ModularSpaceShip::partMap_s = nullptr;
    5656
    5757    ModularSpaceShip::ModularSpaceShip(Context* context) : SpaceShip(context)

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.cc

    r10650 r10768  
    7676        this->reloadWaitCountdown_ = 0;
    7777
    78         this->lastHitOriginator_ = 0;
     78        this->lastHitOriginator_ = nullptr;
    7979
    8080        // set damage multiplier to default value 1, meaning nominal damage
    … …  
    9191        }
    9292        else
    93             this->weaponSystem_ = 0;
     93            this->weaponSystem_ = nullptr;
    9494
    9595        this->setRadarObjectColour(ColourValue::Red);
    … …  
    109109        else
    110110        {
    111             this->explosionSound_ = 0;
     111            this->explosionSound_ = nullptr;
    112112        }
    113113    }
    … …  
    345345                    {
    346346                        // delete the AIController // <-- TODO: delete? nothing is deleted here... should we delete the controller?
    347                         slave->setControllableEntity(0);
     347                        slave->setControllableEntity(nullptr);
    348348
    349349                        // set a new master within the formation
    … …  
    509509            return this->weaponSystem_->getWeaponSlot(index);
    510510        else
    511             return 0;
     511            return nullptr;
    512512    }
    513513
    … …  
    523523            return this->weaponSystem_->getWeaponSet(index);
    524524        else
    525             return 0;
     525            return nullptr;
    526526    }
    527527
    … …  
    551551            return this->weaponSystem_->getWeaponPack(index);
    552552        else
    553             return 0;
     553            return nullptr;
    554554    }
    555555
    … …  
    594594                return it->getController();
    595595        }
    596         return 0;
     596        return nullptr;
    597597    }
    598598

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.h

    r10765 r10768  
    207207            virtual void spawneffect();
    208208
    209             //virtual void damage(float damage, Pawn* originator = 0);
     209            //virtual void damage(float damage, Pawn* originator = nullptr);
    210210            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
    211211

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc

    r10765 r10768  
    494494            Camera* camera = this->getCamera();
    495495            //Shaking Camera effect
    496             if (camera != 0)
     496            if (camera != nullptr)
    497497                camera->setOrientation(Vector3::UNIT_X, angle);
    498498
    … …  
    526526        {
    527527            Camera *camera = this->getCamera();
    528             if (camera == 0)
     528            if (camera == nullptr)
    529529            {
    530530                orxout(internal_warning) << "Failed to reset camera!" << endl;

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Spectator.cc

    r10624 r10768  
    5858        this->localVelocity_ = Vector3::ZERO;
    5959        this->setHudTemplate("spectatorhud");
    60         this->greetingFlare_ = 0;
     60        this->greetingFlare_ = nullptr;
    6161
    6262        this->setDestroyWhenPlayerLeft(true);

  • code/branches/cpp11_v2/test/core/command/CommandTest.cc

    r10765 r10768  
    129129                ModifyConsoleCommand("test").popObject();
    130130            else if (a == 1)
    131                 ModifyConsoleCommand("test").setFunction(FunctorPtr(0));
     131                ModifyConsoleCommand("test").setFunction(FunctorPtr(nullptr));
    132132            else if (a == -1)
    133133                ModifyConsoleCommand("test").popFunction();

  • code/branches/cpp11_v2/test/core/object/StrongPtrTest.cc

    r10765 r10768  
    112112    {
    113113        EXPECT_TRUE(strongPtr == nullptr);
    114         EXPECT_TRUE(strongPtr == 0);
     114        EXPECT_TRUE(strongPtr == nullptr);
    115115        EXPECT_TRUE(!strongPtr);
    116116        EXPECT_FALSE(strongPtr != nullptr);
    117         EXPECT_FALSE(strongPtr != 0);
     117        EXPECT_FALSE(strongPtr != nullptr);
    118118        EXPECT_FALSE(strongPtr);
    119119    }
    … …  
    135135        }
    136136        {
    137             StrongPtr<DestroyableTest> strongPtr = 0;
     137            StrongPtr<DestroyableTest> strongPtr = nullptr;
    138138            isNull(strongPtr);
    139139        }
    140140        {
    141141            StrongPtr<DestroyableTest> strongPtr;
    142             strongPtr = 0;
     142            strongPtr = nullptr;
    143143            isNull(strongPtr);
    144144        }
    … …  
    151151        StrongPtr<DestroyableTest> strongPtr = test;
    152152        EXPECT_FALSE(strongPtr == nullptr);
    153         EXPECT_FALSE(strongPtr == 0);
     153        EXPECT_FALSE(strongPtr == nullptr);
    154154        EXPECT_FALSE(!strongPtr);
    155155        EXPECT_TRUE(strongPtr != nullptr);
    156         EXPECT_TRUE(strongPtr != 0);
     156        EXPECT_TRUE(strongPtr != nullptr);
    157157        EXPECT_TRUE(strongPtr);
    158158        test->destroy();

  • code/branches/cpp11_v2/test/core/object/WeakPtrTest.cc

    r10765 r10768  
    6767    {
    6868        EXPECT_TRUE(weakPtr == nullptr);
    69         EXPECT_TRUE(weakPtr == 0);
     69        EXPECT_TRUE(weakPtr == nullptr);
    7070        EXPECT_TRUE(!weakPtr);
    7171        EXPECT_FALSE(weakPtr != nullptr);
    72         EXPECT_FALSE(weakPtr != 0);
     72        EXPECT_FALSE(weakPtr != nullptr);
    7373        EXPECT_FALSE(weakPtr);
    7474    }
    … …  
    9090        }
    9191        {
    92             WeakPtr<DestroyableTest> weakPtr = 0;
     92            WeakPtr<DestroyableTest> weakPtr = nullptr;
    9393            isNull(weakPtr);
    9494        }
    9595        {
    9696            WeakPtr<DestroyableTest> weakPtr;
    97             weakPtr = 0;
     97            weakPtr = nullptr;
    9898            isNull(weakPtr);
    9999        }
    … …  
    105105        WeakPtr<DestroyableTest> weakPtr = test;
    106106        EXPECT_FALSE(weakPtr == nullptr);
    107         EXPECT_FALSE(weakPtr == 0);
     107        EXPECT_FALSE(weakPtr == nullptr);
    108108        EXPECT_FALSE(!weakPtr);
    109109        EXPECT_TRUE(weakPtr != nullptr);
    110         EXPECT_TRUE(weakPtr != 0);
     110        EXPECT_TRUE(weakPtr != nullptr);
    111111        EXPECT_TRUE(weakPtr);
    112112        test->destroy();

  • code/branches/cpp11_v2/test/util/SharedPtrTest.cc

    r10765 r10768  
    4141    {
    4242        SharedPtr<TestClass> test;
    43         EXPECT_EQ(0, test.get());
     43        EXPECT_EQ(nullptr, test.get());
    4444    }
    4545
    … …  
    9191
    9292        SharedPtr<TestClass> test;
    93         EXPECT_EQ(0, test.get());
     93        EXPECT_EQ(nullptr, test.get());
    9494
    9595        test = other;
    … …  
    105105
    106106        SharedPtr<TestClass> test;
    107         EXPECT_EQ(0, test.get());
     107        EXPECT_EQ(nullptr, test.get());
    108108
    109109        test = other;
    … …  
    138138    {
    139139        SharedPtr<TestClass> test;
    140         EXPECT_EQ(0, test.get());
     140        EXPECT_EQ(nullptr, test.get());
    141141        EXPECT_FALSE(test);
    142142

  • code/branches/cpp11_v2/test/util/SmallObjectAllocatorTest.cc

    r9114 r10768  
    4747        // create an integer
    4848        size_t* pointer = this->create(5);
    49         ASSERT_NE((void*)0, pointer);
     49        ASSERT_NE((void*)nullptr, pointer);
    5050        EXPECT_EQ(5u, *pointer);
    5151    }
    … …  
    5555        // create an integer
    5656        size_t* pointer = this->create(5);
    57         ASSERT_NE((void*)0, pointer);
     57        ASSERT_NE((void*)nullptr, pointer);
    5858        EXPECT_EQ(5u, *pointer);
    5959
    … …  
    228228        // create an object
    229229        SmallObject* pointer = this->create(5);
    230         ASSERT_NE((void*)0, pointer);
     230        ASSERT_NE((void*)nullptr, pointer);
    231231        EXPECT_EQ(5u, pointer->getValue());
    232232        EXPECT_EQ(5u, SmallObject::total_s);
    … …  
    239239        // create an object
    240240        SmallObject* pointer = this->create(5);
    241         ASSERT_NE((void*)0, pointer);
     241        ASSERT_NE((void*)nullptr, pointer);
    242242        EXPECT_EQ(5u, pointer->getValue());
    243243        EXPECT_EQ(5u, SmallObject::total_s);
Note: See TracChangeset for help on using the changeset viewer.