Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Aug 25, 2013, 9:08:42 PM (11 years ago)
Author:
landauf
Message:

merged core6 back to trunk

Location:
code/trunk
Files:
199 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/orxonox/CameraManager.cc

    r9348 r9667  
    3838#include "core/GameMode.h"
    3939#include "core/GraphicsManager.h"
    40 #include "core/ObjectList.h"
     40#include "core/object/ObjectList.h"
    4141#include "tools/Shader.h"
    4242#include "graphics/Camera.h"
    … …  
    4848    CameraManager::CameraManager()
    4949    {
    50         RegisterRootObject(CameraManager);
    51 
    5250        assert(GameMode::showsGraphics());
    5351    }

  • code/trunk/src/orxonox/CameraManager.h

    r8079 r9667  
    4141#include "util/OgreForwardRefs.h"
    4242#include "util/Singleton.h"
    43 #include "core/OrxonoxClass.h"
    4443
    4544namespace orxonox
    4645{
    47     class _OrxonoxExport CameraManager : public Singleton<CameraManager>, public OrxonoxClass
     46    class _OrxonoxExport CameraManager : public Singleton<CameraManager>
    4847    {
    4948            friend class Singleton<CameraManager>;

  • code/trunk/src/orxonox/Level.cc

    r9016 r9667  
    4343namespace orxonox
    4444{
    45     CreateFactory(Level);
     45    RegisterClass(Level);
    4646
    47     Level::Level(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     47    Level::Level(Context* context) : BaseObject(context), Synchronisable(context), Context(context)
    4848    {
    4949        RegisterObject(Level);

  • code/trunk/src/orxonox/Level.h

    r9016 r9667  
    4141namespace orxonox
    4242{
    43     class _OrxonoxExport Level : public BaseObject, public Synchronisable
     43    class _OrxonoxExport Level : public BaseObject, public Synchronisable, public Context
    4444    {
    4545        public:
    46             Level(BaseObject* creator);
     46            Level(Context* context);
    4747            virtual ~Level();
    4848

  • code/trunk/src/orxonox/LevelInfo.cc

    r9348 r9667  
    242242    // LevelInfo
    243243
    244     CreateFactory(LevelInfo);
     244    RegisterClass(LevelInfo);
    245245
    246246    /**
    … …  
    250250        The creator of this object.
    251251    */
    252     LevelInfo::LevelInfo(BaseObject* creator) : BaseObject(creator)
     252    LevelInfo::LevelInfo(Context* context) : BaseObject(context)
    253253    {
    254254        RegisterObject(LevelInfo);

  • code/trunk/src/orxonox/LevelInfo.h

    r9348 r9667  
    4545#include <iostream>
    4646#include <fstream>
    47 #include "core/OrxonoxClass.h"
     47#include "core/class/OrxonoxInterface.h"
    4848
    4949namespace orxonox // tolua_export
    … …  
    6161    */
    6262    class _OrxonoxExport LevelInfoItem // tolua_export
    63         : virtual public OrxonoxClass
     63        : virtual public OrxonoxInterface
    6464    { // tolua_export
    6565        public:
    … …  
    204204    {
    205205        public:
    206             LevelInfo(BaseObject* creator);
     206            LevelInfo(Context* context);
    207207            virtual ~LevelInfo();
    208208

  • code/trunk/src/orxonox/LevelManager.cc

    r9550 r9667  
    3737
    3838#include "util/ScopedSingletonManager.h"
     39#include "core/config/CommandLineParser.h"
     40#include "core/config/ConfigValueIncludes.h"
     41#include "core/CoreIncludes.h"
    3942#include "core/ClassTreeMask.h"
    40 #include "core/CommandLineParser.h"
    41 #include "core/ConfigValueIncludes.h"
    42 #include "core/CoreIncludes.h"
    4343#include "core/Loader.h"
    4444#include "core/Resource.h"
    … …  
    5959    LevelManager::LevelManager()
    6060    {
    61         RegisterRootObject(LevelManager);
     61        RegisterObject(LevelManager);
    6262        this->setConfigValues();
    6363

  • code/trunk/src/orxonox/LevelManager.h

    r8079 r9667  
    4646
    4747#include "util/Singleton.h"
    48 #include "core/OrxonoxClass.h"
     48#include "core/config/Configurable.h"
    4949
    5050// tolua_begin
    … …  
    6767    class _OrxonoxExport LevelManager
    6868    // tolua_end
    69         : public Singleton<LevelManager>, public OrxonoxClass
     69        : public Singleton<LevelManager>, public Configurable
    7070    { // tolua_export
    7171            friend class Singleton<LevelManager>;

  • code/trunk/src/orxonox/Main.cc

    r9550 r9667  
    3636#include "Main.h"
    3737
    38 #include "core/CommandLineParser.h"
     38#include "core/config/CommandLineParser.h"
    3939#include "core/Game.h"
    4040#include "core/LuaState.h"

  • code/trunk/src/orxonox/MoodManager.cc

    r8858 r9667  
    3030
    3131#include "util/ScopedSingletonManager.h"
    32 #include "core/ConfigValueIncludes.h"
     32#include "core/config/ConfigValueIncludes.h"
    3333#include "core/CoreIncludes.h"
    3434#include "core/Resource.h"
    … …  
    4343    MoodManager::MoodManager()
    4444    {
    45         RegisterRootObject(MoodManager);
     45        RegisterObject(MoodManager);
    4646        this->setConfigValues();
    4747
    … …  
    9595    MoodListener::MoodListener()
    9696    {
    97         RegisterRootObject(MoodListener);
     97        RegisterObject(MoodListener);
    9898    }
    9999

  • code/trunk/src/orxonox/MoodManager.h

    r8706 r9667  
    3434#include <string>
    3535#include "util/Singleton.h"
    36 #include "core/OrxonoxClass.h"
     36#include "core/class/OrxonoxInterface.h"
    3737
    3838namespace orxonox
    … …  
    4242        The MoodListener class is aware of a change in themes and directs that info to dependent classes.
    4343    */
    44     class _OrxonoxExport MoodListener : virtual public OrxonoxClass
     44    class _OrxonoxExport MoodListener : virtual public OrxonoxInterface
    4545    {
    4646        friend class MoodManager;
    … …  
    6060        The MoodManager class serves to allow for different musical themes in the game.
    6161    */
    62     class _OrxonoxExport MoodManager : public Singleton<MoodManager>, public OrxonoxClass
     62    class _OrxonoxExport MoodManager : public Singleton<MoodManager>, public Configurable
    6363    {
    6464            friend class Singleton<MoodManager>;
    … …  
    7474
    7575        private:
    76             ~MoodManager() {}
    7776            void checkMoodValidity();
    7877

  • code/trunk/src/orxonox/PawnManager.cc

    r8351 r9667  
    3939    PawnManager::PawnManager()
    4040    {
    41         RegisterRootObject(PawnManager);
     41        RegisterObject(PawnManager);
    4242    }
    4343

  • code/trunk/src/orxonox/PlayerManager.cc

    r8858 r9667  
    4343    PlayerManager::PlayerManager()
    4444    {
    45         RegisterRootObject(PlayerManager);
     45        RegisterObject(PlayerManager);
    4646
    4747//         this->getConnectedClients();

  • code/trunk/src/orxonox/Radar.cc

    r8858 r9667  
    3737
    3838//#include "util/Math.h"
    39 #include "core/ObjectList.h"
     39#include "core/object/ObjectList.h"
    4040#include "core/command/ConsoleCommand.h"
    4141#include "interfaces/RadarListener.h"

  • code/trunk/src/orxonox/Radar.h

    r7163 r9667  
    4141#include <string>
    4242
    43 #include "core/ObjectListIterator.h"
     43#include "core/object/ObjectListIterator.h"
    4444#include "interfaces/RadarViewable.h"
    4545#include "tools/interfaces/Tickable.h"
    … …  
    7474        void radarObjectChanged(RadarViewable* rv);
    7575
    76         ObjectListIterator<RadarViewable> itFocus_;
     76        ObjectList<RadarViewable>::iterator itFocus_;
    7777        RadarViewable* focus_;
    7878        std::map<std::string, RadarViewable::Shape> objectTypes_;

  • code/trunk/src/orxonox/Scene.cc

    r9348 r9667  
    5151namespace orxonox
    5252{
    53     CreateFactory(Scene);
    54 
    55     Scene::Scene(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     53    RegisterClass(Scene);
     54
     55    Scene::Scene(Context* context) : BaseObject(context), Synchronisable(context), Context(context)
    5656    {
    5757        RegisterObject(Scene);

  • code/trunk/src/orxonox/Scene.h

    r6417 r9667  
    4545namespace orxonox
    4646{
    47     class _OrxonoxExport Scene : public BaseObject, public Synchronisable, public Tickable
     47    class _OrxonoxExport Scene : public BaseObject, public Synchronisable, public Tickable, public Context
    4848    {
    4949        public:
    50             Scene(BaseObject* creator);
     50            Scene(Context* context);
    5151            virtual ~Scene();
    5252

  • code/trunk/src/orxonox/Test.cc

    r8858 r9667  
    2828
    2929#include "core/CoreIncludes.h"
    30 #include "core/ConfigValueIncludes.h"
     30#include "core/config/ConfigValueIncludes.h"
    3131#include "core/command/ConsoleCommand.h"
    3232#include "network/NetworkFunction.h"
    … …  
    3636namespace orxonox
    3737{
    38     CreateFactory ( Test );
     38    RegisterClass ( Test );
    3939
    4040    SetConsoleCommand("Test", "printV1", &Test::printV1).addShortcut();
    … …  
    5656    Test* Test::instance_ = 0;
    5757
    58     Test::Test(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     58    Test::Test(Context* context) : BaseObject(context), Synchronisable(context)
    5959    {
    6060        assert(instance_==0);

  • code/trunk/src/orxonox/Test.h

    r8858 r9667  
    4646  {
    4747    public:
    48       Test(BaseObject* creator);
     48      Test(Context* context);
    4949      virtual ~Test();
    5050

  • code/trunk/src/orxonox/chat/ChatHistory.cc

    r8858 r9667  
    3939  /* constructor */
    4040#ifndef CHATTEST
    41   //ChatHistory::ChatHistory( BaseObject* creator ) : BaseObject(creator)
    4241  ChatHistory::ChatHistory()
    4342#else

  • code/trunk/src/orxonox/chat/ChatListener.h

    r8858 r9667  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include "core/OrxonoxClass.h"
     34#include "core/object/Listable.h"
    3535
    3636namespace orxonox
    … …  
    4040        message was sent through ChatManager.
    4141    */
    42     class _OrxonoxExport ChatListener : virtual public OrxonoxClass
     42    class _OrxonoxExport ChatListener : virtual public Listable
    4343    {
    4444        friend class ChatManager;

  • code/trunk/src/orxonox/chat/ChatManager.cc

    r8858 r9667  
    113113    // ChatListener                                                         //
    114114    //////////////////////////////////////////////////////////////////////////
     115    RegisterAbstractClass(ChatListener).inheritsFrom(Class(Listable));
    115116
    116117    ChatListener::ChatListener()
    117118    {
    118         RegisterRootObject(ChatListener);
     119        RegisterObject(ChatListener);
    119120    }
    120121}

  • code/trunk/src/orxonox/collisionshapes/CollisionShape.cc

    r8858 r9667  
    4444namespace orxonox
    4545{
     46    RegisterAbstractClass(CollisionShape).inheritsFrom(Class(BaseObject)).inheritsFrom(Class(Synchronisable));
    4647
    4748    /**
    … …  
    4950        Constructor. Registers and initializes the object.
    5051    */
    51     CollisionShape::CollisionShape(BaseObject* creator)
    52         : BaseObject(creator)
    53         , Synchronisable(creator)
     52    CollisionShape::CollisionShape(Context* context)
     53        : BaseObject(context)
     54        , Synchronisable(context)
    5455    {
    5556        RegisterObject(CollisionShape);

  • code/trunk/src/orxonox/collisionshapes/CollisionShape.h

    r8706 r9667  
    5858    {
    5959        public:
    60             CollisionShape(BaseObject* creator);
     60            CollisionShape(Context* context);
    6161            virtual ~CollisionShape();
    6262

  • code/trunk/src/orxonox/collisionshapes/CompoundCollisionShape.cc

    r8858 r9667  
    4242namespace orxonox
    4343{
    44     CreateFactory(CompoundCollisionShape);
     44    RegisterClass(CompoundCollisionShape);
    4545
    4646    /**
    … …  
    4848        Constructor. Registers and initializes the object.
    4949    */
    50     CompoundCollisionShape::CompoundCollisionShape(BaseObject* creator) : CollisionShape(creator)
     50    CompoundCollisionShape::CompoundCollisionShape(Context* context) : CollisionShape(context)
    5151    {
    5252        RegisterObject(CompoundCollisionShape);

  • code/trunk/src/orxonox/collisionshapes/CompoundCollisionShape.h

    r8706 r9667  
    5858    {
    5959        public:
    60             CompoundCollisionShape(BaseObject* creator);
     60            CompoundCollisionShape(Context* context);
    6161            virtual ~CompoundCollisionShape();
    6262

  • code/trunk/src/orxonox/collisionshapes/WorldEntityCollisionShape.cc

    r8706 r9667  
    3737namespace orxonox
    3838{
    39     WorldEntityCollisionShape::WorldEntityCollisionShape(WorldEntity* creator) : CompoundCollisionShape(creator)
     39    WorldEntityCollisionShape::WorldEntityCollisionShape(Context* context) : CompoundCollisionShape(context)
    4040    {
    4141        RegisterObject(WorldEntityCollisionShape);
    4242
    43         this->worldEntityOwner_ = creator;
     43        this->worldEntityOwner_ = NULL;
    4444        // suppress synchronisation
    4545        this->setSyncMode(ObjectDirection::None);

  • code/trunk/src/orxonox/collisionshapes/WorldEntityCollisionShape.h

    r5781 r9667  
    3838    {
    3939        public:
    40             WorldEntityCollisionShape(WorldEntity* creator);
     40            WorldEntityCollisionShape(Context* context);
    4141            virtual ~WorldEntityCollisionShape();
    4242
    43             inline WorldEntity* getWorldEntityOwner()
     43            inline void setWorldEntityOwner(WorldEntity* worldEntityOwner)
     44                { this->worldEntityOwner_ = worldEntityOwner; }
     45            inline WorldEntity* getWorldEntityOwner() const
    4446                { return this->worldEntityOwner_; }
    4547

  • code/trunk/src/orxonox/controllers/AIController.cc

    r9016 r9667  
    3939    const float AIController::ACTION_INTERVAL = 1.0f;
    4040
    41     CreateFactory(AIController);
    42 
    43     AIController::AIController(BaseObject* creator) : ArtificialController(creator)
     41    RegisterClass(AIController);
     42
     43    AIController::AIController(Context* context) : ArtificialController(context)
    4444    {
    4545        RegisterObject(AIController);

  • code/trunk/src/orxonox/controllers/AIController.h

    r9016 r9667  
    4141    {
    4242        public:
    43             AIController(BaseObject* creator);
     43            AIController(Context* context);
    4444            virtual ~AIController();
    4545

  • code/trunk/src/orxonox/controllers/ArtificialController.cc

    r9252 r9667  
    4545    SetConsoleCommand("ArtificialController", "setbotlevel",      &ArtificialController::setAllBotLevel);
    4646
    47     ArtificialController::ArtificialController(BaseObject* creator) : FormationController(creator)
     47    RegisterClass(ArtificialController);
     48
     49    ArtificialController::ArtificialController(Context* context) : FormationController(context)
    4850    {
    4951        RegisterObject(ArtificialController);

  • code/trunk/src/orxonox/controllers/ArtificialController.h

    r9252 r9667  
    3939    {
    4040        public:
    41             ArtificialController(BaseObject* creator);
     41            ArtificialController(Context* context);
    4242            virtual ~ArtificialController();
    4343

  • code/trunk/src/orxonox/controllers/Controller.cc

    r6417 r9667  
    3333namespace orxonox
    3434{
    35     CreateUnloadableFactory(Controller);
     35    RegisterUnloadableClass(Controller);
    3636
    37     Controller::Controller(BaseObject* creator) : BaseObject(creator)
     37    Controller::Controller(Context* context) : BaseObject(context)
    3838    {
    3939        RegisterObject(Controller);

  • code/trunk/src/orxonox/controllers/Controller.h

    r9666 r9667  
    4242
    4343        public:
    44             Controller(BaseObject* creator);
     44            Controller(Context* context);
    4545            virtual ~Controller();
    4646

  • code/trunk/src/orxonox/controllers/DroneController.cc

    r8891 r9667  
    4141        Constructor.
    4242    */
    43     CreateFactory(DroneController);
     43    RegisterClass(DroneController);
    4444
    4545    const float DroneController::ACTION_INTERVAL = 1.0f;
    4646
    47     DroneController::DroneController(BaseObject* creator) : ArtificialController(creator)
     47    DroneController::DroneController(Context* context) : ArtificialController(context)
    4848    {
    4949        RegisterObject(DroneController);

  • code/trunk/src/orxonox/controllers/DroneController.h

    r8891 r9667  
    3333
    3434#include "AIController.h"
    35 #include "core/WeakPtr.h"
     35#include "core/object/WeakPtr.h"
    3636#include "tools/interfaces/Tickable.h"
    3737
    … …  
    5050    {
    5151        public:
    52             DroneController(BaseObject* creator);
     52            DroneController(Context* context);
    5353            virtual ~DroneController();
    5454

  • code/trunk/src/orxonox/controllers/FormationController.cc

    r9663 r9667  
    5656    SetConsoleCommand("FormationController", "formationsize",    &FormationController::formationsize);
    5757
    58 
    59 
     58    RegisterClass(FormationController);
    6059
    6160    static const unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
    … …  
    6968    static const float ROTATEFACTOR_FREE = 0.8f;
    7069
    71     FormationController::FormationController(BaseObject* creator) : Controller(creator)
     70    FormationController::FormationController(Context* context) : Controller(context)
    7271    {
    7372        RegisterObject(FormationController);

  • code/trunk/src/orxonox/controllers/FormationController.h

    r9625 r9667  
    3333
    3434#include <vector>
    35 #include "core/Super.h"
     35#include "core/class/Super.h"
    3636
    3737#include "util/Math.h"
    38 #include "core/OrxonoxClass.h"
    3938#include "controllers/Controller.h"
    4039#include "worldentities/ControllableEntity.h"
    … …  
    4746
    4847      public:
    49       FormationController(BaseObject* creator);
     48      FormationController(Context* context);
    5049
    5150      virtual ~FormationController();

  • code/trunk/src/orxonox/controllers/HumanController.cc

    r9625 r9667  
    6666    SetConsoleCommand("HumanController", "myposition",             &HumanController::myposition    ).addShortcut();
    6767
    68     CreateUnloadableFactory(HumanController);
     68    RegisterUnloadableClass(HumanController);
    6969
    7070    HumanController* HumanController::localController_s = 0;
    7171    /*static*/ const float HumanController::BOOSTING_TIME = 0.1f;
    7272
    73     HumanController::HumanController(BaseObject* creator) : FormationController(creator)
     73    HumanController::HumanController(Context* context) : FormationController(context)
    7474    {
    7575        RegisterObject(HumanController);

  • code/trunk/src/orxonox/controllers/HumanController.h

    r9256 r9667  
    4444    { // tolua_export
    4545        public:
    46             HumanController(BaseObject* creator);
     46            HumanController(Context* context);
    4747            virtual ~HumanController();
    4848

  • code/trunk/src/orxonox/controllers/NewHumanController.cc

    r9348 r9667  
    5656    SetConsoleCommand("NewHumanController", "unfire",     &NewHumanController::unfire    ).keybindMode(KeybindMode::OnRelease).addShortcut();
    5757
    58     CreateUnloadableFactory(NewHumanController);
     58    RegisterUnloadableClass(NewHumanController);
    5959
    6060    NewHumanController* NewHumanController::localController_s = 0;
    6161
    62     NewHumanController::NewHumanController(BaseObject* creator)
    63         : HumanController(creator)
     62    NewHumanController::NewHumanController(Context* context)
     63        : HumanController(context)
    6464        , crossHairOverlay_(NULL)
    6565        , centerOverlay_(NULL)
    … …  
    9898        if (GameMode::showsGraphics())
    9999        {
    100             crossHairOverlay_ = new OrxonoxOverlay(this);
     100            crossHairOverlay_ = new OrxonoxOverlay(this->getContext());
    101101            crossHairOverlay_->setBackgroundMaterial("Orxonox/Crosshair3");
    102102            crossHairOverlay_->setSize(Vector2(overlaySize_, overlaySize_));
    … …  
    104104            //crossHairOverlay_->setAspectCorrection(true); not working
    105105
    106             centerOverlay_ = new OrxonoxOverlay(this);
     106            centerOverlay_ = new OrxonoxOverlay(this->getContext());
    107107            centerOverlay_->setBackgroundMaterial("Orxonox/CenterOverlay");
    108108            centerOverlay_->setSize(Vector2(overlaySize_ * 2.5f, overlaySize_ * 2.5f));
    … …  
    112112            if (showDamageOverlay_)
    113113            {
    114                 damageOverlayTop_ = new OrxonoxOverlay(this);
     114                damageOverlayTop_ = new OrxonoxOverlay(this->getContext());
    115115                damageOverlayTop_->setBackgroundMaterial("Orxonox/DamageOverlayTop");
    116116                damageOverlayTop_->setSize(Vector2(overlaySize_ * 2.5f, overlaySize_ * 2.5f));
    … …  
    118118                damageOverlayTop_->hide();
    119119
    120                 damageOverlayRight_ = new OrxonoxOverlay(this);
     120                damageOverlayRight_ = new OrxonoxOverlay(this->getContext());
    121121                damageOverlayRight_->setBackgroundMaterial("Orxonox/DamageOverlayRight");
    122122                damageOverlayRight_->setSize(Vector2(overlaySize_ * 2.5f, overlaySize_ * 2.5f));
    … …  
    124124                damageOverlayRight_->hide();
    125125
    126                 damageOverlayBottom_ = new OrxonoxOverlay(this);
     126                damageOverlayBottom_ = new OrxonoxOverlay(this->getContext());
    127127                damageOverlayBottom_->setBackgroundMaterial("Orxonox/DamageOverlayBottom");
    128128                damageOverlayBottom_->setSize(Vector2(overlaySize_ * 2.5f, overlaySize_ * 2.5f));
    … …  
    130130                damageOverlayBottom_->hide();
    131131
    132                 damageOverlayLeft_ = new OrxonoxOverlay(this);
     132                damageOverlayLeft_ = new OrxonoxOverlay(this->getContext());
    133133                damageOverlayLeft_->setBackgroundMaterial("Orxonox/DamageOverlayLeft");
    134134                damageOverlayLeft_->setSize(Vector2(overlaySize_ * 2.5f, overlaySize_ * 2.5f));
    … …  
    139139            if (showArrows_)
    140140            {
    141                 arrowsOverlay1_ = new OrxonoxOverlay(this);
     141                arrowsOverlay1_ = new OrxonoxOverlay(this->getContext());
    142142                arrowsOverlay1_->setBackgroundMaterial("Orxonox/DirectionArrows1");
    143143                arrowsOverlay1_->setSize(Vector2(0.02727f, 0.36f * arrowsSize_));
    … …  
    146146                arrowsOverlay1_->hide();
    147147
    148                 arrowsOverlay2_ = new OrxonoxOverlay(this);
     148                arrowsOverlay2_ = new OrxonoxOverlay(this->getContext());
    149149                arrowsOverlay2_->setBackgroundMaterial("Orxonox/DirectionArrows2");
    150150                arrowsOverlay2_->setSize(Vector2(0.02727f, 0.59f * arrowsSize_));
    … …  
    153153                arrowsOverlay2_->hide();
    154154
    155                 arrowsOverlay3_ = new OrxonoxOverlay(this);
     155                arrowsOverlay3_ = new OrxonoxOverlay(this->getContext());
    156156                arrowsOverlay3_->setBackgroundMaterial("Orxonox/DirectionArrows3");
    157157                arrowsOverlay3_->setSize(Vector2(0.02727f, 0.77f * arrowsSize_));
    … …  
    160160                arrowsOverlay3_->hide();
    161161
    162                 arrowsOverlay4_ = new OrxonoxOverlay(this);
     162                arrowsOverlay4_ = new OrxonoxOverlay(this->getContext());
    163163                arrowsOverlay4_->setBackgroundMaterial("Orxonox/DirectionArrows4");
    164164                arrowsOverlay4_->setSize(Vector2(0.02727f, arrowsSize_));

  • code/trunk/src/orxonox/controllers/NewHumanController.h

    r9016 r9667  
    4242    {
    4343        public:
    44             NewHumanController(BaseObject* creator);
     44            NewHumanController(Context* context);
    4545            virtual ~NewHumanController();
    4646

  • code/trunk/src/orxonox/controllers/ScriptController.cc

    r5781 r9667  
    3232namespace orxonox
    3333{
    34     CreateFactory(ScriptController);
     34    RegisterClass(ScriptController);
    3535
    36     ScriptController::ScriptController(BaseObject* creator) : ArtificialController(creator)
     36    ScriptController::ScriptController(Context* context) : ArtificialController(context)
    3737    {
    3838        RegisterObject(ScriptController);

  • code/trunk/src/orxonox/controllers/ScriptController.h

    r5781 r9667  
    3838    {
    3939        public:
    40             ScriptController(BaseObject* creator);
     40            ScriptController(Context* context);
    4141            virtual ~ScriptController() { }
    4242

  • code/trunk/src/orxonox/controllers/WaypointController.cc

    r9252 r9667  
    3434namespace orxonox
    3535{
    36     CreateFactory(WaypointController);
     36    RegisterClass(WaypointController);
    3737
    38     WaypointController::WaypointController(BaseObject* creator) : ArtificialController(creator)
     38    WaypointController::WaypointController(Context* context) : ArtificialController(context)
    3939    {
    4040        RegisterObject(WaypointController);

  • code/trunk/src/orxonox/controllers/WaypointController.h

    r9252 r9667  
    4141    {
    4242        public:
    43             WaypointController(BaseObject* creator);
     43            WaypointController(Context* context);
    4444            virtual ~WaypointController();
    4545

  • code/trunk/src/orxonox/controllers/WaypointPatrolController.cc

    r9016 r9667  
    3636namespace orxonox
    3737{
    38     CreateFactory(WaypointPatrolController);
     38    RegisterClass(WaypointPatrolController);
    3939
    40     WaypointPatrolController::WaypointPatrolController(BaseObject* creator) : WaypointController(creator)
     40    WaypointPatrolController::WaypointPatrolController(Context* context) : WaypointController(context)
    4141    {
    4242        RegisterObject(WaypointPatrolController);

  • code/trunk/src/orxonox/controllers/WaypointPatrolController.h

    r9016 r9667  
    4040    {
    4141        public:
    42             WaypointPatrolController(BaseObject* creator);
     42            WaypointPatrolController(Context* context);
    4343            virtual ~WaypointPatrolController() {}
    4444

  • code/trunk/src/orxonox/gamestates/GSClient.cc

    r8858 r9667  
    3030
    3131#include "util/Exception.h"
    32 #include "core/CommandLineParser.h"
     32#include "core/config/CommandLineParser.h"
    3333#include "core/Game.h"
    3434#include "core/GameMode.h"

  • code/trunk/src/orxonox/gamestates/GSLevel.h

    r7876 r9667  
    3434#include <string>
    3535#include <set>
    36 #include "core/OrxonoxClass.h"
    3736#include "core/GameState.h"
    3837

  • code/trunk/src/orxonox/gamestates/GSMainMenu.cc

    r8858 r9667  
    3131#include <OgreSceneManager.h>
    3232
    33 #include "core/ConfigValueIncludes.h"
     33#include "core/config/ConfigValueIncludes.h"
    3434#include "core/CoreIncludes.h"
    3535#include "core/Game.h"
    … …  
    6666        : GameState(info)
    6767    {
    68         RegisterRootObject(GSMainMenu);
     68        RegisterObject(GSMainMenu);
    6969
    7070        InputManager::getInstance().createInputState("MainMenuHackery", true, true)->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());

  • code/trunk/src/orxonox/gamestates/GSMainMenu.h

    r8079 r9667  
    3434#include "util/OgreForwardRefs.h"
    3535#include "core/GameState.h"
    36 #include "core/OrxonoxClass.h"
     36#include "core/config/Configurable.h"
    3737
    3838namespace orxonox
    3939{
    40     class _OrxonoxExport GSMainMenu : public GameState, public OrxonoxClass
     40    class _OrxonoxExport GSMainMenu : public GameState, public Configurable
    4141    {
    4242    public:

  • code/trunk/src/orxonox/gamestates/GSServer.cc

    r8858 r9667  
    3030
    3131#include "util/Output.h"
    32 #include "core/CommandLineParser.h"
     32#include "core/config/CommandLineParser.h"
    3333#include "core/Game.h"
    3434#include "core/GameMode.h"

  • code/trunk/src/orxonox/gametypes/Asteroids.cc

    r8858 r9667  
    3535namespace orxonox
    3636{
    37     CreateUnloadableFactory(Asteroids);
     37    RegisterUnloadableClass(Asteroids);
    3838
    39     Asteroids::Asteroids(BaseObject* creator) : Gametype(creator)
     39    Asteroids::Asteroids(Context* context) : Gametype(context)
    4040    {
    4141        RegisterObject(Asteroids);

  • code/trunk/src/orxonox/gametypes/Asteroids.h

    r5781 r9667  
    3838    {
    3939        public:
    40             Asteroids(BaseObject* creator);
     40            Asteroids(Context* context);
    4141            virtual ~Asteroids() {}
    4242

  • code/trunk/src/orxonox/gametypes/Deathmatch.cc

    r9348 r9667  
    3636namespace orxonox
    3737{
    38     CreateUnloadableFactory(Deathmatch);
     38    RegisterUnloadableClass(Deathmatch);
    3939
    40     Deathmatch::Deathmatch(BaseObject* creator) : Gametype(creator)
     40    Deathmatch::Deathmatch(Context* context) : Gametype(context)
    4141    {
    4242        RegisterObject(Deathmatch);

  • code/trunk/src/orxonox/gametypes/Deathmatch.h

    r9348 r9667  
    3838    {
    3939        public:
    40             Deathmatch(BaseObject* creator);
     40            Deathmatch(Context* context);
    4141            virtual ~Deathmatch() {}
    4242

  • code/trunk/src/orxonox/gametypes/Dynamicmatch.cc

    r9348 r9667  
    5454#include "worldentities/pawns/Pawn.h"
    5555#include "worldentities/pawns/SpaceShip.h"
    56 #include "core/ConfigValueIncludes.h"
     56#include "core/config/ConfigValueIncludes.h"
    5757#include "interfaces/TeamColourable.h"
    5858#include "items/Engine.h"
    … …  
    6262namespace orxonox
    6363{
    64     CreateUnloadableFactory(Dynamicmatch);
    65 
    66     Dynamicmatch::Dynamicmatch(BaseObject* creator) : Gametype(creator)
     64    RegisterUnloadableClass(Dynamicmatch);
     65
     66    Dynamicmatch::Dynamicmatch(Context* context) : Gametype(context)
    6767    {
    6868        RegisterObject(Dynamicmatch);

  • code/trunk/src/orxonox/gametypes/Dynamicmatch.h

    r9348 r9667  
    4444    {
    4545        public:
    46             Dynamicmatch(BaseObject* creator);
     46            Dynamicmatch(Context* context);
    4747            virtual ~Dynamicmatch() {}
    4848

  • code/trunk/src/orxonox/gametypes/Gametype.cc

    r9348 r9667  
    3232#include "core/Core.h"
    3333#include "core/CoreIncludes.h"
    34 #include "core/ConfigValueIncludes.h"
     34#include "core/config/ConfigValueIncludes.h"
    3535#include "core/GameMode.h"
    3636#include "core/command/ConsoleCommand.h"
    … …  
    4747namespace orxonox
    4848{
    49     CreateUnloadableFactory(Gametype);
    50 
    51     Gametype::Gametype(BaseObject* creator) : BaseObject(creator)
     49    RegisterUnloadableClass(Gametype);
     50
     51    Gametype::Gametype(Context* context) : BaseObject(context)
    5252    {
    5353        RegisterObject(Gametype);
    5454
    55         this->gtinfo_ = new GametypeInfo(creator);
     55        this->gtinfo_ = new GametypeInfo(context);
    5656
    5757        this->setGametype(SmartPtr<Gametype>(this, false));
    … …  
    7474        if (GameMode::showsGraphics() && !this->scoreboardTemplate_.empty())
    7575        {
    76             this->scoreboard_ = new OverlayGroup(this);
     76            this->scoreboard_ = new OverlayGroup(context);
    7777            this->scoreboard_->addTemplate(this->scoreboardTemplate_);
    7878            this->scoreboard_->setGametype(this);
    … …  
    160160                ControllableEntity* oldentity = it->first->getControllableEntity();
    161161
    162                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity);
     162                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity->getContext());
    163163                if (oldentity->getCamera())
    164164                {
    … …  
    283283                    this->gtinfo_->pawnKilled(victim->getPlayer());
    284284
    285                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(victim->getCreator());
     285                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(victim->getContext());
    286286                if (victim->getCamera())
    287287                {
    … …  
    458458        {
    459459            // force spawn at spawnpoint with default pawn
    460             ControllableEntity* entity = this->defaultControllableEntity_.fabricate(spawn);
     460            ControllableEntity* entity = this->defaultControllableEntity_.fabricate(spawn->getContext());
    461461            spawn->spawn(entity);
    462462            player->startControl(entity);
    … …  
    472472    {
    473473        for (unsigned int i = 0; i < amount; ++i)
    474             this->botclass_.fabricate(this);
     474            this->botclass_.fabricate(this->getContext());
    475475    }
    476476

  • code/trunk/src/orxonox/gametypes/Gametype.h

    r9348 r9667  
    3737
    3838#include "core/BaseObject.h"
    39 #include "core/SubclassIdentifier.h"
     39#include "core/class/SubclassIdentifier.h"
    4040#include "tools/interfaces/Tickable.h"
    4141#include "infos/GametypeInfo.h"
    … …  
    6767
    6868        public:
    69             Gametype(BaseObject* creator);
     69            Gametype(Context* context);
    7070            virtual ~Gametype();
    7171

  • code/trunk/src/orxonox/gametypes/LastManStanding.cc

    r9348 r9667  
    3333#include "infos/PlayerInfo.h"
    3434#include "worldentities/pawns/Pawn.h"
    35 #include "core/ConfigValueIncludes.h"
     35#include "core/config/ConfigValueIncludes.h"
    3636#include "util/Convert.h"
    3737
    3838namespace orxonox
    3939{
    40     CreateUnloadableFactory(LastManStanding);
    41 
    42     LastManStanding::LastManStanding(BaseObject* creator) : Deathmatch(creator)
     40    RegisterUnloadableClass(LastManStanding);
     41
     42    LastManStanding::LastManStanding(Context* context) : Deathmatch(context)
    4343    {
    4444        RegisterObject(LastManStanding);

  • code/trunk/src/orxonox/gametypes/LastManStanding.h

    r7655 r9667  
    6565
    6666        public:
    67             LastManStanding(BaseObject* creator); //!< Default Constructor.
     67            LastManStanding(Context* context); //!< Default Constructor.
    6868            virtual ~LastManStanding() {} //!< Default Destructor.
    6969            void setConfigValues(); //!< Makes values configurable.

  • code/trunk/src/orxonox/gametypes/LastTeamStanding.cc

    r9348 r9667  
    3333#include "infos/PlayerInfo.h"
    3434#include "worldentities/pawns/Pawn.h"
    35 #include "core/ConfigValueIncludes.h"
     35#include "core/config/ConfigValueIncludes.h"
    3636#include "util/Convert.h"
    3737
    3838namespace orxonox
    3939{
    40     CreateUnloadableFactory(LastTeamStanding);
    41 
    42     LastTeamStanding::LastTeamStanding(BaseObject* creator) : TeamDeathmatch(creator)
     40    RegisterUnloadableClass(LastTeamStanding);
     41
     42    LastTeamStanding::LastTeamStanding(Context* context) : TeamDeathmatch(context)
    4343    {
    4444        RegisterObject(LastTeamStanding);

  • code/trunk/src/orxonox/gametypes/LastTeamStanding.h

    r8351 r9667  
    7171
    7272        public:
    73             LastTeamStanding(BaseObject* creator); //!< Default Constructor.
     73            LastTeamStanding(Context* context); //!< Default Constructor.
    7474            virtual ~LastTeamStanding(); //!< Default Destructor.
    7575

  • code/trunk/src/orxonox/gametypes/Mission.cc

    r9348 r9667  
    3737namespace orxonox
    3838{
    39     CreateUnloadableFactory(Mission);
     39    RegisterUnloadableClass(Mission);
    4040
    41     Mission::Mission(BaseObject* creator) : TeamGametype(creator)
     41    Mission::Mission(Context* context) : TeamGametype(context)
    4242    {
    4343        RegisterObject(Mission);

  • code/trunk/src/orxonox/gametypes/Mission.h

    r9348 r9667  
    3939    {
    4040        public:
    41             Mission(BaseObject* creator);
     41            Mission(Context* context);
    4242            virtual ~Mission() {}
    4343

  • code/trunk/src/orxonox/gametypes/TeamBaseMatch.cc

    r9348 r9667  
    3636namespace orxonox
    3737{
    38     CreateUnloadableFactory(TeamBaseMatch);
    39 
    40     TeamBaseMatch::TeamBaseMatch(BaseObject* creator) : TeamDeathmatch(creator)
     38    RegisterUnloadableClass(TeamBaseMatch);
     39
     40    TeamBaseMatch::TeamBaseMatch(Context* context) : TeamDeathmatch(context)
    4141    {
    4242        RegisterObject(TeamBaseMatch);

  • code/trunk/src/orxonox/gametypes/TeamBaseMatch.h

    r9348 r9667  
    4141    {
    4242        public:
    43             TeamBaseMatch(BaseObject* creator);
     43            TeamBaseMatch(Context* context);
    4444            virtual ~TeamBaseMatch() {}
    4545

  • code/trunk/src/orxonox/gametypes/TeamDeathmatch.cc

    r9348 r9667  
    3636namespace orxonox
    3737{
    38     CreateUnloadableFactory(TeamDeathmatch);
     38    RegisterUnloadableClass(TeamDeathmatch);
    3939
    40     TeamDeathmatch::TeamDeathmatch(BaseObject* creator) : TeamGametype(creator)
     40    TeamDeathmatch::TeamDeathmatch(Context* context) : TeamGametype(context)
    4141    {
    4242        RegisterObject(TeamDeathmatch);

  • code/trunk/src/orxonox/gametypes/TeamDeathmatch.h

    r9348 r9667  
    3838    {
    3939        public:
    40             TeamDeathmatch(BaseObject* creator);
     40            TeamDeathmatch(Context* context);
    4141            virtual ~TeamDeathmatch() {}
    4242

  • code/trunk/src/orxonox/gametypes/TeamGametype.cc

    r9348 r9667  
    3030
    3131#include "core/CoreIncludes.h"
    32 #include "core/ConfigValueIncludes.h"
     32#include "core/config/ConfigValueIncludes.h"
    3333#include "infos/PlayerInfo.h"
    3434#include "interfaces/TeamColourable.h"
    … …  
    4040namespace orxonox
    4141{
    42     CreateUnloadableFactory(TeamGametype);
    43 
    44     TeamGametype::TeamGametype(BaseObject* creator) : Gametype(creator)
     42    RegisterUnloadableClass(TeamGametype);
     43
     44    TeamGametype::TeamGametype(Context* context) : Gametype(context)
    4545    {
    4646        RegisterObject(TeamGametype);

  • code/trunk/src/orxonox/gametypes/TeamGametype.h

    r9348 r9667  
    4141    {
    4242        public:
    43             TeamGametype(BaseObject* creator);
     43            TeamGametype(Context* context);
    4444            virtual ~TeamGametype() {}
    4545

  • code/trunk/src/orxonox/gametypes/UnderAttack.cc

    r9348 r9667  
    3131#include "util/Convert.h"
    3232#include "core/CoreIncludes.h"
    33 #include "core/ConfigValueIncludes.h"
     33#include "core/config/ConfigValueIncludes.h"
    3434#include "chat/ChatManager.h"
    3535#include "worldentities/pawns/Destroyer.h"
    … …  
    3838namespace orxonox
    3939{
    40     CreateUnloadableFactory(UnderAttack);
     40    RegisterUnloadableClass(UnderAttack);
    4141
    42     UnderAttack::UnderAttack(BaseObject* creator) : TeamDeathmatch(creator)
     42    UnderAttack::UnderAttack(Context* context) : TeamDeathmatch(context)
    4343    {
    4444        RegisterObject(UnderAttack);

  • code/trunk/src/orxonox/gametypes/UnderAttack.h

    r5929 r9667  
    3939    {
    4040        public:
    41             UnderAttack(BaseObject* creator);
     41            UnderAttack(Context* context);
    4242            virtual ~UnderAttack() {}
    4343

  • code/trunk/src/orxonox/graphics/AnimatedModel.cc

    r8858 r9667  
    3939namespace orxonox
    4040{
    41     CreateFactory(AnimatedModel);
     41    RegisterClass(AnimatedModel);
    4242
    43     AnimatedModel::AnimatedModel(BaseObject* creator) : Model(creator)
     43    AnimatedModel::AnimatedModel(Context* context) : Model(context)
    4444    {
    4545        RegisterObject(AnimatedModel);

  • code/trunk/src/orxonox/graphics/AnimatedModel.h

    r8858 r9667  
    4141    {
    4242        public:
    43             AnimatedModel(BaseObject* creator);
     43            AnimatedModel(Context* context);
    4444            virtual ~AnimatedModel();
    4545

  • code/trunk/src/orxonox/graphics/Backlight.cc

    r8424 r9667  
    4545namespace orxonox
    4646{
    47     CreateFactory(Backlight);
    48 
    49     Backlight::Backlight(BaseObject* creator) : FadingBillboard(creator)
     47    RegisterClass(Backlight);
     48
     49    Backlight::Backlight(Context* context) : FadingBillboard(context)
    5050    {
    5151        RegisterObject(Backlight);

  • code/trunk/src/orxonox/graphics/Backlight.h

    r7163 r9667  
    4141    {
    4242        public:
    43             Backlight(BaseObject* creator);
     43            Backlight(Context* context);
    4444            virtual ~Backlight();
    4545

  • code/trunk/src/orxonox/graphics/Billboard.cc

    r8706 r9667  
    3838namespace orxonox
    3939{
    40     CreateFactory(Billboard);
     40    RegisterClass(Billboard);
    4141
    42     Billboard::Billboard(BaseObject* creator) : StaticEntity(creator)
     42    Billboard::Billboard(Context* context) : StaticEntity(context)
    4343    {
    4444        RegisterObject(Billboard);

  • code/trunk/src/orxonox/graphics/Billboard.h

    r8706 r9667  
    4444    {
    4545        public:
    46             Billboard(BaseObject* creator);
     46            Billboard(Context* context);
    4747            virtual ~Billboard();
    4848

  • code/trunk/src/orxonox/graphics/BlinkingBillboard.cc

    r8351 r9667  
    3535namespace orxonox
    3636{
    37     CreateFactory(BlinkingBillboard);
     37    RegisterClass(BlinkingBillboard);
    3838
    39     BlinkingBillboard::BlinkingBillboard(BaseObject* creator) : Billboard(creator)
     39    BlinkingBillboard::BlinkingBillboard(Context* context) : Billboard(context)
    4040    {
    4141        RegisterObject(BlinkingBillboard);

  • code/trunk/src/orxonox/graphics/BlinkingBillboard.h

    r8351 r9667  
    4141    {
    4242        public:
    43             BlinkingBillboard(BaseObject* creator);
     43            BlinkingBillboard(Context* context);
    4444            virtual ~BlinkingBillboard();
    4545

  • code/trunk/src/orxonox/graphics/Camera.cc

    r8706 r9667  
    3737#include "util/StringUtils.h"
    3838#include "core/CoreIncludes.h"
    39 #include "core/ConfigValueIncludes.h"
     39#include "core/config/ConfigValueIncludes.h"
    4040#include "core/GameMode.h"
    4141#include "core/GUIManager.h"
    … …  
    4646namespace orxonox
    4747{
    48     CreateFactory(Camera);
    49 
    50     Camera::Camera(BaseObject* creator) : StaticEntity(creator)
     48    RegisterClass(Camera);
     49
     50    Camera::Camera(Context* context) : StaticEntity(context)
    5151    {
    5252        RegisterObject(Camera);

  • code/trunk/src/orxonox/graphics/Camera.h

    r8706 r9667  
    4646
    4747        public:
    48             Camera(BaseObject* creator);
     48            Camera(Context* context);
    4949            virtual ~Camera();
    5050

  • code/trunk/src/orxonox/graphics/FadingBillboard.cc

    r5929 r9667  
    3434namespace orxonox
    3535{
    36     CreateFactory(FadingBillboard);
     36    RegisterClass(FadingBillboard);
    3737
    38     FadingBillboard::FadingBillboard(BaseObject* creator) : Billboard(creator)
     38    FadingBillboard::FadingBillboard(Context* context) : Billboard(context)
    3939    {
    4040        RegisterObject(FadingBillboard);

  • code/trunk/src/orxonox/graphics/FadingBillboard.h

    r7163 r9667  
    4242    {
    4343        public:
    44             FadingBillboard(BaseObject* creator);
     44            FadingBillboard(Context* context);
    4545            virtual ~FadingBillboard();
    4646

  • code/trunk/src/orxonox/graphics/GlobalShader.cc

    r8079 r9667  
    3636namespace orxonox
    3737{
    38     CreateFactory(GlobalShader);
     38    RegisterClass(GlobalShader);
    3939
    40     GlobalShader::GlobalShader(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     40    GlobalShader::GlobalShader(Context* context) : BaseObject(context), Synchronisable(context)
    4141    {
    4242        RegisterObject(GlobalShader);

  • code/trunk/src/orxonox/graphics/GlobalShader.h

    r8079 r9667  
    4141    {
    4242        public:
    43             GlobalShader(BaseObject* creator);
     43            GlobalShader(Context* context);
    4444            virtual ~GlobalShader();
    4545

  • code/trunk/src/orxonox/graphics/Light.cc

    r5781 r9667  
    4242namespace orxonox
    4343{
    44     CreateFactory(Light);
     44    RegisterClass(Light);
    4545
    4646    // Be sure we don't do bad conversions
    … …  
    4949    BOOST_STATIC_ASSERT((int)Ogre::Light::LT_SPOTLIGHT   == (int)Light::Spotlight);
    5050
    51     Light::Light(BaseObject* creator) : StaticEntity(creator)
     51    Light::Light(Context* context) : StaticEntity(context)
    5252    {
    5353        RegisterObject(Light);

  • code/trunk/src/orxonox/graphics/Light.h

    r7401 r9667  
    5353
    5454        public:
    55             Light(BaseObject* creator);
     55            Light(Context* context);
    5656            virtual ~Light();
    5757

  • code/trunk/src/orxonox/graphics/MeshLodInformation.cc

    r7183 r9667  
    3838namespace orxonox
    3939{
    40     CreateFactory(MeshLodInformation);
     40    RegisterClass(MeshLodInformation);
    4141
    42     MeshLodInformation::MeshLodInformation(BaseObject* creator)
    43     : BaseObject(creator), lodLevel_(5), bEnabled_(true), numLevels_(10), reductionRate_(0.15f)
     42    MeshLodInformation::MeshLodInformation(Context* context)
     43    : BaseObject(context), lodLevel_(5), bEnabled_(true), numLevels_(10), reductionRate_(0.15f)
    4444    {
    4545        RegisterObject(MeshLodInformation);

  • code/trunk/src/orxonox/graphics/MeshLodInformation.h

    r7163 r9667  
    4141    {
    4242        public:
    43             MeshLodInformation(BaseObject* creator);
     43            MeshLodInformation(Context* context);
    4444            virtual ~MeshLodInformation();
    4545

  • code/trunk/src/orxonox/graphics/Model.cc

    r8858 r9667  
    3232
    3333#include "core/CoreIncludes.h"
    34 #include "core/ConfigValueIncludes.h"
     34#include "core/config/ConfigValueIncludes.h"
    3535#include "core/GameMode.h"
    3636#include "core/XMLPort.h"
    … …  
    4141namespace orxonox
    4242{
    43     CreateFactory(Model);
    44 
    45     Model::Model(BaseObject* creator) :
    46         StaticEntity(creator), bCastShadows_(true), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
     43    RegisterClass(Model);
     44
     45    Model::Model(Context* context) :
     46        StaticEntity(context), bCastShadows_(true), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
    4747    {
    4848        RegisterObject(Model);

  • code/trunk/src/orxonox/graphics/Model.h

    r7166 r9667  
    4141    {
    4242        public:
    43             Model(BaseObject* creator);
     43            Model(Context* context);
    4444            virtual ~Model();
    4545

  • code/trunk/src/orxonox/graphics/ParticleEmitter.cc

    r9550 r9667  
    4343namespace orxonox
    4444{
    45     CreateFactory(ParticleEmitter);
     45    RegisterClass(ParticleEmitter);
    4646
    47     ParticleEmitter::ParticleEmitter(BaseObject* creator) : StaticEntity(creator)
     47    ParticleEmitter::ParticleEmitter(Context* context) : StaticEntity(context)
    4848    {
    4949        RegisterObject(ParticleEmitter);
    … …  
    6363        {
    6464            this->detachOgreObject(this->particles_->getParticleSystem());
    65             this->particles_->destroy();
     65            delete this->particles_;
    6666        }
    6767    }
    … …  
    101101        if (this->particles_)
    102102        {
    103             this->particles_->destroy();
     103            delete this->particles_;
    104104            this->particles_ = 0;
    105105        }

  • code/trunk/src/orxonox/graphics/ParticleEmitter.h

    r7904 r9667  
    4040    {
    4141        public:
    42             ParticleEmitter(BaseObject* creator);
     42            ParticleEmitter(Context* context);
    4343            virtual ~ParticleEmitter();
    4444

  • code/trunk/src/orxonox/graphics/ParticleSpawner.cc

    r7284 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(ParticleSpawner);
     39    RegisterClass(ParticleSpawner);
    4040
    41     ParticleSpawner::ParticleSpawner(BaseObject* creator) : ParticleEmitter(creator)
     41    ParticleSpawner::ParticleSpawner(Context* context) : ParticleEmitter(context)
    4242    {
    4343        RegisterObject(ParticleSpawner);

  • code/trunk/src/orxonox/graphics/ParticleSpawner.h

    r5929 r9667  
    4040    {
    4141        public:
    42             ParticleSpawner(BaseObject* creator);
     42            ParticleSpawner(Context* context);
    4343            virtual ~ParticleSpawner();
    4444

  • code/trunk/src/orxonox/infos/Bot.cc

    r7801 r9667  
    3232#include "core/GameMode.h"
    3333#include "core/CoreIncludes.h"
    34 #include "core/ConfigValueIncludes.h"
     34#include "core/config/ConfigValueIncludes.h"
    3535#include "gametypes/Gametype.h"
    3636#include "controllers/AIController.h"
    … …  
    3838namespace orxonox
    3939{
    40     CreateFactory(Bot);
     40    RegisterClass(Bot);
    4141
    42     Bot::Bot(BaseObject* creator) : PlayerInfo(creator)
     42    Bot::Bot(Context* context) : PlayerInfo(context)
    4343    {
    4444        RegisterObject(Bot);

  • code/trunk/src/orxonox/infos/Bot.h

    r5781 r9667  
    4040    {
    4141        public:
    42             Bot(BaseObject* creator);
     42            Bot(Context* context);
    4343            virtual ~Bot();
    4444

  • code/trunk/src/orxonox/infos/GametypeInfo.cc

    r9348 r9667  
    4848namespace orxonox
    4949{
    50     CreateUnloadableFactory(GametypeInfo);
     50    RegisterUnloadableClass(GametypeInfo);
    5151
    5252    registerMemberNetworkFunction(GametypeInfo, dispatchAnnounceMessage);
    … …  
    6565        Registers and initializes the object.
    6666    */
    67     GametypeInfo::GametypeInfo(BaseObject* creator) : Info(creator)
     67    GametypeInfo::GametypeInfo(Context* context) : Info(context)
    6868    {
    6969        RegisterObject(GametypeInfo);

  • code/trunk/src/orxonox/infos/GametypeInfo.h

    r9348 r9667  
    5858
    5959        public:
    60             GametypeInfo(BaseObject* creator);
     60            GametypeInfo(Context* context);
    6161            virtual ~GametypeInfo();
    6262

  • code/trunk/src/orxonox/infos/HumanPlayer.cc

    r8327 r9667  
    3030
    3131#include "core/CoreIncludes.h"
    32 #include "core/ConfigValueIncludes.h"
     32#include "core/config/ConfigValueIncludes.h"
    3333#include "core/GameMode.h"
    3434// #include "network/ClientInformation.h"
    … …  
    4141namespace orxonox
    4242{
    43     CreateUnloadableFactory(HumanPlayer);
    44 
    45     HumanPlayer::HumanPlayer(BaseObject* creator) : PlayerInfo(creator)
     43    RegisterUnloadableClass(HumanPlayer);
     44
     45    HumanPlayer::HumanPlayer(Context* context) : PlayerInfo(context)
    4646    {
    4747        RegisterObject(HumanPlayer);
    … …  
    183183        if (this->isLocalPlayer() && !this->humanHudTemplate_.empty() && GameMode::showsGraphics())
    184184        {
    185             this->humanHud_ = new OverlayGroup(this);
     185            this->humanHud_ = new OverlayGroup(this->getContext());
    186186            this->humanHud_->addTemplate(this->humanHudTemplate_);
    187187            this->humanHud_->setOwner(this);
    … …  
    199199        if (this->isLocalPlayer() && !this->gametypeHudTemplate_.empty())
    200200        {
    201             this->gametypeHud_ = new OverlayGroup(this);
     201            this->gametypeHud_ = new OverlayGroup(this->getContext());
    202202            this->gametypeHud_->addTemplate(this->gametypeHudTemplate_);
    203203            this->gametypeHud_->setOwner(this);

  • code/trunk/src/orxonox/infos/HumanPlayer.h

    r7163 r9667  
    4040    {
    4141        public:
    42             HumanPlayer(BaseObject* creator);
     42            HumanPlayer(Context* context);
    4343            virtual ~HumanPlayer();
    4444

  • code/trunk/src/orxonox/infos/Info.cc

    r5781 r9667  
    3232namespace orxonox
    3333{
    34     Info::Info(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     34    RegisterClass(Info);
     35
     36    Info::Info(Context* context) : BaseObject(context), Synchronisable(context)
    3537    {
    3638        RegisterObject(Info);

  • code/trunk/src/orxonox/infos/Info.h

    r5781 r9667  
    4040    {
    4141        public:
    42             Info(BaseObject* creator);
     42            Info(Context* context);
    4343            virtual ~Info() {}
    4444    };

  • code/trunk/src/orxonox/infos/PlayerInfo.cc

    r9348 r9667  
    4040namespace orxonox
    4141{
    42     PlayerInfo::PlayerInfo(BaseObject* creator) : Info(creator)
     42    RegisterAbstractClass(PlayerInfo).inheritsFrom(Class(Info));
     43
     44    PlayerInfo::PlayerInfo(Context* context) : Info(context)
    4345    {
    4446        RegisterObject(PlayerInfo);
    … …  
    136138            this->controller_ = 0;
    137139        }
    138         this->controller_ = this->defaultController_.fabricate(this);
     140        this->controller_ = this->defaultController_.fabricate(this->getContext());
    139141        assert(this->controller_);
    140142        this->controller_->setPlayer(this);

  • code/trunk/src/orxonox/infos/PlayerInfo.h

    r8706 r9667  
    3333
    3434#include "Info.h"
    35 #include "core/SubclassIdentifier.h"
     35#include "core/class/SubclassIdentifier.h"
    3636
    3737namespace orxonox // tolua_export
    … …  
    4141    { // tolua_export
    4242        public:
    43             PlayerInfo(BaseObject* creator);
     43            PlayerInfo(Context* context);
    4444            virtual ~PlayerInfo();
    4545

  • code/trunk/src/orxonox/interfaces/GametypeMessageListener.h

    r7163 r9667  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "core/OrxonoxClass.h"
     33#include "core/class/OrxonoxInterface.h"
    3434
    3535namespace orxonox
    3636{
    37     class _OrxonoxExport GametypeMessageListener : virtual public OrxonoxClass
     37    class _OrxonoxExport GametypeMessageListener : virtual public OrxonoxInterface
    3838    {
    3939        public:

  • code/trunk/src/orxonox/interfaces/InterfaceCompilation.cc

    r8706 r9667  
    5050    // GametypeMessageListener
    5151    //----------------------------
     52    RegisterAbstractClass(GametypeMessageListener).inheritsFrom(Class(OrxonoxInterface));
     53
    5254    GametypeMessageListener::GametypeMessageListener()
    5355    {
    54         RegisterRootObject(GametypeMessageListener);
     56        RegisterObject(GametypeMessageListener);
    5557    }
    5658
    … …  
    5860    // PlayerTrigger
    5961    //----------------------------
     62    RegisterAbstractClass(PlayerTrigger).inheritsFrom(Class(OrxonoxInterface));
     63
    6064    PlayerTrigger::PlayerTrigger()
    6165    {
    62         RegisterRootObject(PlayerTrigger);
     66        RegisterObject(PlayerTrigger);
    6367
    6468        this->isForPlayer_ = false;
    … …  
    7680    // RadarListener
    7781    //----------------------------
     82    RegisterAbstractClass(RadarListener).inheritsFrom(Class(OrxonoxInterface));
     83
    7884    RadarListener::RadarListener()
    7985    {
    80         RegisterRootObject(RadarListener);
     86        RegisterObject(RadarListener);
    8187    }
    8288
    … …  
    8490    // TeamColourable
    8591    //----------------------------
     92    RegisterAbstractClass(TeamColourable).inheritsFrom(Class(OrxonoxInterface));
     93
    8694    TeamColourable::TeamColourable()
    8795    {
    88         RegisterRootObject(TeamColourable);
     96        RegisterObject(TeamColourable);
    8997    }
    9098
    … …  
    92100    // Rewardable
    93101    //----------------------------
     102    RegisterAbstractClass(Rewardable).inheritsFrom(Class(OrxonoxInterface));
     103
    94104    Rewardable::Rewardable()
    95105    {
    96         RegisterRootObject(Rewardable);
     106        RegisterObject(Rewardable);
    97107    }
    98108}

  • code/trunk/src/orxonox/interfaces/NotificationListener.cc

    r8706 r9667  
    5353    NotificationListener::NotificationListener()
    5454    {
    55         RegisterRootObject(NotificationListener);
     55        RegisterObject(NotificationListener);
    5656    }
    5757

  • code/trunk/src/orxonox/interfaces/NotificationListener.h

    r8706 r9667  
    4444#include "util/StringUtils.h"
    4545
    46 #include "core/OrxonoxClass.h"
     46#include "core/class/OrxonoxInterface.h"
    4747
    4848namespace orxonox
    … …  
    9090    @todo Consistent terminology between message, notification and command.
    9191    */
    92     class _OrxonoxExport NotificationListener : virtual public OrxonoxClass
     92    class _OrxonoxExport NotificationListener : virtual public OrxonoxInterface
    9393    {
    9494        public:

  • code/trunk/src/orxonox/interfaces/PickupCarrier.cc

    r8858 r9667  
    3535
    3636#include "core/CoreIncludes.h"
    37 #include "core/Identifier.h"
     37#include "core/class/Identifier.h"
    3838
    3939#include "Pickupable.h"
    4040
    41 namespace orxonox {
     41namespace orxonox
     42{
     43    RegisterAbstractClass(PickupCarrier).inheritsFrom(Class(OrxonoxInterface));
    4244
    4345    /**
    … …  
    4749    PickupCarrier::PickupCarrier()
    4850    {
    49         RegisterRootObject(PickupCarrier);
     51        RegisterObject(PickupCarrier);
    5052    }
    5153

  • code/trunk/src/orxonox/interfaces/PickupCarrier.h

    r7552 r9667  
    4141#include <vector>
    4242
    43 #include "core/OrxonoxClass.h"
     43#include "core/class/OrxonoxInterface.h"
    4444
    4545namespace orxonox
    … …  
    6666    @ingroup Pickup
    6767    */
    68     class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
     68    class _OrxonoxExport PickupCarrier : virtual public OrxonoxInterface
    6969    {
    7070        // So that the different Pickupables have full access to their PickupCarrier.

  • code/trunk/src/orxonox/interfaces/PickupListener.cc

    r8351 r9667  
    4747    PickupListener::PickupListener()
    4848    {
    49         RegisterRootObject(PickupListener);
     49        RegisterObject(PickupListener);
    5050    }
    5151

  • code/trunk/src/orxonox/interfaces/PickupListener.h

    r8351 r9667  
    3939#include "Pickupable.h"
    4040
    41 #include "core/OrxonoxClass.h"
     41#include "core/class/OrxonoxInterface.h"
    4242
    4343namespace orxonox
    … …  
    5555    @ingroup Pickup
    5656    */
    57     class _OrxonoxExport PickupListener : virtual public OrxonoxClass
     57    class _OrxonoxExport PickupListener : virtual public OrxonoxInterface
    5858    {
    5959        public:

  • code/trunk/src/orxonox/interfaces/Pickupable.cc

    r9348 r9667  
    3434#include "Pickupable.h"
    3535
    36 #include "core/Identifier.h"
     36#include "core/class/Identifier.h"
    3737#include "core/CoreIncludes.h"
    3838#include "util/Convert.h"
    … …  
    4646namespace orxonox
    4747{
     48    RegisterAbstractClass(Pickupable).inheritsFrom(Class(OrxonoxInterface)).inheritsFrom(Class(Rewardable));
    4849
    4950    /**
    … …  
    5354    Pickupable::Pickupable() : used_(false), pickedUp_(false)
    5455    {
    55         RegisterRootObject(Pickupable);
     56        RegisterObject(Pickupable);
    5657
    5758        this->carrier_ = NULL;
    … …  
    7172    /**
    7273    @brief
    73         A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
     74        A method that is called by Destroyable::destroy() before the object is actually destroyed.
    7475    */
    7576    void Pickupable::preDestroy(void)
    … …  
    9899    {
    99100        if(!this->isBeingDestroyed())
    100             this->OrxonoxClass::destroy();
     101            this->Destroyable::destroy();
    101102        else
    102103            orxout(internal_warning, context::pickups) << this->getIdentifier()->getName() << " may be unsafe. " << endl;

  • code/trunk/src/orxonox/interfaces/Pickupable.h

    r9348 r9667  
    3939
    4040#include <list>
    41 #include "core/Super.h"
     41#include "core/class/Super.h"
    4242
    43 #include "core/OrxonoxClass.h"
     43#include "core/class/OrxonoxInterface.h"
    4444#include "Rewardable.h"
    4545
    … …  
    5858    @ingroup Pickup
    5959    */
    60     class _OrxonoxExport Pickupable : virtual public OrxonoxClass, public Rewardable
     60    class _OrxonoxExport Pickupable : virtual public OrxonoxInterface, public Rewardable
    6161    {
    6262        friend class PickupCarrier;
    … …  
    144144
    145145        protected:
    146             virtual void preDestroy(void); //!< A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
     146            virtual void preDestroy(void); //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
    147147            virtual void destroyPickup(void); //!< Destroys a Pickupable.
    148148            virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.

  • code/trunk/src/orxonox/interfaces/PlayerTrigger.h

    r8706 r9667  
    3838#include "OrxonoxPrereqs.h"
    3939
    40 #include "core/OrxonoxClass.h"
    41 #include "core/WeakPtr.h"
     40#include "core/class/OrxonoxInterface.h"
     41#include "core/object/WeakPtr.h"
    4242
    4343namespace orxonox
    … …  
    5252    @ingroup Triggers
    5353    */
    54     class _OrxonoxExport PlayerTrigger : virtual public OrxonoxClass
     54    class _OrxonoxExport PlayerTrigger : virtual public OrxonoxInterface
    5555    {
    5656    public:

  • code/trunk/src/orxonox/interfaces/RadarListener.h

    r7163 r9667  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "core/OrxonoxClass.h"
     33#include "core/class/OrxonoxInterface.h"
    3434
    3535namespace orxonox
    3636{
    37     class _OrxonoxExport RadarListener : virtual public OrxonoxClass
     37    class _OrxonoxExport RadarListener : virtual public OrxonoxInterface
    3838    {
    3939    public:

  • code/trunk/src/orxonox/interfaces/RadarViewable.cc

    r9526 r9667  
    3838namespace orxonox
    3939{
     40    RegisterAbstractClass(RadarViewable).inheritsFrom(Class(OrxonoxInterface));
     41
    4042    /**
    4143        @brief Constructor.
    … …  
    4547        , bVisibility_(true)
    4648        , bInitialized_(false)
    47         , creator_(creator)
    4849        , wePtr_(wePtr)
    4950        , radarObjectCamouflage_(0.0f)
    … …  
    5253        , scale_(1.0f)
    5354    {
    54         RegisterRootObject(RadarViewable);
     55        RegisterObject(RadarViewable);
    5556
    5657        this->uniqueId_=getUniqueNumberString();
    5758        if( GameMode::showsGraphics() )
    5859        {
    59             this->radar_ = this->creator_->getScene()->getRadar();
     60            this->radar_ = creator->getScene()->getRadar();
    6061            this->radar_->addRadarObject(this);
    6162        }

  • code/trunk/src/orxonox/interfaces/RadarViewable.h

    r9526 r9667  
    3636
    3737#include "util/Math.h"
    38 #include "core/OrxonoxClass.h"
    39 #include "core/SmartPtr.h"
     38#include "core/class/OrxonoxInterface.h"
     39#include "core/object/SmartPtr.h"
    4040
    4141namespace orxonox
    … …  
    4646    @brief Interface for receiving window events.
    4747    */
    48     class _OrxonoxExport RadarViewable : virtual public OrxonoxClass
     48    class _OrxonoxExport RadarViewable : virtual public OrxonoxInterface
    4949    {
    5050    public:
    … …  
    153153        //Map
    154154        std::string uniqueId_;
    155         BaseObject* creator_;
    156155
    157156

  • code/trunk/src/orxonox/interfaces/Rewardable.h

    r7163 r9667  
    3636
    3737#include "OrxonoxPrereqs.h"
    38 #include "core/OrxonoxClass.h"
     38#include "core/class/OrxonoxInterface.h"
    3939
    4040namespace orxonox
    … …  
    4848        Damian 'Mozork' Frick
    4949    */
    50     class _OrxonoxExport Rewardable : virtual public OrxonoxClass
     50    class _OrxonoxExport Rewardable : virtual public OrxonoxInterface
    5151    {
    5252        public:

  • code/trunk/src/orxonox/interfaces/TeamColourable.h

    r5781 r9667  
    3333
    3434#include "util/UtilPrereqs.h"
    35 #include "core/OrxonoxClass.h"
     35#include "core/class/OrxonoxInterface.h"
    3636
    3737namespace orxonox
    3838{
    39     class _OrxonoxExport TeamColourable : virtual public OrxonoxClass
     39    class _OrxonoxExport TeamColourable : virtual public OrxonoxInterface
    4040    {
    4141        public:

  • code/trunk/src/orxonox/items/Engine.cc

    r8858 r9667  
    3030
    3131#include "core/CoreIncludes.h"
    32 #include "core/ConfigValueIncludes.h"
     32#include "core/config/ConfigValueIncludes.h"
    3333#include "core/Template.h"
    3434#include "core/XMLPort.h"
    … …  
    4040namespace orxonox
    4141{
    42     CreateFactory(Engine);
     42    RegisterClass(Engine);
    4343
    4444    /**
    … …  
    4646        Constructor. Registers and initializes the object.
    4747    */
    48     Engine::Engine(BaseObject* creator) : Item(creator)
     48    Engine::Engine(Context* context) : Item(context)
    4949    {
    5050        RegisterObject(Engine);

  • code/trunk/src/orxonox/items/Engine.h

    r8727 r9667  
    5656    {
    5757        public:
    58             Engine(BaseObject* creator);
     58            Engine(Context* context);
    5959            virtual ~Engine();
    6060

  • code/trunk/src/orxonox/items/Item.cc

    r5781 r9667  
    3232namespace orxonox
    3333{
    34     Item::Item(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     34    RegisterClass(Item);
     35
     36    Item::Item(Context* context) : BaseObject(context), Synchronisable(context)
    3537    {
    3638        RegisterObject(Item);

  • code/trunk/src/orxonox/items/Item.h

    r5781 r9667  
    4040    {
    4141        public:
    42             Item(BaseObject* creator);
     42            Item(Context* context);
    4343            virtual ~Item() {}
    4444    };

  • code/trunk/src/orxonox/items/MultiStateEngine.cc

    r8727 r9667  
    4949    static const float MAX_VELOCITY_BOOST = 221;
    5050
    51     CreateFactory(MultiStateEngine);
    52 
    53     MultiStateEngine::MultiStateEngine(BaseObject* creator) : Engine(creator)
     51    RegisterClass(MultiStateEngine);
     52
     53    MultiStateEngine::MultiStateEngine(Context* context) : Engine(context)
    5454    {
    5555        RegisterObject(MultiStateEngine);
    … …  
    5757        if (GameMode::isMaster())
    5858        {
    59             this->defEngineSndNormal_ = new WorldSound(this);
    60             this->defEngineSndBoost_  = new WorldSound(this);
     59            this->defEngineSndNormal_ = new WorldSound(this->getContext());
     60            this->defEngineSndBoost_  = new WorldSound(this->getContext());
    6161            this->defEngineSndNormal_->setLooping(true);
    6262            this->defEngineSndBoost_->setLooping(true);

  • code/trunk/src/orxonox/items/MultiStateEngine.h

    r8727 r9667  
    4949            };
    5050
    51             MultiStateEngine(BaseObject* creator);
     51            MultiStateEngine(Context* context);
    5252            virtual ~MultiStateEngine();
    5353

  • code/trunk/src/orxonox/overlays/GUISheet.cc

    r7401 r9667  
    3636namespace orxonox
    3737{
    38     CreateFactory(GUISheet);
     38    RegisterClass(GUISheet);
    3939
    40     GUISheet::GUISheet(BaseObject* creator)
    41         : BaseObject(creator)
     40    GUISheet::GUISheet(Context* context)
     41        : BaseObject(context)
    4242        , bShowOnLoad_(false)
    4343        , bHidePrevious_(false)

  • code/trunk/src/orxonox/overlays/GUISheet.h

    r7401 r9667  
    4141    {
    4242    public:
    43         GUISheet(BaseObject* creator);
     43        GUISheet(Context* context);
    4444        ~GUISheet();
    4545

  • code/trunk/src/orxonox/overlays/InGameConsole.cc

    r9550 r9667  
    4949#include "util/output/OutputManager.h"
    5050#include "core/CoreIncludes.h"
    51 #include "core/ConfigValueIncludes.h"
     51#include "core/config/ConfigValueIncludes.h"
    5252#include "core/command/ConsoleCommand.h"
    5353#include "core/GUIManager.h"
    … …  
    110110
    111111        // destroy the underlaying shell
    112         this->shell_->destroy();
     112        delete this->shell_;
    113113
    114114        Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();

  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

    r8858 r9667  
    6363    SetConsoleCommand("OrxonoxOverlay", "rotateOverlay",    &OrxonoxOverlay::rotateOverlay);
    6464
    65     OrxonoxOverlay::OrxonoxOverlay(BaseObject* creator)
    66         : BaseObject(creator)
     65    RegisterClass(OrxonoxOverlay);
     66
     67    OrxonoxOverlay::OrxonoxOverlay(Context* context)
     68        : BaseObject(context)
    6769    {
    6870        RegisterObject(OrxonoxOverlay);

  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

    r8706 r9667  
    4242#include "util/OgreForwardRefs.h"
    4343#include "core/BaseObject.h"
    44 #include "core/Super.h"
    4544#include "core/WindowEventListener.h"
     45#include "core/class/Super.h"
    4646
    4747namespace orxonox
    … …  
    8787
    8888    public:
    89         OrxonoxOverlay(BaseObject* creator);
     89        OrxonoxOverlay(Context* context);
    9090        virtual ~OrxonoxOverlay();
    9191

  • code/trunk/src/orxonox/overlays/OverlayGroup.cc

    r8309 r9667  
    4141namespace orxonox
    4242{
    43     CreateFactory(OverlayGroup);
     43    RegisterClass(OverlayGroup);
    4444
    4545    SetConsoleCommand("OverlayGroup", "toggleVisibility", &OverlayGroup::toggleVisibility);
    … …  
    4848    SetConsoleCommand("OverlayGroup", "scrollGroup",      &OverlayGroup::scrollGroup);
    4949
    50     OverlayGroup::OverlayGroup(BaseObject* creator)
    51         : BaseObject(creator)
     50    OverlayGroup::OverlayGroup(Context* context)
     51        : BaseObject(context)
    5252    {
    5353        RegisterObject(OverlayGroup);
    … …  
    148148        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    149149            (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
     150    }
     151
     152    //! Changes the gametype of all elements
     153    void OverlayGroup::changedGametype()
     154    {
     155        SUPER( OverlayGroup, changedGametype );
     156
     157        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     158            (*it)->setGametype(this->getGametype());
    150159    }
    151160

  • code/trunk/src/orxonox/overlays/OverlayGroup.h

    r8309 r9667  
    5454    {
    5555    public:
    56         OverlayGroup(BaseObject* creator);
     56        OverlayGroup(Context* context);
    5757        //! Empty destructor.
    5858        ~OverlayGroup();
    … …  
    6868            { return this->hudElements_; }
    6969
    70         void changedVisibility();
     70        virtual void changedVisibility();
     71        virtual void changedGametype();
    7172
    7273        void setOwner(BaseObject* owner);

  • code/trunk/src/orxonox/sound/BaseSound.cc

    r8858 r9667  
    4343namespace orxonox
    4444{
     45    RegisterAbstractClass(BaseSound).inheritsFrom(Class(Listable));
     46
    4547    BaseSound::BaseSound()
    4648        : bPooling_(false)
    … …  
    5052        , pitch_ (1.0)
    5153    {
    52         RegisterRootObject(BaseSound);
     54        RegisterObject(BaseSound);
    5355
    5456        // Initialise audioSource_ to a value that is not a source

  • code/trunk/src/orxonox/sound/BaseSound.h

    r7856 r9667  
    3535#include <boost/shared_ptr.hpp>
    3636#include <OgreDataStream.h>
    37 #include "core/OrxonoxClass.h"
     37#include "core/object/Listable.h"
    3838
    3939namespace orxonox
    … …  
    4343     * It serves as main interface to the OpenAL library.
    4444     */
    45     class _OrxonoxExport BaseSound : virtual public OrxonoxClass
     45    class _OrxonoxExport BaseSound : virtual public Listable
    4646    {
    4747    public:

  • code/trunk/src/orxonox/sound/SoundManager.cc

    r8903 r9667  
    3939#include "util/Clock.h"
    4040#include "util/ScopedSingletonManager.h"
    41 #include "core/ConfigValueIncludes.h"
     41#include "core/config/ConfigValueIncludes.h"
    4242#include "core/CoreIncludes.h"
    4343#include "core/GameMode.h"
    … …  
    6969        : effectsPoolSize_(0)
    7070    {
    71         RegisterRootObject(SoundManager);
     71        RegisterObject(SoundManager);
    7272
    7373        orxout(user_status) << "Loading sound" << endl;

  • code/trunk/src/orxonox/sound/SoundManager.h

    r8351 r9667  
    3939
    4040#include "util/Singleton.h"
    41 #include "core/OrxonoxClass.h"
    42 #include "core/SmartPtr.h"
     41#include "core/config/Configurable.h"
     42#include "core/object/SmartPtr.h"
    4343
    4444// tolua_begin
    … …  
    5959    class _OrxonoxExport SoundManager
    6060    // tolua_end
    61         : public Singleton<SoundManager>, public OrxonoxClass
     61        : public Singleton<SoundManager>, public Configurable
    6262    { // tolua_export
    6363        friend class Singleton<SoundManager>;

  • code/trunk/src/orxonox/sound/WorldAmbientSound.cc

    r7854 r9667  
    3636namespace orxonox
    3737{
    38     CreateFactory(WorldAmbientSound);
     38    RegisterClass(WorldAmbientSound);
    3939
    40     WorldAmbientSound::WorldAmbientSound(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     40    WorldAmbientSound::WorldAmbientSound(Context* context) : BaseObject(context), Synchronisable(context)
    4141    {
    4242        RegisterObject(WorldAmbientSound);

  • code/trunk/src/orxonox/sound/WorldAmbientSound.h

    r7854 r9667  
    4444    {
    4545        public:
    46             WorldAmbientSound(BaseObject* creator);
     46            WorldAmbientSound(Context* context);
    4747            virtual ~WorldAmbientSound();
    4848

  • code/trunk/src/orxonox/sound/WorldSound.cc

    r8858 r9667  
    4141namespace orxonox
    4242{
    43     CreateFactory(WorldSound);
     43    RegisterClass(WorldSound);
    4444
    45     WorldSound::WorldSound(BaseObject* creator)
    46         : StaticEntity(creator)
     45    WorldSound::WorldSound(Context* context)
     46        : StaticEntity(context)
    4747    {
    4848        RegisterObject(WorldSound);

  • code/trunk/src/orxonox/sound/WorldSound.h

    r7854 r9667  
    4545    {
    4646    public:
    47         WorldSound(BaseObject* creator);
     47        WorldSound(Context* context);
    4848
    4949        void XMLPort(Element& xmlelement, XMLPort::Mode mode);

  • code/trunk/src/orxonox/weaponsystem/DefaultWeaponmodeLink.cc

    r5781 r9667  
    3535namespace orxonox
    3636{
    37     CreateFactory(DefaultWeaponmodeLink);
     37    RegisterClass(DefaultWeaponmodeLink);
    3838
    39     DefaultWeaponmodeLink::DefaultWeaponmodeLink(BaseObject* creator) : BaseObject(creator)
     39    DefaultWeaponmodeLink::DefaultWeaponmodeLink(Context* context) : BaseObject(context)
    4040    {
    4141        RegisterObject(DefaultWeaponmodeLink);

  • code/trunk/src/orxonox/weaponsystem/DefaultWeaponmodeLink.h

    r5781 r9667  
    3939    {
    4040        public:
    41             DefaultWeaponmodeLink(BaseObject* creator);
     41            DefaultWeaponmodeLink(Context* context);
    4242            virtual ~DefaultWeaponmodeLink();
    4343

  • code/trunk/src/orxonox/weaponsystem/Munition.cc

    r8729 r9667  
    3535namespace orxonox
    3636{
    37     CreateFactory(Munition);
    38 
    39     Munition::Munition(BaseObject* creator) : BaseObject(creator)
     37    RegisterClass(Munition);
     38
     39    Munition::Munition(Context* context) : BaseObject(context)
    4040    {
    4141        RegisterObject(Munition);

  • code/trunk/src/orxonox/weaponsystem/Munition.h

    r7851 r9667  
    5656
    5757        public:
    58             Munition(BaseObject* creator);
     58            Munition(Context* context);
    5959            virtual ~Munition();
    6060

  • code/trunk/src/orxonox/weaponsystem/Weapon.cc

    r5929 r9667  
    3939namespace orxonox
    4040{
    41     CreateFactory(Weapon);
     41    RegisterClass(Weapon);
    4242
    43     Weapon::Weapon(BaseObject* creator) : StaticEntity(creator)
     43    Weapon::Weapon(Context* context) : StaticEntity(context)
    4444    {
    4545        RegisterObject(Weapon);

  • code/trunk/src/orxonox/weaponsystem/Weapon.h

    r5929 r9667  
    4242    {
    4343        public:
    44             Weapon(BaseObject* creator);
     44            Weapon(Context* context);
    4545            virtual ~Weapon();
    4646

  • code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

    r8858 r9667  
    4545namespace orxonox
    4646{
    47     WeaponMode::WeaponMode(BaseObject* creator) : BaseObject(creator)
     47    RegisterAbstractClass(WeaponMode).inheritsFrom(Class(BaseObject));
     48
     49    WeaponMode::WeaponMode(Context* context) : BaseObject(context)
    4850    {
    4951        RegisterObject(WeaponMode);
    … …  
    7577        if( GameMode::isMaster() )
    7678        {
    77             this->defSndWpnFire_ = new WorldSound(this);
     79            this->defSndWpnFire_ = new WorldSound(this->getContext());
    7880            this->defSndWpnFire_->setLooping(false);
    7981            this->bSoundAttached_ = false;

  • code/trunk/src/orxonox/weaponsystem/WeaponMode.h

    r8706 r9667  
    3636#include "util/Math.h"
    3737#include "core/BaseObject.h"
    38 #include "core/SubclassIdentifier.h"
     38#include "core/class/SubclassIdentifier.h"
    3939#include "tools/Timer.h"
    4040
    … …  
    4444    {
    4545        public:
    46             WeaponMode(BaseObject* creator);
     46            WeaponMode(Context* context);
    4747            virtual ~WeaponMode();
    4848

  • code/trunk/src/orxonox/weaponsystem/WeaponPack.cc

    r6417 r9667  
    3838namespace orxonox
    3939{
    40     CreateFactory(WeaponPack);
     40    RegisterClass(WeaponPack);
    4141
    42     WeaponPack::WeaponPack(BaseObject* creator) : BaseObject(creator)
     42    WeaponPack::WeaponPack(Context* context) : BaseObject(context)
    4343    {
    4444        RegisterObject(WeaponPack);

  • code/trunk/src/orxonox/weaponsystem/WeaponPack.h

    r6417 r9667  
    4141    {
    4242        public:
    43             WeaponPack(BaseObject* creator);
     43            WeaponPack(Context* context);
    4444            virtual ~WeaponPack();
    4545

  • code/trunk/src/orxonox/weaponsystem/WeaponSet.cc

    r5781 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(WeaponSet);
     39    RegisterClass(WeaponSet);
    4040
    41     WeaponSet::WeaponSet(BaseObject* creator) : BaseObject(creator)
     41    WeaponSet::WeaponSet(Context* context) : BaseObject(context)
    4242    {
    4343        RegisterObject(WeaponSet);

  • code/trunk/src/orxonox/weaponsystem/WeaponSet.h

    r5781 r9667  
    4141    {
    4242        public:
    43             WeaponSet(BaseObject* creator);
     43            WeaponSet(Context* context);
    4444            virtual ~WeaponSet();
    4545

  • code/trunk/src/orxonox/weaponsystem/WeaponSlot.cc

    r8706 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(WeaponSlot);
     39    RegisterClass(WeaponSlot);
    4040
    41     WeaponSlot::WeaponSlot(BaseObject* creator) : StaticEntity(creator)
     41    WeaponSlot::WeaponSlot(Context* context) : StaticEntity(context)
    4242    {
    4343        RegisterObject(WeaponSlot);

  • code/trunk/src/orxonox/weaponsystem/WeaponSlot.h

    r8891 r9667  
    5757    {
    5858        public:
    59             WeaponSlot(BaseObject* creator);
     59            WeaponSlot(Context* context);
    6060            virtual ~WeaponSlot();
    6161

  • code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

    r8729 r9667  
    3030
    3131#include "core/CoreIncludes.h"
    32 #include "core/SubclassIdentifier.h"
     32#include "core/class/SubclassIdentifier.h"
    3333#include "worldentities/pawns/Pawn.h"
    3434
    … …  
    4646namespace orxonox
    4747{
    48     CreateFactory(WeaponSystem);
    49 
    50     WeaponSystem::WeaponSystem(BaseObject* creator) : BaseObject(creator)
     48    RegisterClass(WeaponSystem);
     49
     50    WeaponSystem::WeaponSystem(Context* context) : BaseObject(context)
    5151    {
    5252        RegisterObject(WeaponSystem);
    … …  
    308308        else if (identifier->getIdentifier()->isA(Class(Munition)))
    309309        {
    310             Munition* munition = identifier->fabricate(this);
     310            Munition* munition = identifier->fabricate(this->getContext());
    311311            this->munitions_[identifier->getIdentifier()] = munition;
    312312            return munition;

  • code/trunk/src/orxonox/weaponsystem/WeaponSystem.h

    r6417 r9667  
    4343    {
    4444        public:
    45             WeaponSystem(BaseObject* creator);
     45            WeaponSystem(Context* context);
    4646            virtual ~WeaponSystem();
    4747

  • code/trunk/src/orxonox/worldentities/BigExplosion.cc

    r8858 r9667  
    4141namespace orxonox
    4242{
    43     CreateFactory(BigExplosion);
    44 
    45     BigExplosion::BigExplosion(BaseObject* creator) : StaticEntity(creator)
     43    RegisterClass(BigExplosion);
     44
     45    BigExplosion::BigExplosion(Context* context) : StaticEntity(context)
    4646    {
    4747        RegisterObject(BigExplosion);
    … …  
    8080    void BigExplosion::init()
    8181    {
    82         this->debrisEntity1_ = new MovableEntity(this);
    83         this->debrisEntity2_ = new MovableEntity(this);
    84         this->debrisEntity3_ = new MovableEntity(this);
    85         this->debrisEntity4_ = new MovableEntity(this);
     82        this->debrisEntity1_ = new MovableEntity(this->getContext());
     83        this->debrisEntity2_ = new MovableEntity(this->getContext());
     84        this->debrisEntity3_ = new MovableEntity(this->getContext());
     85        this->debrisEntity4_ = new MovableEntity(this->getContext());
    8686
    8787        this->debrisEntity1_->setSyncMode(0);
    … …  
    9090        this->debrisEntity4_->setSyncMode(0);
    9191
    92         this->debris1_ = new Model(this);
    93         this->debris2_ = new Model(this);
    94         this->debris3_ = new Model(this);
    95         this->debris4_ = new Model(this);
     92        this->debris1_ = new Model(this->getContext());
     93        this->debris2_ = new Model(this->getContext());
     94        this->debris3_ = new Model(this->getContext());
     95        this->debris4_ = new Model(this->getContext());
    9696
    9797        this->debris1_->setSyncMode(0);
    … …  
    100100        this->debris4_->setSyncMode(0);
    101101
    102         this->explosion_ = new StaticEntity(this);
     102        this->explosion_ = new StaticEntity(this->getContext());
    103103        this->explosion_->setSyncMode(0);
    104104
    … …  
    148148        this->debrisEntity4_->attach(debris4_);
    149149
    150         ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
     150        ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    151151        effect->setDestroyAfterLife(true);
    152152        effect->setSource("Orxonox/explosion2b");
    … …  
    154154        effect->setSyncMode(0);
    155155
    156         ParticleSpawner* effect2 = new ParticleSpawner(this->getCreator());
     156        ParticleSpawner* effect2 = new ParticleSpawner(this->getContext());
    157157        effect2->setDestroyAfterLife(true);
    158158        effect2->setSource("Orxonox/smoke6");
    … …  
    172172        for(int i=0;i<10;i++)
    173173        {
    174             Model* part1 = new Model(this);
    175             Model* part2 = new Model(this);
    176 
    177             MovableEntity* partEntity1 = new MovableEntity(this);
    178             MovableEntity* partEntity2 = new MovableEntity(this);
     174            Model* part1 = new Model(this->getContext());
     175            Model* part2 = new Model(this->getContext());
     176
     177            MovableEntity* partEntity1 = new MovableEntity(this->getContext());
     178            MovableEntity* partEntity2 = new MovableEntity(this->getContext());
    179179
    180180            part1->setSyncMode(0);
    … …  
    225225            {
    226226                this->debris1_->detachOgreObject(this->debrisFire1_->getParticleSystem());
    227                 this->debrisFire1_->destroy();
     227                delete this->debrisFire1_;
    228228            }
    229229            if (this->debrisSmoke1_)
    230230            {
    231231                this->debris1_->detachOgreObject(this->debrisSmoke1_->getParticleSystem());
    232                 this->debrisSmoke1_->destroy();
     232                delete this->debrisSmoke1_;
    233233            }
    234234
    … …  
    236236            {
    237237                this->debris2_->detachOgreObject(this->debrisFire2_->getParticleSystem());
    238                 this->debrisFire2_->destroy();
     238                delete this->debrisFire2_;
    239239            }
    240240            if (this->debrisSmoke2_)
    241241            {
    242242                this->debris2_->detachOgreObject(this->debrisSmoke2_->getParticleSystem());
    243                 this->debrisSmoke2_->destroy();
     243                delete this->debrisSmoke2_;
    244244            }
    245245
    … …  
    247247            {
    248248                this->debris3_->detachOgreObject(this->debrisFire3_->getParticleSystem());
    249                 this->debrisFire3_->destroy();
     249                delete this->debrisFire3_;
    250250            }
    251251            if (this->debrisSmoke3_)
    252252            {
    253253                this->debris3_->detachOgreObject(this->debrisSmoke3_->getParticleSystem());
    254                 this->debrisSmoke3_->destroy();
     254                delete this->debrisSmoke3_;
    255255            }
    256256
    … …  
    258258            {
    259259                this->debris4_->detachOgreObject(this->debrisFire4_->getParticleSystem());
    260                 this->debrisFire4_->destroy();
     260                delete this->debrisFire4_;
    261261            }
    262262            if (this->debrisSmoke4_)
    263263            {
    264264                this->debris4_->detachOgreObject(this->debrisSmoke4_->getParticleSystem());
    265                 this->debrisSmoke4_->destroy();
     265                delete this->debrisSmoke4_;
    266266            }
    267267        }

  • code/trunk/src/orxonox/worldentities/BigExplosion.h

    r7176 r9667  
    4040    {
    4141        public:
    42             BigExplosion(BaseObject* creator);
     42            BigExplosion(Context* context);
    4343            virtual ~BigExplosion();
    4444

  • code/trunk/src/orxonox/worldentities/CameraPosition.cc

    r8706 r9667  
    3535namespace orxonox
    3636{
    37     CreateFactory(CameraPosition);
     37    RegisterClass(CameraPosition);
    3838
    39     CameraPosition::CameraPosition(BaseObject* creator) : StaticEntity(creator)
     39    CameraPosition::CameraPosition(Context* context) : StaticEntity(context)
    4040    {
    4141        RegisterObject(CameraPosition);

  • code/trunk/src/orxonox/worldentities/CameraPosition.h

    r5781 r9667  
    3838    {
    3939        public:
    40             CameraPosition(BaseObject* creator);
     40            CameraPosition(Context* context);
    4141            virtual ~CameraPosition();
    4242

  • code/trunk/src/orxonox/worldentities/ControllableEntity.cc

    r9348 r9667  
    3333
    3434#include "core/CoreIncludes.h"
    35 #include "core/ConfigValueIncludes.h"
     35#include "core/config/ConfigValueIncludes.h"
    3636#include "core/GameMode.h"
    3737#include "core/XMLPort.h"
    … …  
    4747namespace orxonox
    4848{
    49     CreateFactory(ControllableEntity);
     49    RegisterClass(ControllableEntity);
    5050
    5151    registerMemberNetworkFunction( ControllableEntity, fire );
    5252    registerMemberNetworkFunction( ControllableEntity, setTargetInternal );
    5353
    54     ControllableEntity::ControllableEntity(BaseObject* creator) : MobileEntity(creator)
     54    ControllableEntity::ControllableEntity(Context* context) : MobileEntity(context)
    5555    {
    5656        RegisterObject(ControllableEntity);
    … …  
    397397        if (!this->camera_ && GameMode::showsGraphics())
    398398        {
    399             this->camera_ = new Camera(this);
     399            this->camera_ = new Camera(this->getContext());
    400400            this->camera_->requestFocus();
    401401            if (!this->cameraPositionTemplate_.empty())
    … …  
    423423            if (!this->hudtemplate_.empty())
    424424            {
    425                 this->hud_ = new OverlayGroup(this);
     425                this->hud_ = new OverlayGroup(this->getContext());
    426426                this->hud_->addTemplate(this->hudtemplate_);
    427427                this->hud_->setOwner(this);

  • code/trunk/src/orxonox/worldentities/ControllableEntity.h

    r9348 r9667  
    4444
    4545        public:
    46             ControllableEntity(BaseObject* creator);
     46            ControllableEntity(Context* context);
    4747            virtual ~ControllableEntity();
    4848

  • code/trunk/src/orxonox/worldentities/Drone.cc

    r7163 r9667  
    3434namespace orxonox
    3535{
    36     CreateFactory(Drone);
     36    RegisterClass(Drone);
    3737    /**
    3838    @brief
    3939        Constructor. Registers the object and initializes some default values.
    4040    */
    41     Drone::Drone(BaseObject* creator) : Pawn(creator)
     41    Drone::Drone(Context* context) : Pawn(context)
    4242    {
    4343        RegisterObject(Drone);
    … …  
    5050        this->setCollisionType(WorldEntity::Dynamic);
    5151
    52         myController_ = new DroneController(static_cast<BaseObject*>(this)); //!< Creates a new controller and passes our this pointer to it as creator.
     52        myController_ = new DroneController(this->getContext()); //!< Creates a new controller and passes our this pointer to it as creator.
    5353        myController_->setDrone(this);
    5454

  • code/trunk/src/orxonox/worldentities/Drone.h

    r7163 r9667  
    4747    {
    4848        public:
    49             Drone(BaseObject* creator);
     49            Drone(Context* context);
    5050            virtual ~Drone();
    5151

  • code/trunk/src/orxonox/worldentities/EffectContainer.cc

    r6417 r9667  
    4040namespace orxonox
    4141{
    42     CreateFactory(EffectContainer);
     42    RegisterClass(EffectContainer);
    4343
    44     EffectContainer::EffectContainer(BaseObject* creator)
    45         : BaseObject(creator)
     44    EffectContainer::EffectContainer(Context* context)
     45        : BaseObject(context)
    4646        , lua_(NULL)
    4747    {

  • code/trunk/src/orxonox/worldentities/EffectContainer.h

    r6417 r9667  
    4040    {
    4141        public:
    42             EffectContainer(BaseObject* creator);
     42            EffectContainer(Context* context);
    4343            virtual ~EffectContainer();
    4444

  • code/trunk/src/orxonox/worldentities/ExplosionChunk.cc

    r8858 r9667  
    3838namespace orxonox
    3939{
    40     CreateFactory(ExplosionChunk);
     40    RegisterClass(ExplosionChunk);
    4141
    42     ExplosionChunk::ExplosionChunk(BaseObject* creator) : MovableEntity(creator)
     42    ExplosionChunk::ExplosionChunk(Context* context) : MovableEntity(context)
    4343    {
    4444        RegisterObject(ExplosionChunk);
    … …  
    9292            {
    9393                this->detachOgreObject(this->fire_->getParticleSystem());
    94                 this->fire_->destroy();
     94                delete this->fire_;
    9595            }
    9696            if (this->smoke_)
    9797            {
    9898                this->detachOgreObject(this->smoke_->getParticleSystem());
    99                 this->smoke_->destroy();
     99                delete this->smoke_;
    100100            }
    101101        }

  • code/trunk/src/orxonox/worldentities/ExplosionChunk.h

    r7163 r9667  
    4040    {
    4141        public:
    42             ExplosionChunk(BaseObject* creator);
     42            ExplosionChunk(Context* context);
    4343            virtual ~ExplosionChunk();
    4444

  • code/trunk/src/orxonox/worldentities/MobileEntity.cc

    r8858 r9667  
    3939namespace orxonox
    4040{
    41     MobileEntity::MobileEntity(BaseObject* creator) : WorldEntity(creator)
     41    RegisterClass(MobileEntity);
     42
     43    MobileEntity::MobileEntity(Context* context) : WorldEntity(context)
    4244    {
    4345        RegisterObject(MobileEntity);

  • code/trunk/src/orxonox/worldentities/MobileEntity.h

    r8727 r9667  
    4141    {
    4242        public:
    43             MobileEntity(BaseObject* creator);
     43            MobileEntity(Context* context);
    4444            virtual ~MobileEntity();
    4545

  • code/trunk/src/orxonox/worldentities/MovableEntity.cc

    r7284 r9667  
    4141    static const float CONTINUOUS_SYNCHRONIZATION_TIME = 10.0f;
    4242
    43     CreateFactory(MovableEntity);
     43    RegisterClass(MovableEntity);
    4444
    45     MovableEntity::MovableEntity(BaseObject* creator) : MobileEntity(creator)
     45    MovableEntity::MovableEntity(Context* context) : MobileEntity(context)
    4646    {
    4747        RegisterObject(MovableEntity);

  • code/trunk/src/orxonox/worldentities/MovableEntity.h

    r7163 r9667  
    4343    {
    4444        public:
    45             MovableEntity(BaseObject* creator);
     45            MovableEntity(Context* context);
    4646            virtual ~MovableEntity();
    4747

  • code/trunk/src/orxonox/worldentities/SpawnPoint.cc

    r8858 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(SpawnPoint);
     39    RegisterClass(SpawnPoint);
    4040
    41     SpawnPoint::SpawnPoint(BaseObject* creator) : StaticEntity(creator)
     41    SpawnPoint::SpawnPoint(Context* context) : StaticEntity(context)
    4242    {
    4343        RegisterObject(SpawnPoint);
    … …  
    8181    Pawn* SpawnPoint::spawn()
    8282    {
    83         Pawn* entity = this->spawnclass_.fabricate(this);
     83        Pawn* entity = this->spawnclass_.fabricate(this->getContext());
    8484        if (entity)
    8585        {

  • code/trunk/src/orxonox/worldentities/SpawnPoint.h

    r5929 r9667  
    3333
    3434#include <string>
    35 #include "core/SubclassIdentifier.h"
     35#include "core/class/SubclassIdentifier.h"
    3636#include "worldentities/StaticEntity.h"
    3737
    … …  
    4141    {
    4242        public:
    43             SpawnPoint(BaseObject* creator);
     43            SpawnPoint(Context* context);
    4444            virtual ~SpawnPoint() {}
    4545

  • code/trunk/src/orxonox/worldentities/StaticEntity.cc

    r8858 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(StaticEntity);
     39    RegisterClass(StaticEntity);
    4040
    41     StaticEntity::StaticEntity(BaseObject* creator) : WorldEntity(creator)
     41    StaticEntity::StaticEntity(Context* context) : WorldEntity(context)
    4242    {
    4343        RegisterObject(StaticEntity);

  • code/trunk/src/orxonox/worldentities/StaticEntity.h

    r7163 r9667  
    3939    {
    4040        public:
    41             StaticEntity(BaseObject* creator);
     41            StaticEntity(Context* context);
    4242            virtual ~StaticEntity();
    4343

  • code/trunk/src/orxonox/worldentities/TeamSpawnPoint.cc

    r5781 r9667  
    3434namespace orxonox
    3535{
    36     CreateFactory(TeamSpawnPoint);
     36    RegisterClass(TeamSpawnPoint);
    3737
    38     TeamSpawnPoint::TeamSpawnPoint(BaseObject* creator) : SpawnPoint(creator)
     38    TeamSpawnPoint::TeamSpawnPoint(Context* context) : SpawnPoint(context)
    3939    {
    4040        RegisterObject(TeamSpawnPoint);

  • code/trunk/src/orxonox/worldentities/TeamSpawnPoint.h

    r5781 r9667  
    4040    {
    4141        public:
    42             TeamSpawnPoint(BaseObject* creator);
     42            TeamSpawnPoint(Context* context);
    4343            virtual ~TeamSpawnPoint() {}
    4444

  • code/trunk/src/orxonox/worldentities/WorldEntity.cc

    r8858 r9667  
    6161    BOOST_STATIC_ASSERT((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::World);
    6262
     63    RegisterAbstractClass(WorldEntity).inheritsFrom(Class(BaseObject)).inheritsFrom(Class(Synchronisable));
     64
    6365    /**
    6466    @brief
    … …  
    6668        All the default values are being set here.
    6769    */
    68     WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     70    WorldEntity::WorldEntity(Context* context) : BaseObject(context), Synchronisable(context)
    6971    {
    7072        RegisterObject(WorldEntity);
    … …  
    9294        this->bPhysicsActiveSynchronised_    = false;
    9395        this->bPhysicsActiveBeforeAttaching_ = false;
    94         this->collisionShape_ = new WorldEntityCollisionShape(this);
     96        this->collisionShape_ = new WorldEntityCollisionShape(this->getContext());
     97        this->collisionShape_->setWorldEntityOwner(this);
    9598        this->collisionType_             = None;
    9699        this->collisionTypeSynchronised_ = None;

  • code/trunk/src/orxonox/worldentities/WorldEntity.h

    r7910 r9667  
    9090
    9191        public:
    92             WorldEntity(BaseObject* creator);
     92            WorldEntity(Context* context);
    9393            virtual ~WorldEntity();
    9494

  • code/trunk/src/orxonox/worldentities/pawns/Destroyer.cc

    r5929 r9667  
    3434namespace orxonox
    3535{
    36     CreateFactory(Destroyer);
     36    RegisterClass(Destroyer);
    3737
    38     Destroyer::Destroyer(BaseObject* creator) : SpaceShip(creator)
     38    Destroyer::Destroyer(Context* context) : SpaceShip(context)
    3939    {
    4040        RegisterObject(Destroyer);

  • code/trunk/src/orxonox/worldentities/pawns/Destroyer.h

    r5781 r9667  
    3939    {
    4040        public:
    41             Destroyer(BaseObject* creator);
     41            Destroyer(Context* context);
    4242            virtual ~Destroyer() {};
    4343

  • code/trunk/src/orxonox/worldentities/pawns/FpsPlayer.cc

    r9016 r9667  
    3838
    3939#include "core/CoreIncludes.h"
    40 #include "core/ConfigValueIncludes.h"
     40#include "core/config/ConfigValueIncludes.h"
    4141#include "core/Template.h"
    4242#include "core/XMLPort.h"
    … …  
    5353    const float orientationGain_ = 100;
    5454    const float jumpValue_ = 300;
    55     CreateFactory(FpsPlayer);
    56 
    57     FpsPlayer::FpsPlayer(BaseObject* creator) : Pawn(creator)
     55    RegisterClass(FpsPlayer);
     56
     57    FpsPlayer::FpsPlayer(Context* context) : Pawn(context)
    5858    {
    5959        RegisterObject(FpsPlayer);

  • code/trunk/src/orxonox/worldentities/pawns/FpsPlayer.h

    r9016 r9667  
    4343    {
    4444        public:
    45             FpsPlayer(BaseObject* creator);
     45            FpsPlayer(Context* context);
    4646            virtual ~FpsPlayer();
    4747

  • code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

    r9666 r9667  
    5151namespace orxonox
    5252{
    53     CreateFactory(Pawn);
    54 
    55     Pawn::Pawn(BaseObject* creator)
    56         : ControllableEntity(creator)
    57         , RadarViewable(creator, static_cast<WorldEntity*>(this))
     53    RegisterClass(Pawn);
     54
     55    Pawn::Pawn(Context* context)
     56        : ControllableEntity(context)
     57        , RadarViewable(this, static_cast<WorldEntity*>(this))
    5858    {
    5959        RegisterObject(Pawn);
    … …  
    8686        if (GameMode::isMaster())
    8787        {
    88             this->weaponSystem_ = new WeaponSystem(this);
     88            this->weaponSystem_ = new WeaponSystem(this->getContext());
    8989            this->weaponSystem_->setPawn(this);
    9090        }
    … …  
    299299        if (!this->spawnparticlesource_.empty())
    300300        {
    301             ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
     301            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    302302            effect->setPosition(this->getPosition());
    303303            effect->setOrientation(this->getOrientation());
    … …  
    365365        this->setDestroyWhenPlayerLeft(false);
    366366
    367         BigExplosion* chunk = new BigExplosion(this->getCreator());
     367        BigExplosion* chunk = new BigExplosion(this->getContext());
    368368        chunk->setPosition(this->getPosition());
    369369
    … …  
    373373        // play death effect
    374374        {
    375             ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
     375            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    376376            effect->setPosition(this->getPosition());
    377377            effect->setOrientation(this->getOrientation());
    … …  
    381381        }
    382382        {
    383             ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
     383            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    384384            effect->setPosition(this->getPosition());
    385385            effect->setOrientation(this->getOrientation());
    … …  
    389389        }
    390390        {
    391             ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
     391            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    392392            effect->setPosition(this->getPosition());
    393393            effect->setOrientation(this->getOrientation());
    … …  
    398398        for (unsigned int i = 0; i < this->numexplosionchunks_; ++i)
    399399        {
    400             ExplosionChunk* chunk = new ExplosionChunk(this->getCreator());
     400            ExplosionChunk* chunk = new ExplosionChunk(this->getContext());
    401401            chunk->setPosition(this->getPosition());
    402402        }

  • code/trunk/src/orxonox/worldentities/pawns/Pawn.h

    r9625 r9667  
    4545
    4646        public:
    47             Pawn(BaseObject* creator);
     47            Pawn(Context* context);
    4848            virtual ~Pawn();
    4949

  • code/trunk/src/orxonox/worldentities/pawns/SpaceShip.cc

    r9348 r9667  
    3232
    3333#include "core/CoreIncludes.h"
    34 #include "core/ConfigValueIncludes.h"
     34#include "core/config/ConfigValueIncludes.h"
    3535#include "core/Template.h"
    3636#include "core/XMLPort.h"
    … …  
    4646namespace orxonox
    4747{
    48     CreateFactory(SpaceShip);
    49 
    50     SpaceShip::SpaceShip(BaseObject* creator) : Pawn(creator), boostBlur_(NULL)
     48    RegisterClass(SpaceShip);
     49
     50    SpaceShip::SpaceShip(Context* context) : Pawn(context), boostBlur_(NULL)
    5151    {
    5252        RegisterObject(SpaceShip);
    … …  
    9696
    9797            if (this->boostBlur_)
    98                 this->boostBlur_->destroy();
     98                delete this->boostBlur_;
    9999        }
    100100    }
    … …  
    447447        if (!this->bEnableMotionBlur_ && this->boostBlur_ != NULL)
    448448        {
    449             this->boostBlur_->destroy();
     449            delete this->boostBlur_;
    450450            this->boostBlur_ = NULL;
    451451        }

  • code/trunk/src/orxonox/worldentities/pawns/SpaceShip.h

    r8727 r9667  
    8888    {
    8989        public:
    90             SpaceShip(BaseObject* creator);
     90            SpaceShip(Context* context);
    9191            virtual ~SpaceShip();
    9292

  • code/trunk/src/orxonox/worldentities/pawns/Spectator.cc

    r7863 r9667  
    3131#include "util/Convert.h"
    3232#include "core/CoreIncludes.h"
    33 #include "core/ConfigValueIncludes.h"
     33#include "core/config/ConfigValueIncludes.h"
    3434#include "core/GameMode.h"
    3535#include "core/command/CommandExecutor.h"
    … …  
    4545    extern const std::string __CC_suicide_name;
    4646
    47     CreateFactory(Spectator);
    48 
    49     Spectator::Spectator(BaseObject* creator) : ControllableEntity(creator)
     47    RegisterClass(Spectator);
     48
     49    Spectator::Spectator(Context* context) : ControllableEntity(context)
    5050    {
    5151        RegisterObject(Spectator);

  • code/trunk/src/orxonox/worldentities/pawns/Spectator.h

    r7862 r9667  
    4040    {
    4141        public:
    42             Spectator(BaseObject* creator);
     42            Spectator(Context* context);
    4343            virtual ~Spectator();
    4444

  • code/trunk/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc

    r5929 r9667  
    3737namespace orxonox
    3838{
    39     CreateFactory(TeamBaseMatchBase);
     39    RegisterClass(TeamBaseMatchBase);
    4040
    41     TeamBaseMatchBase::TeamBaseMatchBase(BaseObject* creator) : Pawn(creator)
     41    TeamBaseMatchBase::TeamBaseMatchBase(Context* context) : Pawn(context)
    4242    {
    4343        RegisterObject(TeamBaseMatchBase);

  • code/trunk/src/orxonox/worldentities/pawns/TeamBaseMatchBase.h

    r5781 r9667  
    5050    {
    5151        public:
    52             TeamBaseMatchBase(BaseObject* creator);
     52            TeamBaseMatchBase(Context* context);
    5353
    5454            // if class closes, close everything
Note: See TracChangeset for help on using the changeset viewer.