Changeset 11199 for code/branches/presentationFS16/src

Timestamp:

May 26, 2016, 3:13:51 PM (9 years ago)

Author:

fvultier

Message:

merged branch hover

Location:

code/branches/presentationFS16/src/modules

Files:

• hover/CMakeLists.txt (modified) (2 diffs)
• hover/Hover.cc (modified) (5 diffs)
• hover/Hover.h (modified) (4 diffs)
• hover/HoverFlag.cc (modified) (1 diff)
• hover/HoverOrigin.cc (modified) (3 diffs)
• hover/HoverOrigin.h (modified) (2 diffs)
• hover/HoverShip.cc (modified) (3 diffs)
• hover/HoverShip.h (modified) (2 diffs)
• hover/TFlagsLivesLevelHUD.cc (copied) (copied from code/branches/tgidronFS16/src/modules/hover/TFlagsLivesLevelHUD.cc)
• hover/TFlagsLivesLevelHUD.h (copied) (copied from code/branches/tgidronFS16/src/modules/hover/TFlagsLivesLevelHUD.h)
• invader/Invader.cc (modified) (1 diff)
• pickup/PickupSpawner.h (modified) (2 diffs)
• weapons/weaponmodes/HsW01.cc (modified) (1 diff)
• weapons/weaponmodes/HsW01.h (modified) (1 diff)

code/branches/presentationFS16/src/modules/hover/CMakeLists.txt

@@ -8 +8 @@
   FlagHUD.cc
   MazeGenerator.cc
+  TFlagsLivesLevelHUD.cc
 )
 
@@ -17 +18 @@
     objects
     overlays
+    pickup
   SOURCE_FILES ${Hover_SRC_FILES}
 )

code/branches/presentationFS16/src/modules/hover/Hover.cc

@@ -24 +24 @@
  *   Co-authors:
  *      Cyrill Burgener
+ *      Tomer Gidron
  *
  */
@@ -33 +34 @@
 
 #include "Hover.h"
-
+#include "chat/ChatManager.h"
 #include "HoverOrigin.h"
 #include "HoverWall.h"
@@ -39 +40 @@
 #include "MazeGenerator.h"
 #include "core/CoreIncludes.h"
+#include "gamestates/GSLevel.h"
+#include "HoverShip.h"
+
+#include "pickup/PickupSpawner.h"
+#include "pickup/Pickup.h"
 
 namespace orxonox
@@ -51 +57 @@
         this->numberOfFlags_ = 1;
         this->firstTick_ = true;
+        level = 1; //start at level 1
+        flagsTaken = 0;// took 0 flags in the beginning
+        lives = 3;
+
+        numCells = 0;
+        cellSize = 0;
+        cellHeight = 0;
+
+        bLevelUpgradeHUD = false;
+
+        totFlags = 0;
 
         this->setHUDTemplate("HoverHUD");
