Changeset 2024 for code/branches/objecthierarchy

Timestamp:

Oct 28, 2008, 3:05:17 AM (16 years ago)

Author:

landauf

Message:

added spaceship

Location:

code/branches/objecthierarchy/src

Files:

• core/CommandEvaluation.cc (modified) (1 diff)
• core/Identifier.h (modified) (1 diff)
• core/Template.cc (modified) (1 diff)
• orxonox/CMakeLists.txt (modified) (1 diff)
• orxonox/objects/Scene.cc (modified) (1 diff)
• orxonox/objects/controllers/HumanController.cc (modified) (6 diffs)
• orxonox/objects/gametypes/Gametype.cc (modified) (7 diffs)
• orxonox/objects/gametypes/Gametype.h (modified) (4 diffs)
• orxonox/objects/infos/PlayerInfo.cc (modified) (1 diff)
• orxonox/objects/worldentities/ControllableEntity.h (modified) (4 diffs)
• orxonox/objects/worldentities/SpawnPoint.cc (modified) (2 diffs)
• orxonox/objects/worldentities/SpawnPoint.h (modified) (3 diffs)
• orxonox/objects/worldentities/pawns/Pawn.cc (added)
• orxonox/objects/worldentities/pawns/Pawn.h (added)
• orxonox/objects/worldentities/pawns/SpaceShip.cc (added)
• orxonox/objects/worldentities/pawns/SpaceShip.h (added)
• orxonox/objects/worldentities/pawns/Spectator.cc (modified) (6 diffs)
• orxonox/objects/worldentities/pawns/Spectator.h (modified) (3 diffs)
• orxonox/overlays/OverlayGroup.cc (modified) (1 diff)
• orxonox/overlays/OverlayGroup.h (modified) (2 diffs)
• orxonox/overlays/OverlayText.cc (modified) (3 diffs)
• orxonox/overlays/OverlayText.h (modified) (2 diffs)

code/branches/objecthierarchy/src/core/CommandEvaluation.cc

@@ -78 +78 @@
         if (this->bEvaluatedParams_ && this->function_)
         {
-            COUT(5) << "CE_execute (evaluation): " << this->function_->getName() << " " << this->param_[0] << " " << this->param_[1] << " " << this->param_[2] << " " << this->param_[3] << " " << this->param_[4] << std::endl;
+            COUT(6) << "CE_execute (evaluation): " << this->function_->getName() << " " << this->param_[0] << " " << this->param_[1] << " " << this->param_[2] << " " << this->param_[3] << " " << this->param_[4] << std::endl;
             (*this->function_)(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
             return true;

code/branches/objecthierarchy/src/core/Identifier.h

@@ -487 +487 @@
             SubclassIdentifier<T>& operator=(Identifier* identifier)
             {
-                if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
                 {
                     COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
-                    COUT(1) << "Aborting..." << std::endl;
-                    abort();
+                    if (identifier)
+                    {
+                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
+                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    }
+                    else
+                    {
+                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                    }
                 }
-                this->identifier_ = identifier;
+                else
+                {
+                    this->identifier_ = identifier;
+                }
                 return *this;
             }

code/branches/objecthierarchy/src/core/Template.cc

@@ -149 +149 @@
             return it->second;
         else
+        {
+            COUT(2) << "Warning: Template with name " << name << " doesn't exist." << std::endl;
             return 0;
+        }
     }
 

code/branches/objecthierarchy/src/orxonox/CMakeLists.txt

@@ -69 +69 @@
 
   objects/worldentities/pawns/Spectator.cc
+  objects/worldentities/pawns/Pawn.cc
+  objects/worldentities/pawns/SpaceShip.cc
 
   objects/controllers/Controller.cc

code/branches/objecthierarchy/src/orxonox/objects/Scene.cc

@@ -85 +85 @@
     Scene::~Scene()
     {
-        if (Ogre::Root::getSingletonPtr())
+        if (this->isInitialized())
         {
-//            this->sceneManager_->destroySceneNode(this->rootSceneNode_->getName()); // TODO: remove getName() for newer versions of Ogre
-            Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
-        }
-        else if (!Core::showsGraphics())
-        {
-            delete this->sceneManager_;
+            if (Ogre::Root::getSingletonPtr())
+            {
+//                this->sceneManager_->destroySceneNode(this->rootSceneNode_->getName()); // TODO: remove getName() for newer versions of Ogre
+                Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
+            }
+            else if (!Core::showsGraphics())
+            {
+                delete this->sceneManager_;
+            }
         }
     }

code/branches/objecthierarchy/src/orxonox/objects/controllers/HumanController.cc

@@ -67 +67 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->moveFrontBack(value.y);
+            HumanController::localController_s->controllableEntity_->moveFrontBack(value);
     }
 
