Changeset 2024 for code/branches/objecthierarchy/src/orxonox/objects

Timestamp:

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

Author:

landauf

Message:

added spaceship

Location:

code/branches/objecthierarchy/src/orxonox/objects

Files:

• Scene.cc (modified) (1 diff)
• controllers/HumanController.cc (modified) (6 diffs)
• gametypes/Gametype.cc (modified) (7 diffs)
• gametypes/Gametype.h (modified) (4 diffs)
• infos/PlayerInfo.cc (modified) (1 diff)
• worldentities/ControllableEntity.h (modified) (4 diffs)
• worldentities/SpawnPoint.cc (modified) (2 diffs)
• worldentities/SpawnPoint.h (modified) (3 diffs)
• worldentities/pawns/Pawn.cc (added)
• worldentities/pawns/Pawn.h (added)
• worldentities/pawns/SpaceShip.cc (added)
• worldentities/pawns/SpaceShip.h (added)
• worldentities/pawns/Spectator.cc (modified) (6 diffs)
• worldentities/pawns/Spectator.h (modified) (3 diffs)

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
     };
 }