-    }
-
-    void Hover::tick(float dt)
-    {
-        SUPER(Hover, tick, dt);
-
+
+    }
+
+    void Hover::start()
+    {
+        Gametype::start();
         if(this->firstTick_ && this->origin_)
         {
             this->firstTick_ = false;
 
-            int numCells = this->origin_->getNumCells();
-            int cellSize = this->origin_->getCellSize();
-            int cellHeight = this->origin_->getCellHeight();
+            numCells = this->origin_->getNumCells();
+            cellSize = this->origin_->getCellSize();
+            cellHeight = this->origin_->getCellHeight();
+
+            //TODO
+            //create boolean array/vector to assert that no two objects are placed in the same way
+            
 
             MazeGenerator generator(numCells);
@@ -81 +102 @@
             }
 
+
+            //Ground
+            for(int i = 0; i<numCells; i++){
+                for(int j = 0; j<numCells; j++){
+                    StaticEntity* groundCell = new StaticEntity(origin_->getContext());
+
+                    groundCell->addTemplate(origin_->getGroundTemplate());
+                    groundCell->setPosition(get3dCoordinates(i,j,-60));
+                }
+
+            }
+
+
+
             //Generate inner Walls according to levelcode
             for(int y=0; y<numCells; y++){
                 for(int x=0; x<numCells; x++){
-                    switch(levelcode[ y * numCells + x ]){
+                    switch(levelcode[ y * numCells + x ])
+                    {
                         case 1: (new HoverWall(origin_->getContext()))->init(x+1, numCells-y, cellSize, cellHeight, 1);
-                                break;
+                            break;
                         case 3: (new HoverWall(origin_->getContext()))->init(x+1, numCells-y, cellSize, cellHeight, 1);
                         case 2: (new HoverWall(origin_->getContext()))->init(x+1, numCells-y, cellSize, cellHeight, 0);
-                        default: break;
+                        default:
+                            break;
                     }
-                }   
-            }
-
-            //Generate 5 flags randomly
-            for ( int i = 0; i < 5; i++ )
-            {
-                HoverFlag* flag = new HoverFlag(origin_->getContext());
-                flag->init(rand()%numCells, rand()%numCells, cellSize);
-                flags_.push_back(flag);
-            }
-
-        }//firsttick end
+                }
+            }
+
+            createFlags();
+
+            //Generate 3 PickupSpawners randomly (destroy hover pickup)
+            for (int i = 0; i<3; i++)
+            {
+                PickupSpawner* pickupSpawner = new PickupSpawner(origin_->getContext());
+
+                pickupSpawner->setPosition(get3dCoordinates(rand()%numCells, rand()%numCells, 0.0f));
+                pickupSpawner->setPickupTemplateName(origin_->getPickupTemplate());
+                pickupSpawner->setMaxSpawnedItems(3);
+                pickupSpawner->setRespawnTime(30);
+                pickupSpawner->setTriggerDistance(40);
+                // Add pickup spawner to the pickup spawner list
+                pickupSpawners_.push_back(pickupSpawner);
+            }
+            
+            //Generate 3 PickupSpawners randomly (speed pickup)
+            for (int i = 0; i<3; i++)
+            {
+                PickupSpawner* pickupSpawner = new PickupSpawner(origin_->getContext());
+
+                pickupSpawner->setPosition(get3dCoordinates(rand()%numCells, rand()%numCells, 0.0f));
+                pickupSpawner->setPickupTemplateName(origin_->getPickupTemplateSpeed());
+                pickupSpawner->setMaxSpawnedItems(3);
+                pickupSpawner->setRespawnTime(30);
+                pickupSpawner->setTriggerDistance(40);
+                // Add pickup spawner to the pickup spawner list
+                pickupSpawners_.push_back(pickupSpawner);
+            }
+
+            //Generate 3 PickupSpawners randomly (shrink pickup)
+            for (int i = 0; i<3; i++)
+            {
+                PickupSpawner* pickupSpawner = new PickupSpawner(origin_->getContext());
+
+                pickupSpawner->setPosition(get3dCoordinates(rand()%numCells, rand()%numCells, 0.0f));
+                pickupSpawner->setPickupTemplateName(origin_->getPickupTemplateShrink());
+                pickupSpawner->setMaxSpawnedItems(3);
+                pickupSpawner->setRespawnTime(30);
+                pickupSpawner->setTriggerDistance(40);
+                // Add pickup spawner to the pickup spawner list
+                pickupSpawners_.push_back(pickupSpawner);
+            }
+
+            //*****************************************************************************
+
+            //Generate destroyable crates randomly on field
+
+            for (int i = 0; i<10; i++){
+
+                Pawn* crate = new Pawn(origin_->getContext());
+
+                crate->addTemplate(origin_->getObstacleTemplate());  
+                crate->setPosition(get3dCoordinates(rand()%numCells, rand()%numCells, 43.0f));
+
+
+            }    
+            
+
+
+
+             //If no lives are left, end game
+            if(lives <= 0)
+            {
+                GSLevel::startMainMenu();
+            }
+            
+        }
+    }
+
+
+    // generate new Flags
+    void Hover::createFlags()
+    {
+        //TODO
+        //Generate flags randomly using bool array
+
+        //Generate 5 flags randomly on field
+        for ( int i = 0; i < 5; i++ )
+        {
+            HoverFlag* flag = new HoverFlag(origin_->getContext());
+            flag->init(rand()%numCells, rand()%numCells, cellSize);
+            flags_.push_back(flag);
+
+            
+
+            if(flags_[i]->getPosition() == get3dCoordinates(0,0,-60))
+            {
+                flags_[i]->destroyLater();
+                flags_.erase(flags_.begin()+i);
+            }
+        }
+            
+    }
+
+    void Hover::tick(float dt)
+    {
+        SUPER(Hover, tick, dt);
+
 
         // Check if ship collided with one of the flags
-        for ( unsigned int i = 0; i < flags_.size(); i++ ){
-            if(flags_[i]->getCollided()){
+        for ( unsigned int i = 0; i < flags_.size(); i++ )
+        {
+            if(flags_[i]->getCollided())
+            {
                 flags_[i]->destroyLater();
                 flags_.erase (flags_.begin()+i);
-            }
+                totFlags++;
+                if(flags_.size()<=0){
+                    //ChatManager::message("Level Up!");
+                    
+                    levelUp();
+                }
+            }
+
         }
         numberOfFlags_ = flags_.size();
+
+        if(lives <= 0){
+                GSLevel::startMainMenu();
+            }
+    }
+
+    //start new level - call to create new flags
+    void Hover::levelUp()
+    {
+        level++;
+        //increment lives after every 4 levels
+        if(level%4 == 0)
+        {
+            lives++;
+        }
+        createFlags();
+        toggleShowLevel();
+        showLevelTimer.setTimer(2.0f, false, createExecutor(createFunctor(&Hover::toggleShowLevel, this)));
+
+        //spawn one additional crate randomly
+        Pawn* crate = new Pawn(origin_->getContext());
+        crate->addTemplate(origin_->getObstacleTemplate());  
+        crate->setPosition(get3dCoordinates(rand()%numCells, rand()%numCells, 43.0f));
+
+    }
+
+    Vector3 Hover::get3dCoordinates(int x, int y, float heightOffset)
+    {
+        return Vector3(x*cellSize*1.0f + cellSize/2, heightOffset, y*cellSize*1.0f + cellSize/2);
+    }
+
+    //if killed, subtract number of lives. If lives == 0, end game
+    void Hover::costLife()
+    {
+        lives--;
+        if (lives <= 0)
+            GSLevel::startMainMenu();
     }
 }