@@ -73 +73 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->moveRightLeft(value.y);
+            HumanController::localController_s->controllableEntity_->moveRightLeft(value);
     }
 
@@ -79 +79 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->moveUpDown(value.y);
+            HumanController::localController_s->controllableEntity_->moveUpDown(value);
     }
 
@@ -85 +85 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->rotateYaw(value.y);
+            HumanController::localController_s->controllableEntity_->rotateYaw(value);
     }
 
@@ -91 +91 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->rotatePitch(value.y);
+            HumanController::localController_s->controllableEntity_->rotatePitch(value);
     }
 
@@ -97 +97 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->rotateRoll(value.y);
+            HumanController::localController_s->controllableEntity_->rotateRoll(value);
     }
 

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc

@@ -48 +48 @@
         RegisterObject(Gametype);
 
-        this->defaultPawn_ = Class(Spectator);
+        this->defaultControllableEntity_ = Class(Spectator);
+
         this->bStarted_ = false;
         this->bEnded_ = false;
         this->bAutoStart_ = false;
+        this->bForceSpawn_ = false;
+
+        this->initialStartCountdown_ = 3;
+        this->startCountdown_ = 0;
+        this->bStartCountdownRunning_ = false;
 
         COUT(0) << "created Gametype" << std::endl;
@@ -58 +64 @@
     void Gametype::tick(float dt)
     {
+        if (this->bStartCountdownRunning_ && !this->bStarted_)
+            this->startCountdown_ -= dt;
+
         if (!this->bStarted_)
             this->checkStart();
 
         this->assignDefaultPawnsIfNeeded();
+        this->spawnDeadPlayersIfRequested();
     }
 
@@ -69 +79 @@
         this->bStarted_ = true;
 
-        for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
-            this->spawnPlayer(*it);
+        this->spawnPlayersIfRequested();
     }
 
@@ -122 +131 @@
     }
 
-    void Gametype::playerSpawned(PlayerInfo* player)
-    {
-    }
-
-    void Gametype::playerDied(PlayerInfo* player)
+    void Gametype::pawnPreSpawn(Pawn* pawn)
+    {
+    }
+
+    void Gametype::pawnPostSpawn(Pawn* pawn)
+    {
+    }
+
+    void Gametype::pawnKilled(Pawn* victim, Pawn* killer)
     {
     }
@@ -164 +177 @@
                 {
                     // force spawn at spawnpoint with default pawn
-                    ControllableEntity* newpawn = this->defaultPawn_.fabricate(spawn);
-                    spawn->spawn(newpawn);
-                    (*it)->startControl(newpawn);
+                    ControllableEntity* entity = this->defaultControllableEntity_.fabricate(spawn);
+                    spawn->spawn(entity);
+                    (*it)->startControl(entity);
                 }
                 else