code/branches/presentationFS16/src/modules/hover/Hover.h

@@ -24 +24 @@
  *   Co-authors:
  *      Cyrill Burgener
+ *      Tomer Gidron
  *
  */
@@ -37 +38 @@
 
 #include "HoverPrereqs.h"
+#include "HoverShip.h"
 
 #include <vector>
@@ -42 +44 @@
 #include "gametypes/Gametype.h"
 #include "HoverOrigin.h"
+#include "pickup/PickupSpawner.h"
 
 namespace orxonox
@@ -55 +58 @@
                 { this->origin_ = origin; }
 
+            void start();
+            void createFlags();
+            void levelUp();
+            void endLevel();
+            void costLife();
+
             inline int getNumberOfFlags() const
                 { return this->numberOfFlags_; }
 
+            virtual Vector3 get3dCoordinates(int x, int y, float heightOffset);
+
+            inline int getTotFlags() const
+                { return this->totFlags; }
+
+            inline int getLives() const
+                { return this->lives; }
+
+            inline int getLevel() const
+                { return this->level; }
+
+            bool bLevelUpgradeHUD;
+
         private:
+
             WeakPtr<HoverOrigin> origin_;
             std::vector<HoverFlag*> flags_;
             int numberOfFlags_;
             bool firstTick_;
+            int level;
+            int lives;
+            int flagsTaken;
+
+            int cellSize;
+            int cellHeight;
+            int numCells;
+
+            int totFlags;
+
+            std::vector<PickupSpawner*> pickupSpawners_;
+
+            void toggleShowLevel(){bLevelUpgradeHUD = !bLevelUpgradeHUD;}
+
+            Timer showLevelTimer;
     };
 }

code/branches/presentationFS16/src/modules/hover/HoverFlag.cc

@@ -87 +87 @@
         model_ = new Model(this->getContext());
         model_->setMeshSource("ss_flag_eu.mesh");
-        model_->setScale3D(Vector3(5, 5, 5));
-        model_->setPosition(Vector3(xCoordinate*cellSize*1.0f + cellSize/2,10.0f,yCoordinate*cellSize*1.0f + cellSize/2));
+        model_->setScale3D(Vector3(30, 30, 30));
+        model_->setPosition(Vector3(xCoordinate*cellSize*1.0f + cellSize/2,50.0f,yCoordinate*cellSize*1.0f + cellSize/2));
 
         this->attach(model_);
 
         cs_ = new BoxCollisionShape(this->getContext());
-        cs_->setHalfExtents(Vector3(5, 5, 5));
+        cs_->setHalfExtents(Vector3(30, 30, 30));
         cs_->setPosition(Vector3(xCoordinate*cellSize*1.0f + cellSize/2,0.0f,yCoordinate*cellSize*1.0f + cellSize/2));
 

code/branches/presentationFS16/src/modules/hover/HoverOrigin.cc

@@ -23 +23 @@
  *      Manuel Meier
  *   Co-authors:
- *      ...
+ *      Tomer Gidron
  *
  */
@@ -45 +45 @@
         RegisterObject(HoverOrigin);
         checkGametype();
+
+        //Initialization of variables (not really needed)
+
+        pickupTemplate_ = "";
+        pickupRepresentationTemplate_ = "";
+
+        pickupTemplateSpeed_ = "";
+        pickupRepresentationTemplateSpeed_ = "";
+
+
+        pickupTemplateShrink_ = "";
+        pickupRepresentationTemplateShrink_ = "";
     }
 
@@ -54 +66 @@
         XMLPortParam(HoverOrigin, "cellSize", setCellSize, getCellSize, xmlelement, mode);
         XMLPortParam(HoverOrigin, "cellHeight", setCellHeight, getCellHeight, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "wallThickness", setWallThickness, getWallThickness, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuptemplate", setPickupTemplate, getPickupTemplate, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuprepresentationtemplate", setPickupRepresentationTemplate, getPickupRepresentationTemplate, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuptemplatespeed", setPickupTemplateSpeed, getPickupTemplateSpeed, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuprepresentationtemplatespeed", setPickupRepresentationTemplateSpeed, getPickupRepresentationTemplateSpeed, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "obstacletemplate", setObstacleTemplate, getObstacleTemplate, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuptemplateshrink", setPickupTemplateShrink, getPickupTemplateShrink, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "pickuprepresentationtemplateshrink", setPickupRepresentationTemplateShrink, getPickupRepresentationTemplateShrink, xmlelement, mode);
+        XMLPortParam(HoverOrigin, "groundtemplate", setGroundTemplate, getGroundTemplate, xmlelement, mode);
     }
+
 
     void HoverOrigin::checkGametype()

code/branches/presentationFS16/src/modules/hover/HoverOrigin.h

@@ -23 +23 @@
  *      Manuel Meier
  *   Co-authors:
- *      ...
+ *      Tomer Gidron
  *
  */
@@ -66 +66 @@
                 { return this->cellHeight_; }
 