@@ -181 +194 @@
         if (!this->bStarted_)
         {
-            if (this->players_.size() > 0)
+            if (this->bStartCountdownRunning_)
+            {
+                if (this->startCountdown_ <= 0)
+                {
+                    this->bStartCountdownRunning_ = false;
+                    this->startCountdown_ = 0;
+                    this->start();
+                }
+            }
+            else if (this->players_.size() > 0)
             {
                 if (this->bAutoStart_)
@@ -196 +218 @@
                     }
                     if (allplayersready)
-                        this->start();
-                }
-            }
-        }
+                    {
+                        this->startCountdown_ = this->initialStartCountdown_;
+                        this->bStartCountdownRunning_ = true;
+                    }
+                }
+            }
+        }
+    }
+
+    void Gametype::spawnPlayersIfRequested()
+    {
+        for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+            if ((*it)->isReadyToSpawn() || this->bForceSpawn_)
+                this->spawnPlayer(*it);
+    }
+
+    void Gametype::spawnDeadPlayersIfRequested()
+    {
+        for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+            if (!(*it)->getControllableEntity())
+                if ((*it)->isReadyToSpawn() || this->bForceSpawn_)
+                    this->spawnPlayer(*it);
     }
 
     void Gametype::spawnPlayer(PlayerInfo* player)
     {
-        if (player->isReadyToSpawn())
-        {
-            SpawnPoint* spawnpoint = this->getBestSpawnPoint(player);
-            if (spawnpoint)
-            {
-                player->startControl(spawnpoint->spawn());
-            }
-            else
-            {
-                COUT(1) << "Error: No SpawnPoints in current Gametype" << std::endl;
-                abort();
-            }
+        SpawnPoint* spawnpoint = this->getBestSpawnPoint(player);
+        if (spawnpoint)
+        {
+            player->startControl(spawnpoint->spawn());
+        }
+        else
+        {
+            COUT(1) << "Error: No SpawnPoints in current Gametype" << std::endl;
+            abort();
         }
     }

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h

@@ -51 +51 @@
             virtual void tick(float dt);
 
+            inline bool hasStarted() const
+                { return this->bStarted_; }
+            inline bool hasEnded() const
+                { return this->bEnded_; }
+
             virtual void start();
             virtual void end();
@@ -58 +63 @@
             virtual void playerSwitchedBack(PlayerInfo* player, Gametype* oldgametype);
             virtual void playerChangedName(PlayerInfo* player);
-            virtual void playerSpawned(PlayerInfo* player);
-            virtual void playerDied(PlayerInfo* player);
+
             virtual void playerScored(PlayerInfo* player);
+
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual void pawnPreSpawn(Pawn* pawn);
+            virtual void pawnPostSpawn(Pawn* pawn);
 
             inline const std::set<PlayerInfo*>& getPlayers() const
@@ -67 +75 @@
             inline void registerSpawnPoint(SpawnPoint* spawnpoint)
                 { this->spawnpoints_.insert(spawnpoint); }
+
+            inline bool isStartCountdownRunning() const
+                { return this->bStartCountdownRunning_; }
+            inline float getStartCountdown() const
+                { return this->startCountdown_; }
 
         private:
@@ -77 +90 @@
             void checkStart();
             void spawnPlayer(PlayerInfo* player);
+            void spawnPlayersIfRequested();
+            void spawnDeadPlayersIfRequested();
 
             bool bStarted_;
             bool bEnded_;
             bool bAutoStart_;
+            bool bForceSpawn_;
+
+            float initialStartCountdown_;
+            float startCountdown_;
+            bool bStartCountdownRunning_;
+
             std::set<PlayerInfo*> players_;
             std::set<SpawnPoint*> spawnpoints_;
-            SubclassIdentifier<ControllableEntity> defaultPawn_;
+            SubclassIdentifier<ControllableEntity> defaultControllableEntity_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc

@@ -121 +121 @@
             this->controllableEntityID_ = entity->getObjectID();
             entity->setPlayer(this);
+            this->bReadyToSpawn_ = false;
         }
         else

code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.h

@@ -57 +57 @@
                 { return this->bDestroyWhenPlayerLeft_; }
 
-            virtual void moveFrontBack(float value) {}
-            virtual void moveRightLeft(float value) {}
-            virtual void moveUpDown(float value) {}
+            virtual void moveFrontBack(const Vector2& value) {}
+            virtual void moveRightLeft(const Vector2& value) {}
+            virtual void moveUpDown(const Vector2& value) {}
 
-            virtual void rotateYaw(float value) {}
-            virtual void rotatePitch(float value) {}
-            virtual void rotateRoll(float value) {}
+            virtual void rotateYaw(const Vector2& value) {}
+            virtual void rotatePitch(const Vector2& value) {}
+            virtual void rotateRoll(const Vector2& value) {}
 
             virtual void fire() {}
@@ -108 +108 @@
                 { this->acceleration_.x = x; this->acceleration_.y = y; this->acceleration_.z = z; }
 
+            inline Camera* getCamera() const
+                { return this->camera_; }
+            inline OverlayGroup* getHUD() const
+                { return this->hud_; }
+
         protected:
             virtual void startLocalControl();
@@ -117 +122 @@
             inline bool isLocallyControlled() const
                 { return this->bControlled_; }
+
+            Vector3 acceleration_;
 
         private:
@@ -136 +143 @@
 
             Vector3 velocity_;
-            Vector3 acceleration_;
 
             bool bControlled_;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/SpawnPoint.cc

@@ -57 +57 @@
 
         XMLPortParam(SpawnPoint, "spawnclass", setSpawnClassName, getSpawnClassName, xmlelement, mode);
-        XMLPortParam(SpawnPoint, "design", setTemplateName, getTemplateName, xmlelement, mode);
+        XMLPortParam(SpawnPoint, "pawndesign", setTemplateName, getTemplateName, xmlelement, mode);
     }
 
@@ -72 +72 @@
     }
 
-    ControllableEntity* SpawnPoint::spawn()
+    Pawn* SpawnPoint::spawn()
     {
-        ControllableEntity* entity = this->spawnclass_.fabricate(this);
+        Pawn* entity = this->spawnclass_.fabricate(this);
         if (entity)
         {
+            this->getGametype()->pawnPreSpawn(entity);
             this->spawn(entity);
             if (this->template_)
                 entity->addTemplate(this->template_);
+            entity->postSpawn();
+            this->getGametype()->pawnPostSpawn(entity);
         }
         return entity;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/SpawnPoint.h

@@ -35 +35 @@
 #include "core/Template.h"
 #include "PositionableEntity.h"
-#include "ControllableEntity.h"
+#include "objects/worldentities/pawns/Pawn.h"
 
 namespace orxonox
@@ -57 +57 @@
                 { return this->template_; }
 
-            ControllableEntity* spawn();
+            Pawn* spawn();
             void spawn(ControllableEntity* entity);
 
@@ -69 +69 @@
                 { return this->templatename_; }
 
-            SubclassIdentifier<ControllableEntity> spawnclass_;
+            SubclassIdentifier<Pawn> spawnclass_;
             std::string spawnclassname_;
             Template* template_;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/pawns/Spectator.cc

@@ -35 +35 @@
 #include "objects/Scene.h"
 #include "objects/infos/PlayerInfo.h"
+#include "objects/gametypes/Gametype.h"
 #include "tools/BillboardSet.h"
+#include "overlays/OverlayText.h"
+#include "overlays/OverlayGroup.h"
+#include "util/Convert.h"
 
 namespace orxonox
@@ -54 +58 @@
 
         this->setDestroyWhenPlayerLeft(true);
-
-        // test test test
-        if (this->getScene()->getSceneManager())
-        {
-            this->testmesh_ = new Mesh();
-            this->testnode_ = this->getNode()->createChildSceneNode();
-            this->testmesh_->setMeshSource(this->getScene()->getSceneManager(), "assff.mesh");
-            if (this->testmesh_->getEntity())
-                this->testnode_->attachObject(this->testmesh_->getEntity());
-            this->testnode_->pitch(Degree(-90));
-            this->testnode_->roll(Degree(+90));
-            this->testnode_->scale(10, 10, 10);
-        }
-        else
-        {
-            this->testmesh_ = 0;
-            this->testnode_ = 0;
-        }
-        // test test test
 
         this->greetingFlare_ = new BillboardSet();
@@ -93 +78 @@
                 delete this->greetingFlare_;
             }
-
-            // test test test
-            {
-                if (this->testmesh_ && this->testnode_)
-                    this->testnode_->detachObject(this->testmesh_->getEntity());
-
-                if (this->testmesh_)
-                    delete this->testmesh_;
-
-                if (this->testnode_)
-                    this->getNode()->removeAndDestroyChild(this->testnode_->getName());
-            }
-            // test test test
         }
     }