+            inline void setWallTickness(int wallTickness)
+                { this->wallTickness_ = wallTickness; }
+            inline int getWallTickness() const
+                { return this->wallTickness_; }
+
+            //pickup template set and get for destroy hover pickup
+
+            inline void setPickupTemplate(std::string pickupTemplate)
+                { this->pickupTemplate_ = pickupTemplate; }
+            inline std::string getPickupTemplate() const
+                { return this->pickupTemplate_; }
+
+            inline void setPickupRepresentationTemplate(std::string pickupRepresenationaTemplate)
+                { this->pickupRepresentationTemplate_ = pickupRepresenationaTemplate; }
+            inline std::string getPickupRepresentationTemplate() const
+                { return this->pickupRepresentationTemplate_; }
+
+            //pickup template get and set for damage hover pickup
+
+            inline void setPickupTemplateSpeed(std::string pickupTemplateSpeed)
+                { this->pickupTemplateSpeed_ = pickupTemplateSpeed; }
+            inline std::string getPickupTemplateSpeed() const
+                { return this->pickupTemplateSpeed_; }
+
+            inline void setPickupRepresentationTemplateSpeed(std::string pickupRepresenationaTemplateSpeed)
+                { this->pickupRepresentationTemplateSpeed_ = pickupRepresenationaTemplateSpeed; }
+            inline std::string getPickupRepresentationTemplateSpeed() const
+                { return this->pickupRepresentationTemplateSpeed_; }
+
+
+            //pickup template get and set for shrink hover pickup
+
+            inline void setPickupTemplateShrink(std::string pickupTemplateShrink)
+                { this->pickupTemplateShrink_ = pickupTemplateShrink; }
+            inline std::string getPickupTemplateShrink() const
+                { return this->pickupTemplateShrink_; }
+
+            inline void setPickupRepresentationTemplateShrink(std::string pickupRepresenationaTemplateShrink)
+                { this->pickupRepresentationTemplateShrink_ = pickupRepresenationaTemplateShrink; }
+            inline std::string getPickupRepresentationTemplateShrink() const
+                { return this->pickupRepresentationTemplateShrink_; }
+
+            //get and set for obstacle template
+
+            inline void setObstacleTemplate(std::string obstacleTemplate)
+                { this->obstacleTemplate_ = obstacleTemplate; }
+            inline std::string getObstacleTemplate() const
+                { return this->obstacleTemplate_; }        
+
+            //get and set for ground template
+
+            inline void setGroundTemplate(std::string groundTemplate)
+                { this->groundTemplate_ = groundTemplate; }
+            inline std::string getGroundTemplate() const
+                { return this->groundTemplate_; }  
+
         private:
             void checkGametype();
+
        
             int numCells_;
             int cellSize_;
             int cellHeight_;
+            int wallThickness_;
+
+            // Tempaltes for the destroy hover pickup
+            std::string pickupTemplate_;
+            std::string pickupRepresentationTemplate_;
+
+            // Tempaltes for the damage hover pickup
+            std::string pickupTemplateSpeed_;
+            std::string pickupRepresentationTemplateSpeed_;
+
+            // Tempaltes for the shrink hover pickup
+            std::string pickupTemplateShrink_;
+            std::string pickupRepresentationTemplateShrink_;
+
+            //Template for crate obstacle
+            std::string obstacleTemplate_;
+
+            //Template for ground cell
+            std::string groundTemplate_;
     };
 }

code/branches/presentationFS16/src/modules/hover/HoverShip.cc

@@ -33 +33 @@
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "Hover.h"
+//#include "NewHumanController.h"
 
 #include <BulletCollision/NarrowPhaseCollision/btManifoldPoint.h>
@@ -112 +114 @@
         if (bBoost && this->isFloor_)
         {
+
             this->setVelocity(
                 this->getVelocity().x,
@@ -120 +123 @@
         }
     }