@@ -130 +102 @@
         if (this->isLocallyControlled())
         {
+            this->updateHUD();
+
             Vector3 velocity = this->getVelocity();
             velocity.normalise();
@@ -159 +133 @@
     {
         ControllableEntity::startLocalControl();
-        if (this->isLocallyControlled())
-            this->testmesh_->setVisible(false);
-    }
-
-    void Spectator::moveFrontBack(float value)
-    {
-        this->setVelocity(this->getVelocity() + value * this->speed_ * WorldEntity::FRONT);
-    }
-
-    void Spectator::moveRightLeft(float value)
-    {
-        this->setVelocity(this->getVelocity() + value * this->speed_ * WorldEntity::RIGHT);
-    }
-
-    void Spectator::moveUpDown(float value)
-    {
-        this->setVelocity(this->getVelocity() + value * this->speed_ * WorldEntity::UP);
-    }
-
-    void Spectator::rotateYaw(float value)
-    {
-        this->yaw_ = value;
-    }
-
-    void Spectator::rotatePitch(float value)
-    {
-        this->pitch_ = value;
-    }
-
-    void Spectator::rotateRoll(float value)
-    {
-        this->roll_ = value;
+//        if (this->isLocallyControlled())
+//            this->testmesh_->setVisible(false);
+    }
+
+    void Spectator::moveFrontBack(const Vector2& value)
+    {
+        this->setVelocity(this->getVelocity() + value.y * this->speed_ * WorldEntity::FRONT);
+    }
+
+    void Spectator::moveRightLeft(const Vector2& value)
+    {
+        this->setVelocity(this->getVelocity() + value.y * this->speed_ * WorldEntity::RIGHT);
+    }
+
+    void Spectator::moveUpDown(const Vector2& value)
+    {
+        this->setVelocity(this->getVelocity() + value.y * this->speed_ * WorldEntity::UP);
+    }
+
+    void Spectator::rotateYaw(const Vector2& value)
+    {
+        this->yaw_ = value.y;
+    }
+
+    void Spectator::rotatePitch(const Vector2& value)
+    {
+        this->pitch_ = value.y;
+    }
+
+    void Spectator::rotateRoll(const Vector2& value)
+    {
+        this->roll_ = value.y;
     }
 
@@ -209 +183 @@
         }
     }
+
+    void Spectator::updateHUD()
+    {
+        // <hack>
+        if (this->getHUD())
+        {
+            std::string text;
+
+            if (this->getPlayer() && this->getGametype())
+            {
+                if (!this->getGametype()->hasStarted() && !this->getGametype()->isStartCountdownRunning())
+                {
+                    if (!this->getPlayer()->isReadyToSpawn())
+                        text = "Press [Fire] to start the match";
+                    else
+                        text = "Waiting for other players";
+                }
+                else if (!this->getGametype()->hasEnded())
+                {
+                    if (this->getGametype()->isStartCountdownRunning())
+                    {
+                        text = convertToString(ceil(this->getGametype()->getStartCountdown()));
+                    }
+                    else
+                    {
+                        text = "Press [Fire] to respawn";
+                    }
+                }
+                else
+                {
+                    text = "Game has ended";
+                }
+            }
+            else
+            {
+                return;
+            }
+
+            std::map<std::string, OrxonoxOverlay*>::const_iterator it = this->getHUD()->getOverlays().begin();
+            for (; it != this->getHUD()->getOverlays().end(); ++it)
+            {
+                if (it->second->isA(Class(OverlayText)) && it->second->getName() == "state")
+                {
+                    OverlayText* overlay = dynamic_cast<OverlayText*>(it->second);
+                    if (overlay)
+                        overlay->setCaption(text);
+                    break;
+                }
+            }
+        }
+        // </hack>
+    }
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/pawns/Spectator.h

@@ -48 +48 @@
             virtual void startLocalControl();
 
-            virtual void moveFrontBack(float value);
-            virtual void moveRightLeft(float value);
-            virtual void moveUpDown(float value);
+            virtual void moveFrontBack(const Vector2& value);
+            virtual void moveRightLeft(const Vector2& value);
+            virtual void moveUpDown(const Vector2& value);
 
-            virtual void rotateYaw(float value);
-            virtual void rotatePitch(float value);
-            virtual void rotateRoll(float value);
+            virtual void rotateYaw(const Vector2& value);
+            virtual void rotatePitch(const Vector2& value);
+            virtual void rotateRoll(const Vector2& value);
 
             virtual void fire();
@@ -62 +62 @@
             void changedGreeting();
             void changedFlareVisibility();