+
+    Hover* HoverShip::getGame()
+    {
+        if (game == nullptr)
+        {
+            for (Hover* hover : ObjectList<Hover>())
+                game = hover;
+        }
+        return game;
+    }
+
+    void HoverShip::death()
+    {
+        getGame()->costLife();
+        SpaceShip::death();
+    }
 }

code/branches/presentationFS16/src/modules/hover/HoverShip.h

@@ -34 +34 @@
 
 #include "HoverPrereqs.h"
+#include "Hover.h"
 
 #include "worldentities/pawns/SpaceShip.h"
@@ -69 +70 @@
             virtual void boost(bool bBoost) override;
 
+        protected:
+            virtual void death() override;
+
         private:
+            Hover* getGame();
+            WeakPtr<Hover> game;
             float jumpBoost_;
             bool isFloor_;

code/branches/presentationFS16/src/modules/invader/Invader.cc

@@ -71 +71 @@
         // spawn enemy every 3.5 seconds
         enemySpawnTimer.setTimer(3.5f, true, createExecutor(createFunctor(&Invader::spawnEnemy, this)));
-        comboTimer.setTimer(3.0f, true, createExecutor(createFunctor(&Invader::comboControll, this)));
+        comboTimer.setTimer(3.0f, false, createExecutor(createFunctor(&Invader::comboControll, this)));
         this->setHUDTemplate("InvaderHUD");
     }

code/branches/presentationFS16/src/modules/pickup/PickupSpawner.h

@@ -114 +114 @@
                 {return this->pickupTemplate_; }
 
+
+            void setPickupTemplateName(const std::string& name);
+            void setPickupTemplate(Template* temp);
+
+
+/**
+            @brief Set the distance in which to trigger.
+            @param value The new distance in which to trigger.
+            */
+            inline void setTriggerDistance(float value)
+                { this->triggerDistance_ = value; }
+            /**
+            @brief Set the time to respawn.
+            @param time New time after which this gets re-actived.
+            */
+            inline void setRespawnTime(float time)
+                { this->respawnTime_ = time; }
+
+            void setMaxSpawnedItems(int items); //!< Sets the maximum number of spawned items.
+
         private:
             void initialize(void);
@@ -131 +151 @@
                 { this->blocked_.insert(std::pair<PickupCarrier*, std::time_t>(carrier, std::time(0)+time)); }
 
-            /**
-            @brief Set the distance in which to trigger.
-            @param value The new distance in which to trigger.
-            */
-            inline void setTriggerDistance(float value)
-                { this->triggerDistance_ = value; }
-            /**
-            @brief Set the time to respawn.
-            @param time New time after which this gets re-actived.
-            */
-            inline void setRespawnTime(float time)
-                { this->respawnTime_ = time; }
+            
+            
 
-            void setMaxSpawnedItems(int items); //!< Sets the maximum number of spawned items.
-
-            void setPickupTemplateName(const std::string& name);
-            void setPickupTemplate(Template* temp);
 
             Pickupable* createPickup(void); //!< Creates a new Pickupable.

code/branches/presentationFS16/src/modules/weapons/weaponmodes/HsW01.cc

@@ -85 +85 @@
         XMLPortParam(HsW01, "projectileMesh", setMesh, getMesh, xmlelement, mode);
         XMLPortParam(HsW01, "sound", setSound, getSound, xmlelement, mode);
+        XMLPortParam(HsW01, "speed", setSpeed, getSpeed, xmlelement, mode);
     }
 

code/branches/presentationFS16/src/modules/weapons/weaponmodes/HsW01.h

@@ -112 +112 @@
             void muzzleflash();
 
+            /**
+            @brief Set the firing speed.
+            @param speed The speed of the shot
+            */
+
+            void setSpeed(const float speed)
+                { this->speed_ = speed; }
+
+            /**
+            @brief Get the firing speed.
+            @return Returns the speed of the shot
+            */
+
+            const float getSpeed() const
+                { return this->speed_; }
+
             std::string material_; //!< The material.
             std::string mesh_; //!< The mesh.