+            void updateHUD();
 
             BillboardSet* greetingFlare_;
@@ -73 +74 @@
             float pitch_;
             float roll_;
-
-            // test test test
-            Mesh* testmesh_;
-            Ogre::SceneNode* testnode_;
-            // test test test
     };
 }

code/branches/objecthierarchy/src/orxonox/overlays/OverlayGroup.cc

@@ -53 +53 @@
     {
         RegisterObject(OverlayGroup);
+    }
+
+    OverlayGroup::~OverlayGroup()
+    {
+        for (std::map<std::string, OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+            delete it->second;
     }
 

code/branches/objecthierarchy/src/orxonox/overlays/OverlayGroup.h

@@ -56 +56 @@
         OverlayGroup(BaseObject* creator);
         //! Empty destructor.
-        ~OverlayGroup() { }
+        ~OverlayGroup();
 
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
@@ -63 +63 @@
         static void scaleGroup(const std::string& name, float scale);
         static void scrollGroup(const std::string& name, const Vector2& scroll);
+
+        inline const std::map<std::string, OrxonoxOverlay*>& getOverlays() const
+            { return this->hudElements_; }
 
         void changedVisibility();

code/branches/objecthierarchy/src/orxonox/overlays/OverlayText.cc

@@ -65 +65 @@
         }
 
-        XMLPortParam(OverlayText, "font",     setFont,     getFont,     xmlElement, mode).defaultValues("Monofur");
-        XMLPortParam(OverlayText, "colour",   setColour,   getColour,   xmlElement, mode).defaultValues(ColourValue(1.0, 1.0, 1.0, 1.0));
-        XMLPortParam(OverlayText, "caption",  setCaption,  getCaption,  xmlElement, mode).defaultValues("");
-        XMLPortParam(OverlayText, "textSize", setTextSize, getTextSize, xmlElement, mode).defaultValues(1.0f);
-        XMLPortParamTemplate(OverlayText, "align", setAlignment, getAlignment, xmlElement, mode, const std::string&).defaultValues("left");
+        XMLPortParam(OverlayText, "font",     setFont,            getFont,            xmlElement, mode).defaultValues("Monofur");
+        XMLPortParam(OverlayText, "colour",   setColour,          getColour,          xmlElement, mode).defaultValues(ColourValue(1.0, 1.0, 1.0, 1.0));
+        XMLPortParam(OverlayText, "caption",  setCaption,         getCaption,         xmlElement, mode).defaultValues("");
+        XMLPortParam(OverlayText, "textSize", setTextSize,        getTextSize,        xmlElement, mode).defaultValues(1.0f);
+        XMLPortParam(OverlayText, "align",    setAlignmentString, getAlignmentString, xmlElement, mode).defaultValues("left");
     }
 
@@ -106 +106 @@
     }
 
-    void OverlayText::setAlignment(const std::string& alignment)
+    Ogre::TextAreaOverlayElement::Alignment OverlayText::getAlignment() const
+    {
+        if (this->text_)
+            return this->text_->getAlignment();
+        else
+            return Ogre::TextAreaOverlayElement::Left;
+    }
+
+    void OverlayText::setAlignmentString(const std::string& alignment)
     {
         if (alignment == "right")
@@ -116 +124 @@
     }
 
-    std::string OverlayText::getAlignment() const
+    std::string OverlayText::getAlignmentString() const
     {
         if (this->text_)

code/branches/objecthierarchy/src/orxonox/overlays/OverlayText.h

@@ -47 +47 @@
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-    protected:
-        virtual void sizeChanged();
-
         void setCaption(const std::string& caption);
         const std::string& getCaption() const       { return this->caption_; }
@@ -60 +57 @@
 
         void setAlignment(Ogre::TextAreaOverlayElement::Alignment alignment);
-        void setAlignment(const std::string& alignment);
-        std::string getAlignment() const;
+        Ogre::TextAreaOverlayElement::Alignment getAlignment() const;
+
+    protected:
+        virtual void sizeChanged();
+
+        void setAlignmentString(const std::string& alignment);
+        std::string getAlignmentString() const;
 
         void setTextSize(float size) { this->setSize(Vector2(size, size)); }