Changeset 10074 for code/branches/pickupsFS14/src/modules

Timestamp:

May 22, 2014, 3:05:46 PM (11 years ago)

Author:

fvultier

Message:

new items added. improved level generator.

Location:

code/branches/pickupsFS14/src/modules

Files:

• invader/InvaderWeapon.cc (modified) (1 diff)
• jump/CMakeLists.txt (modified) (2 diffs)
• jump/Jump.cc (modified) (22 diffs)
• jump/Jump.h (modified) (4 diffs)
• jump/JumpBoots.cc (added)
• jump/JumpBoots.h (added)
• jump/JumpCenterpoint.cc (modified) (4 diffs)
• jump/JumpCenterpoint.h (modified) (5 diffs)
• jump/JumpEnemy.cc (modified) (4 diffs)
• jump/JumpEnemy.h (modified) (1 diff)
• jump/JumpFigure.cc (modified) (12 diffs)
• jump/JumpFigure.h (modified) (2 diffs)
• jump/JumpItem.cc (modified) (6 diffs)
• jump/JumpItem.h (modified) (2 diffs)
• jump/JumpPlatform.cc (modified) (4 diffs)
• jump/JumpPlatform.h (modified) (2 diffs)
• jump/JumpPlatformDisappear.cc (modified) (1 diff)
• jump/JumpPlatformFake.cc (modified) (1 diff)
• jump/JumpPlatformHMove.cc (modified) (1 diff)
• jump/JumpPlatformStatic.cc (modified) (1 diff)
• jump/JumpPlatformTimer.cc (modified) (1 diff)
• jump/JumpPlatformVMove.cc (modified) (1 diff)
• jump/JumpPrereqs.h (modified) (1 diff)
• jump/JumpProjectile.cc (modified) (3 diffs)
• jump/JumpProjectile.h (modified) (1 diff)
• jump/JumpPropeller.cc (added)
• jump/JumpPropeller.h (added)
• jump/JumpRocket.cc (added)
• jump/JumpRocket.h (added)
• jump/JumpScore.cc (modified) (4 diffs)
• jump/JumpScore.h (modified) (1 diff)
• jump/JumpShield.cc (added)
• jump/JumpShield.h (added)
• jump/JumpSpring.cc (added)
• jump/JumpSpring.h (added)

code/branches/pickupsFS14/src/modules/invader/InvaderWeapon.cc

@@ -57 +57 @@
     }
 
-    InvaderWeapon::~InvaderWeapon(){}
+    InvaderWeapon::~InvaderWeapon()
+    {
+
+    }
 
     void InvaderWeapon::shot()

code/branches/pickupsFS14/src/modules/jump/CMakeLists.txt

@@ -13 +13 @@
   JumpFigure.cc
   JumpItem.cc
+  JumpSpring.cc
+  JumpRocket.cc
+  JumpShield.cc
+  JumpPropeller.cc
+  JumpBoots.cc
   JumpCenterpoint.cc
   JumpScore.cc
@@ -24 +29 @@
     orxonox
     overlays
+    weapons
   SOURCE_FILES ${JUMP_SRC_FILES}
 )

code/branches/pickupsFS14/src/modules/jump/Jump.cc

@@ -53 +53 @@
 #include "JumpEnemy.h"
 #include "JumpFigure.h"
+#include "JumpItem.h"
+#include "JumpSpring.h"
+#include "JumpRocket.h"
+#include "JumpPropeller.h"
+#include "JumpBoots.h"
+#include "JumpShield.h"
 
 #include "infos/PlayerInfo.h"
@@ -72 +78 @@
         RegisterObject(Jump);
 
-        this->center_ = 0;
-        this->figure_ = 0;
-        this->camera = 0;
-        this->fakeAdded_ = false;
-
-        this->setHUDTemplate("JumpHUD");
-
-        // Pre-set the timer, but don't start it yet.
-        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Jump::startBall, this)));
-        this->starttimer_.stopTimer();
-
-        this->scoreLimit_ = 10;
-        this->setConfigValues();
+        center_ = 0;
+        figure_ = 0;
+        camera = 0;
+
+        setHUDTemplate("JumpHUD");
+
+        scoreLimit_ = 10;
+        setConfigValues();
     }
 
@@ -93 +94 @@
     Jump::~Jump()
     {
-        if (this->isInitialized())
+        if (isInitialized())
         {
-            this->cleanup();
+            cleanup();
         }
     }
@@ -102 +103 @@
     {
         SUPER(Jump, tick, dt);
-
         if (figure_ != NULL)
         {
@@ -108 +108 @@
                 Vector3 figureVelocity = figure_->getVelocity();
 
-                if (figurePosition.z > totalScreenShift)
+                float boundary = totalScreenShift+center_->getCameraOffset();
+
+                if (figurePosition.z > boundary)
                 {
-                        screenShiftSinceLastUpdate += figurePosition.z - totalScreenShift;
-                        totalScreenShift = figurePosition.z;
+                        screenShiftSinceLastUpdate += figurePosition.z - boundary;
+                        totalScreenShift = figurePosition.z - center_->getCameraOffset();
 
                 // Falls noetig neue Platformen im neuen Bereich einfuegen
@@ -117 +119 @@
                 {
                         screenShiftSinceLastUpdate -= center_->getSectionLength();
-                    addSection();
+                        if (sectionNumber_ > 2 && sectionNumber_%4 == 0 && rand()%2 == 0)
+                        {
+                                if (addAdventure(adventureNumber_) == false)
+                                                {
+                                        addSection();
+                                                }
+                                else
+                                {
+                                        ++ adventureNumber_;
+                                }
+                        }
+                        else
+                        {
+                                addSection();
+                        }
                 }
                 }
 
                 // Spiel verloren wegen Ansturz?
-                if (figurePosition.z < totalScreenShift - center_->getFieldDimension().y && figureVelocity.z < 0)
+                if (figurePosition.z < totalScreenShift - center_->getFieldDimension().y + platformHeight_ && figureVelocity.z < 0)
                 {
                         end();
@@ -128 +144 @@
 
                 // Schiessen
+
                 if (figure_->fireSignal)
                 {
                         figure_->fireSignal = false;
-                        addProjectile(figurePosition.x, figurePosition.z, 0.0, 150.0);
+                        addProjectile(figurePosition.x, figurePosition.z + figure_->getPropellerPos());
                 }
 
 
-                if (this->camera != NULL)
+                if (camera != NULL)
                         {
                                 Vector3 cameraPosition = Vector3(0, totalScreenShift, 0);
@@ -248 +265 @@
                 }
 
-
-
+                // Gegner, die zu weit unten oder abgeschossen sind entfernen
+                ObjectList<JumpEnemy>::iterator beginEnemy = ObjectList<JumpEnemy>::begin();
+                ObjectList<JumpEnemy>::iterator endEnemy = ObjectList<JumpEnemy>::end();
+                ObjectList<JumpEnemy>::iterator itEnemy = beginEnemy;
+                Vector3 enemyPosition;
+
+                while (itEnemy != endEnemy)
+                {
+                        enemyPosition = itEnemy->getPosition();
+                        if (enemyPosition.z < totalScreenShift - center_->getFieldDimension().y || itEnemy->dead_ == true)
+                        {
+                                ObjectList<JumpEnemy>::iterator temp = itEnemy;
+                                ++ itEnemy;
+                                center_->detach(*temp);
+                                temp->destroy();
+                        }
+                        else
+                        {
+                                ++ itEnemy;
+                        }
+                }
+
+                // Items, die zu weit unten sind entfernen
+                ObjectList<JumpItem>::iterator beginItem = ObjectList<JumpItem>::begin();
+                ObjectList<JumpItem>::iterator endItem = ObjectList<JumpItem>::end();
+                ObjectList<JumpItem>::iterator itItem = beginItem;
+                Vector3 itemPosition;
+
+                while (itItem != endItem)
+                {
+                        itemPosition = itItem->getPosition();
+
+                        WorldEntity* parent = itItem->getParent();
+
+                        if (itItem->attachedToFigure_ == false && itemPosition.z < totalScreenShift - center_->getFieldDimension().y && parent == center_)
+                        {
+                                ObjectList<JumpItem>::iterator temp = itItem;
+                                ++ itItem;
+                                center_->detach(*temp);
+                                temp->destroy();
+                        }
+                        else
+                        {
+                                ++ itItem;
+                        }
+                }
     }
 
@@ -263 +324 @@
     void Jump::cleanup()
     {
-                if (this->figure_ != NULL)
+                if (figure_ != NULL)
                 {
                         //this->figure_->destroy();
                         //this->figure_ = 0;
                 }
-                this->camera = 0;
-    }
-
-    /**
-    @brief
-        Starts the Jump minigame.
-    */
+                camera = 0;
+    }
+
     void Jump::start()
     {
-        if (this->center_ != NULL) // There needs to be a JumpCenterpoint, i.e. the area the game takes place.
+        if (center_ != NULL) // There needs to be a JumpCenterpoint, i.e. the area the game takes place.
         {
-
-
-            // Attach the ball to the centerpoint and set the parameters as specified in the centerpoint, the ball is attached to.
-            /*this->center_->attach(this->ball_);
-            this->ball_->setPosition(0, 0, 0);
-            this->ball_->setFieldDimension(this->center_->getFieldDimension());
-
-            // Set the bats for the ball.
-            this->ball_->setFigure(this->figure_);
-            */
-
-            // If one of the bats is missing, create it. Apply the template for the bats as specified in the centerpoint.
-                        if (this->figure_ == NULL)
-                        {
-                                this->figure_ = new JumpFigure(this->center_->getContext());
-                                this->figure_->addTemplate(this->center_->getFigureTemplate());
-                        }
-
-            // Attach the bats to the centerpoint and set the parameters as specified in the centerpoint, the bats are attached to.
-            this->center_->attach(this->figure_);
-            this->figure_->setPosition(-this->center_->getFieldDimension().x / 2, 0, 0);
-            this->figure_->setFieldDimension(this->center_->getFieldDimension());
+                        if (figure_ == NULL)
+                        {
+                                figure_ = new JumpFigure(center_->getContext());
+                                figure_->addTemplate(center_->getFigureTemplate());
+                                figure_->InitializeAnimation(center_->getContext());
+                        }
+
+            center_->attach(figure_);
+            figure_->setPosition(0, 0, 0);
+            figure_->setFieldDimension(center_->getFieldDimension());
         }
         else // If no centerpoint was specified, an error is thrown and the level is exited.
@@ -309 +354 @@
         }
 
-        // Start the timer. After it has expired the ball is started.
-        this->starttimer_.startTimer();
-
         // Set variable to temporarily force the player to spawn.
-        bool temp = this->bForceSpawn_;
-        this->bForceSpawn_ = true;
+        bool temp = bForceSpawn_;
+        bForceSpawn_ = true;
 
         // Call start for the parent class.
@@ -320 +362 @@
 
         // Reset the variable.
-        this->bForceSpawn_ = temp;
-
-        if (this->figure_ != NULL)
+        bForceSpawn_ = temp;
+
+        if (figure_ != NULL)
         {
-                this->camera = this->figure_->getCamera();
+                camera = figure_->getCamera();
         }
 
         totalScreenShift = 0.0;
         screenShiftSinceLastUpdate = 0.0;
-        sectionNumber = 0;
+        sectionNumber_ = 0;
+        adventureNumber_ = 0;
 
         addStartSection();
@@ -347 +390 @@
         // Call end for the parent class.
         Deathmatch::end();
-    }
-
-    /**
-    @brief
-        Spawns players, and fills the rest up with bots.
-    */
-    void Jump::spawnPlayersIfRequested()
-    {
-
-        // first spawn human players to assign always the left bat to the player in singleplayer
-        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
-            if (it->first->isHumanPlayer() && (it->first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(it->first);
-        // now spawn bots
-        /*
-        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
-            if (!it->first->isHumanPlayer() && (it->first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(it->first);
-        */
     }
 
@@ -384 +408 @@
             this->players_[player].state_ = PlayerState::Alive;
         }
-        // If both bats are taken.
-        else
-        {
-            return;
-        }
-
     }
 
@@ -398 +416 @@
     void Jump::playerScored(PlayerInfo* player, int score)
     {
-        /*
-        Deathmatch::playerScored(player, score);
-        if (this->center_ != NULL) // If there is a centerpoint.
-        {
-            // Fire an event for the player that has scored, to be able to react to it in the level, e.g. by displaying fireworks.
-            if (player == this->getRightPlayer())
-                this->center_->fireEvent(FireEventName(JumpCenterpoint, right));
-            else if (player == this->getLeftPlayer())
-                this->center_->fireEvent(FireEventName(JumpCenterpoint, left));
-
-            // Also announce, that the player has scored.
-            if (player != NULL)
-                this->gtinfo_->sendAnnounceMessage(player->getName() + " scored");
-        }
-
-        // If there is a ball present, reset its position, velocity and acceleration.
-        if (this->ball_ != NULL)
-        {
-            this->ball_->setPosition(Vector3::ZERO);
-            this->ball_->setVelocity(Vector3::ZERO);
-            this->ball_->setAcceleration(Vector3::ZERO);
-            this->ball_->setSpeed(0);
-        }
-
-        // If there are bats reset them to the middle position.
-        if (this->figure_[0] != NULL && this->figure_[1] != NULL)
-        {
-            this->figure_[0]->setPosition(-this->center_->getFieldDimension().x / 2, 0, 0);
-            this->figure_[1]->setPosition( this->center_->getFieldDimension().x / 2, 0, 0);
-        }
-
-        // If a player gets enough points, he won the game -> end of game
-        PlayerInfo* winningPlayer = NULL;
-        if (this->getLeftPlayer() && this->getScore(this->getLeftPlayer()) >= scoreLimit_)
-            winningPlayer = this->getLeftPlayer();
-        else if (this->getRightPlayer() && this->getScore(this->getRightPlayer()) >= scoreLimit_)
-            winningPlayer = getLeftPlayerthis->getRightPlayer();
-
-        if (winningPlayer)
-        {
-             ChatManager::message(winningPlayer->getName() + " has won!");
-             this->end();
-        }
-
-        // Restart the timer to start the ball.
-        this->starttimer_.startTimer();
-
-        */
+
     }
 
@@ -481 +452 @@
                 newPlatform->addTemplate(platformTemplate);
                 newPlatform->setPosition(Vector3(xPosition, 0.0, zPosition));
-                newPlatform->setFieldDimension(center_->getFieldDimension());
                 newPlatform->setFigure(this->figure_);
                 center_->attach(newPlatform);
@@ -487 +457 @@
     }
 
-    void Jump::addPlatformStatic(float xPosition, float zPosition)
-    {
-                if (fakeAdded_ == false && rand()%5 == 0)
-                {
-                        addPlatformFake(xPosition, zPosition);
-                }
-                else
-                {
-                JumpPlatformStatic* newPlatform = new JumpPlatformStatic(center_->getContext());
-                        addPlatform(newPlatform, center_->getPlatformStaticTemplate(), xPosition, zPosition);
-                }
-    }
-
-    void Jump::addPlatformHMove(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float speed)
+    JumpPlatformStatic* Jump::addPlatformStatic(float xPosition, float zPosition)
+    {
+                JumpPlatformStatic* newPlatform = new JumpPlatformStatic(center_->getContext());
+                addPlatform(newPlatform, center_->getPlatformStaticTemplate(), xPosition, zPosition);
+
+                return newPlatform;
+    }
+
+    JumpPlatformHMove* Jump::addPlatformHMove(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float speed)
     {
         JumpPlatformHMove* newPlatform = new JumpPlatformHMove(center_->getContext());
                 newPlatform->setProperties(leftBoundary, rightBoundary, speed);
                 addPlatform(newPlatform, center_->getPlatformHMoveTemplate(), xPosition, zPosition);
-    }
-
-    void Jump::addPlatformVMove(float xPosition, float zPosition, float lowerBoundary, float upperBoundary, float speed)
+
+                return newPlatform;
+    }
+
+    JumpPlatformVMove* Jump::addPlatformVMove(float xPosition, float zPosition, float lowerBoundary, float upperBoundary, float speed)
     {
         JumpPlatformVMove* newPlatform = new JumpPlatformVMove(center_->getContext());
                 newPlatform->setProperties(lowerBoundary, upperBoundary, speed);
                 addPlatform(newPlatform, center_->getPlatformVMoveTemplate(), xPosition, zPosition);
-    }
-
-    void Jump::addPlatformDisappear(float xPosition, float zPosition)
+
+                return newPlatform;
+    }
+
+    JumpPlatformDisappear* Jump::addPlatformDisappear(float xPosition, float zPosition)
     {
                 JumpPlatformDisappear* newPlatform = new JumpPlatformDisappear(center_->getContext());
                 newPlatform->setProperties(true);
                 addPlatform(newPlatform, center_->getPlatformDisappearTemplate(), xPosition, zPosition);
-    }
-
-    void Jump::addPlatformTimer(float xPosition, float zPosition, float time, float variance)
+
+                return newPlatform;
+    }
+
+    JumpPlatformTimer* Jump::addPlatformTimer(float xPosition, float zPosition, float time, float variance)
     {
                 float additionalTime = (float)(rand()%100)/(100*variance) - variance/2;
@@ -528 +499 @@
                 newPlatform->setProperties(time + additionalTime);
                 addPlatform(newPlatform, center_->getPlatformTimerTemplate(), xPosition, zPosition);
-    }
-
-    void Jump::addPlatformFake(float xPosition, float zPosition)
-    {
-        fakeAdded_ = true;
-
+
+                return newPlatform;
+    }
+
+    JumpPlatformFake* Jump::addPlatformFake(float xPosition, float zPosition)
+    {
                 JumpPlatformFake* newPlatform = new JumpPlatformFake(center_->getContext());
                 addPlatform(newPlatform, center_->getPlatformFakeTemplate(), xPosition, zPosition);
                 newPlatform->setAngularVelocity(Vector3(0, 0, 2.0));
-    }
-
-
-    void Jump::addProjectile(float xPosition, float zPosition, float xVelocity, float zVelocity)
+
+                return newPlatform;
+    }
+
+
+    void Jump::addProjectile(float xPosition, float zPosition)
     {
         JumpProjectile* newProjectile = new JumpProjectile(center_->getContext());
@@ -547 +520 @@
                 newProjectile->addTemplate(center_->getProjectileTemplate());
                 newProjectile->setPosition(Vector3(xPosition, 0.0, zPosition));
-                newProjectile->setVelocity(Vector3(xVelocity, 0.0, zVelocity));
                 newProjectile->setFieldDimension(center_->getFieldDimension());
                 newProjectile->setFigure(this->figure_);
@@ -554 +526 @@
     }
 
-    void Jump::addEnemy1(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    void Jump::addSpring(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    {
+        JumpSpring* newSpring = new JumpSpring(center_->getContext());
+        if (newSpring != NULL && center_ != NULL)
+                {
+                newSpring->addTemplate(center_->getSpringTemplate());
+                newSpring->setPosition(Vector3(xPosition, 0.0, zPosition));
+                newSpring->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                newSpring->setFigure(figure_);
+                center_->attach(newSpring);
+                }
+    }
+
+    void Jump::addSpring(JumpPlatform* platform)
+    {
+        JumpSpring* newSpring = new JumpSpring(center_->getContext());
+        if (newSpring != NULL && center_ != NULL)
+                {
+                newSpring->addTemplate(center_->getSpringTemplate());
+                newSpring->setPosition(Vector3(0.0, 0.0, 0.0));
+                newSpring->setProperties(-10.0, 10.0, -10.0, 10.0, 0.0, 0.0);
+                newSpring->setFigure(figure_);
+                platform->attach(newSpring);
+                }
+    }
+
+    void Jump::addRocket(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    {
+        JumpRocket* newRocket = new JumpRocket(center_->getContext());
+        if (newRocket != NULL && center_ != NULL)
+                {
+                newRocket->addTemplate(center_->getRocketTemplate());
+                newRocket->setPosition(Vector3(xPosition, 0.0, zPosition));
+                newRocket->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                newRocket->setFigure(figure_);
+                center_->attach(newRocket);
+                }
+    }
+
+    void Jump::addRocket(JumpPlatform* platform)
+    {
+        JumpRocket* newRocket = new JumpRocket(center_->getContext());
+        if (newRocket != NULL && center_ != NULL)
+                {
+                newRocket->addTemplate(center_->getRocketTemplate());
+                newRocket->setPosition(Vector3(0.0, 0.0, 0.0));
+                newRocket->setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+                newRocket->setFigure(figure_);
+                platform->attach(newRocket);
+                }
+    }
+
+    void Jump::addPropeller(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    {
+        JumpPropeller* newPropeller = new JumpPropeller(center_->getContext());
+        if (newPropeller != NULL && center_ != NULL)
+                {
+                newPropeller->addTemplate(center_->getPropellerTemplate());
+                newPropeller->setPosition(Vector3(xPosition, 0.0, zPosition));
+                newPropeller->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                newPropeller->setFigure(figure_);
+                center_->attach(newPropeller);
+                }
+    }
+
+    void Jump::addPropeller(JumpPlatform* platform)
+    {
+        JumpPropeller* newPropeller = new JumpPropeller(center_->getContext());
+        if (newPropeller != NULL && center_ != NULL)
+                {
+                newPropeller->addTemplate(center_->getPropellerTemplate());
+                newPropeller->setPosition(Vector3(0.0, 0.0, 0.0));
+                newPropeller->setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+                newPropeller->setFigure(figure_);
+                platform->attach(newPropeller);
+                }
+    }
+
+    void Jump::addBoots(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    {
+        JumpBoots* newBoots = new JumpBoots(center_->getContext());
+        if (newBoots != NULL && center_ != NULL)
+                {
+                newBoots->addTemplate(center_->getBootsTemplate());
+                newBoots->setPosition(Vector3(xPosition, 0.0, zPosition));
+                newBoots->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                newBoots->setFigure(figure_);
+                center_->attach(newBoots);
+                }
+    }
+
+    void Jump::addBoots(JumpPlatform* platform)
+    {
+        JumpBoots* newBoots = new JumpBoots(center_->getContext());
+        if (newBoots != NULL && center_ != NULL)
+                {
+                newBoots->addTemplate(center_->getBootsTemplate());
+                newBoots->setPosition(Vector3(0.0, 0.0, 0.0));
+                newBoots->setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+                newBoots->setFigure(figure_);
+                platform->attach(newBoots);
+                }
+    }
+
+    void Jump::addShield(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
+    {
+        JumpShield* newShield = new JumpShield(center_->getContext());
+        if (newShield != NULL && center_ != NULL)
+                {
+                newShield->addTemplate(center_->getShieldTemplate());
+                newShield->setPosition(Vector3(xPosition, 0.0, zPosition));
+                newShield->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                newShield->setFigure(figure_);
+                center_->attach(newShield);
+                }
+    }
+
+    void Jump::addShield(JumpPlatform* platform)
+    {
+        JumpShield* newShield = new JumpShield(center_->getContext());
+        if (newShield != NULL && center_ != NULL)
+                {
+                newShield->addTemplate(center_->getShieldTemplate());
+                newShield->setPosition(Vector3(0.0, 0.0, 0.0));
+                newShield->setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+                newShield->setFigure(figure_);
+                platform->attach(newShield);
+                }
+    }
+
+    void Jump::addEnemy(int type, float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity)
     {
         JumpEnemy* newEnemy = new JumpEnemy(center_->getContext());
         if (newEnemy != NULL && center_ != NULL)
                 {
-                newEnemy->addTemplate(center_->getEnemy1Template());
+                switch (type)
+                {
+                case 1:
+                        newEnemy->addTemplate(center_->getEnemy1Template());
+                        break;
+                case 2:
+                        newEnemy->addTemplate(center_->getEnemy2Template());
+                        break;
+                case 3:
+                        newEnemy->addTemplate(center_->getEnemy3Template());
+                        break;
+                case 4:
+                        newEnemy->addTemplate(center_->getEnemy4Template());
+                        break;
+                default:
+                        return;
+                }
+
                 newEnemy->setPosition(Vector3(xPosition, 0.0, zPosition));
                 newEnemy->setProperties(leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
@@ -573 +692 @@
 
                 float sectionLength = center_->getSectionLength();
-                float platformLength = center_->getPlatformLength();
-
-                for (float xPosition = -center_->getFieldDimension().x; xPosition <= center_->getFieldDimension().x; xPosition += platformLength)
+
+                newPlatform = new JumpPlatformStatic(center_->getContext());
+                addPlatform(newPlatform, center_->getPlatformStaticTemplate(), 0.0, -0.05*sectionLength);
+
+                platformWidth_ = newPlatform->getWidth();
+                platformHeight_ = newPlatform->getHeight();
+
+                for (float xPosition = platformWidth_; xPosition <= center_->getFieldDimension().x; xPosition += platformWidth_)
                 {
                         newPlatform = new JumpPlatformStatic(center_->getContext());
                         addPlatform(newPlatform, center_->getPlatformStaticTemplate(), xPosition, -0.05*sectionLength);
+                        newPlatform = new JumpPlatformStatic(center_->getContext());
+                        addPlatform(newPlatform, center_->getPlatformStaticTemplate(), -xPosition, -0.05*sectionLength);
                 }
     }
@@ -586 +712 @@
         float fieldWidth = center_->getFieldDimension().x;
         float sectionLength = center_->getSectionLength();
-        float platformLength = center_->getPlatformLength();
-
-        float sectionBegin = sectionNumber * sectionLength;
-        float sectionEnd = (1.0 + sectionNumber) * sectionLength;
-
-                int randPos1 = rand()%10;
-                int randPos2 = rand()%10;
-                int randPos3 = rand()%10;
-                int randPos4 = rand()%10;
-
-                if (rand()%5 == 0)
-                {
-                        addEnemy1(randomXPosition(), sectionBegin + sectionLength/10, -fieldWidth, fieldWidth, sectionBegin + sectionLength/10, sectionBegin + sectionLength/10, 5.0, 0.0);
-                }
-
-        switch (rand()%12)
+        float sectionBegin = sectionNumber_ * sectionLength;
+        float sectionEnd = (1 + sectionNumber_) * sectionLength;
+
+        int numI = 6;
+        int numJ = 4;
+
+        enum PlatformType
+        {
+                PLATFORM_EMPTY, PLATFORM_STATIC, PLATFORM_HMOVE, PLATFORM_VMOVE, PLATFORM_DISAPPEAR, PLATFORM_TIMER, PLATFORM_FAKE
+        };
+
+        enum ItemType
+        {
+                ITEM_NOTHING, ITEM_SPRING, ITEM_PROPELLER, ITEM_ROCKET, ITEM_BOOTS, ITEM_SHIELD
+        };
+
+        struct PlatformMatrix
+        {
+                PlatformType type;
+            bool done;
+        } matrix[numI][numJ];
+
+
+                for (int i = 0; i < numI; ++i)
+                {
+                        for (int j = 0; j < numJ; ++j)
+                        {
+                                matrix[i][j].type = PLATFORM_EMPTY;
+                                matrix[i][j].done = false;
+                        }
+                }
+                PlatformType platformtype1;
+                PlatformType platformtype2;
+                ItemType itemType = ITEM_NOTHING;
+
+            if (rand()%2 == 0)
+            {
+                itemType = ITEM_SPRING;
+            }
+            else if (rand()%2 == 0 && sectionNumber_ > 3)
+                switch(rand()%4)
                 {
                 case 0:
-                        // Doppelt statisch
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                for (int j = 0; j < 2; ++j)
-                                {
-                                        addPlatformStatic(randomXPosition(2, j), sectionBegin + i*sectionLength/10);
-                                }
-                        }
+                        itemType = ITEM_PROPELLER;
                         break;
                 case 1:
-                        // Dreifach statisch
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                for (int j = 0; j < 3; ++j)
-                                {
-                                        addPlatformStatic(randomXPosition(3, j), sectionBegin + i*sectionLength/10);
-                                }
-                        }
+                        itemType = ITEM_ROCKET;
                         break;
                 case 2:
-                        // statisch mit 1 horizontal
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                if (i == randPos1)
-                                {
-                                        addPlatformHMove(randomXPosition(), sectionBegin + i*sectionLength/10, -fieldWidth, fieldWidth, 30.0);
-                                }
-                                else
-                                {
-                                        addPlatformStatic(randomXPosition(), sectionBegin + i*sectionLength/10);
-                                }
-                        }
+                        itemType = ITEM_BOOTS;
                         break;
                 case 3:
-                        // statisch mit 2 horizontal
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                if (i == randPos1 || i == randPos2)
+                        itemType = ITEM_SHIELD;
+                        break;
+                default:
+                        break;
+                }
+
+                switch((sectionNumber_ > 28) ? rand()%29 : rand()%(sectionNumber_+1))
+            {
+            case 0:
+                platformtype1 = PLATFORM_STATIC;
+                platformtype2 = PLATFORM_STATIC;
+                break;
+            case 1:
+                platformtype1 = PLATFORM_STATIC;
+                platformtype2 = PLATFORM_STATIC;
+                break;
+            case 2:
+              platformtype1 = PLATFORM_STATIC;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 3:
+              platformtype1 = PLATFORM_STATIC;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 4:
+              platformtype1 = PLATFORM_STATIC;
+              platformtype2 = PLATFORM_VMOVE;
+              break;
+            case 5:
+              platformtype1 = PLATFORM_STATIC;
+              platformtype2 = PLATFORM_TIMER;
+              break;
+            case 6:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_STATIC;
+              break;
+            case 7:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 8:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 9:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 10:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_VMOVE;
+              break;
+            case 11:
+              platformtype1 = PLATFORM_HMOVE;
+              platformtype2 = PLATFORM_TIMER;
+              break;
+            case 12:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_STATIC;
+              break;
+            case 13:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 14:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 15:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 16:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_VMOVE;
+              break;
+            case 17:
+              platformtype1 = PLATFORM_DISAPPEAR;
+              platformtype2 = PLATFORM_TIMER;
+              break;
+            case 18:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_STATIC;
+              break;
+            case 19:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 20:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 21:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_VMOVE;
+              break;
+            case 22:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_VMOVE;
+              break;
+            case 23:
+              platformtype1 = PLATFORM_VMOVE;
+              platformtype2 = PLATFORM_TIMER;
+              break;
+            case 24:
+              platformtype1 = PLATFORM_TIMER;
+              platformtype2 = PLATFORM_STATIC;
+              break;
+            case 25:
+              platformtype1 = PLATFORM_TIMER;
+              platformtype2 = PLATFORM_HMOVE;
+              break;
+            case 26:
+              platformtype1 = PLATFORM_TIMER;
+              platformtype2 = PLATFORM_DISAPPEAR;
+              break;
+            case 27:
+                platformtype1 = PLATFORM_TIMER;
+                platformtype2 = PLATFORM_VMOVE;
+                break;
+            case 28:
+                platformtype1 = PLATFORM_TIMER;
+                platformtype2 = PLATFORM_TIMER;
+                break;
+            default:
+                platformtype1 = PLATFORM_TIMER;
+                platformtype2 = PLATFORM_TIMER;
+                break;
+            }
+
+            // Fill Matrix with selected platform types
+            for (int i = 0; i < numI; ++ i)
+            {
+                          for (int j = 0; j < numJ; ++ j)
+                          {
+                                        if (rand()%(sectionNumber_+1) == 0)
+                                        {
+                                            matrix[i][j].type = platformtype1;
+                                        }
+                                        else
+                                        {
+                                                matrix[i][j].type = platformtype2;
+                                        }
+                                        matrix[i][j].done = false;
+                          }
+            }
+
+            // Delete some platforms or replace them with fake platforms
+            if (platformtype1 == platformtype2 && sectionNumber_ > 10)
+            {
+                int j = rand()%numJ;
+                        if (rand()%2 == 0)
+                        {
+                                for (int i = 0; i <= j; ++ i)
                                 {
-                                        addPlatformHMove(randomXPosition(), sectionBegin + i*sectionLength/10, -fieldWidth, fieldWidth, 30.0);
+                                    matrix[rand()%numI][rand()%numJ].type = PLATFORM_EMPTY;
                                 }
-                                else
+                        }
+                        else
+                        {
+                            for (int i = 0; i <= j; ++ i)
                                 {
-                                        addPlatformStatic(randomXPosition(), sectionBegin + i*sectionLength/10);
+                                      matrix[rand()%numI][rand()%numJ].type = PLATFORM_FAKE;
                                 }
                         }
+            }
+
+            std::vector<JumpPlatform*> platformList;
+
+            for (int i = 0; i < numI; ++ i)
+            {
+                for (int j = 0; j < numJ; ++ j)
+                {
+                    if (matrix[i][j].done == false)
+                    {
+                        float xPosition = 0.0;
+                        float zPosition = 0.0;
+                                float leftBoundary = 0.0;
+                                float rightBoundary = 0.0;
+                                float lowerBoundary = 0.0;
+                                float upperBoundary = 0.0;
+                                float xVelocity = 0.0;
+                                float zVelocity = 0.0;
+
+                        switch(matrix[i][j].type)
+                                    {
+                                    case PLATFORM_EMPTY:
+                                            matrix[i][j].done = true;
+                                            break;
+                                    case PLATFORM_STATIC:
+                                                xPosition = randomXPosition(numJ, j);
+                                                zPosition = sectionBegin + i*sectionLength/numI;
+                                                platformList.push_back(addPlatformStatic(xPosition, zPosition));
+                                                matrix[i][j].done = true;
+                                        break;
+                                    case PLATFORM_FAKE:
+                                                xPosition = randomXPosition(numJ, j);
+                                                zPosition = sectionBegin + i*sectionLength/numI;
+                                                platformList.push_back(addPlatformFake(xPosition, zPosition));
+                                            matrix[i][j].done = true;
+                                        break;
+                                    case PLATFORM_TIMER:
+                                                xPosition = randomXPosition(numJ, j);
+                                                zPosition = sectionBegin + i*sectionLength/numI;
+                                                platformList.push_back(addPlatformTimer(xPosition, zPosition, 10.0, 1.5));
+                                            matrix[i][j].done = true;
+                                        break;
+                                    case PLATFORM_DISAPPEAR:
+                                                xPosition = randomXPosition(numJ, j);
+                                                zPosition = sectionBegin + i*sectionLength/numI;
+                                                platformList.push_back(addPlatformDisappear(xPosition, zPosition));
+                                            matrix[i][j].done = true;
+                                        break;
+                                    case PLATFORM_HMOVE:
+                                        xVelocity = randomSpeed();
+                                            if (j <= numJ-3 && matrix[i][j+1].type == PLATFORM_HMOVE && matrix[i][j+2].type == PLATFORM_HMOVE && rand()%2 == 0)
+                                            {
+                                                leftBoundary = randomXPositionLeft(numJ, j);
+                                                rightBoundary = randomXPositionRight(numJ, j+2);
+                                                xPosition = randomPosition(leftBoundary, rightBoundary);
+                                                        zPosition = sectionBegin + i*sectionLength/numI;
+                                                        platformList.push_back(addPlatformHMove(xPosition, zPosition, leftBoundary, rightBoundary, xVelocity));
+                                                matrix[i][j].done = true;
+                                                matrix[i][j+1].done = true;
+                                                matrix[i][j+2].done = true;
+                                            }
+                                            else if (j <= numJ-2 && matrix[i][j+1].type == PLATFORM_HMOVE && rand()%2 == 0)
+                                            {
+                                                leftBoundary = randomXPositionLeft(numJ, j);
+                                                rightBoundary = randomXPositionRight(numJ, j+1);
+                                                xPosition = randomPosition(leftBoundary, rightBoundary);
+                                                        zPosition = sectionBegin + i*sectionLength/numI;
+                                                        platformList.push_back(addPlatformHMove(xPosition, zPosition, leftBoundary, rightBoundary, xVelocity));
+                                                matrix[i][j].done = true;
+                                                matrix[i][j+1].done = true;
+                                            }
+                                            else
+                                            {
+                                                leftBoundary = randomXPositionLeft(numJ, j);
+                                                rightBoundary = randomXPositionRight(numJ, j);
+                                                xPosition = randomPosition(leftBoundary, rightBoundary);
+                                                        zPosition = sectionBegin + i*sectionLength/numI;
+                                                        platformList.push_back(addPlatformHMove(xPosition, zPosition, leftBoundary, rightBoundary, xVelocity));
+                                                matrix[i][j].done = true;
+                                            }
+                                            break;
+                                    case PLATFORM_VMOVE:
+                                        zVelocity = randomSpeed();
+                                            if (i <= numI-3 && matrix[i+1][j].type == PLATFORM_VMOVE && matrix[i+2][j].type == PLATFORM_VMOVE && rand()%2 == 0)
+                                            {
+                                                lowerBoundary = randomZPositionLower(numI, i, sectionBegin, sectionEnd);
+                                                upperBoundary = randomZPositionUpper(numI, i+2, sectionBegin, sectionEnd);
+                                                zPosition = randomPosition(lowerBoundary, upperBoundary);
+                                                xPosition = randomXPosition(numJ, j);
+                                                platformList.push_back(addPlatformVMove(xPosition, zPosition, lowerBoundary, upperBoundary, zVelocity));
+                                                matrix[i][j].done = true;
+                                                matrix[i+1][j].done = true;
+                                                matrix[i+2][j].done = true;
+                                            }
+                                            else if (i <= numI-2 && matrix[i+1][j].type == PLATFORM_VMOVE && rand()%2 == 0)
+                                            {
+                                                lowerBoundary = randomZPositionLower(numI, i, sectionBegin, sectionEnd);
+                                                upperBoundary = randomZPositionUpper(numI, i+1, sectionBegin, sectionEnd);
+                                                zPosition = randomPosition(lowerBoundary, upperBoundary);
+                                                xPosition = randomXPosition(numJ, j);
+                                                platformList.push_back(addPlatformVMove(xPosition, zPosition, lowerBoundary, upperBoundary, zVelocity));
+                                                matrix[i][j].done = true;
+                                                matrix[i+1][j].done = true;
+                                            }
+                                            else
+                                            {
+                                                lowerBoundary = randomZPositionLower(numI, i, sectionBegin, sectionEnd);
+                                                upperBoundary = randomZPositionUpper(numI, i, sectionBegin, sectionEnd);
+                                                zPosition = randomPosition(lowerBoundary, upperBoundary);
+                                                xPosition = randomXPosition(numJ, j);
+                                                platformList.push_back(addPlatformVMove(xPosition, zPosition, lowerBoundary, upperBoundary, zVelocity));
+                                                matrix[i][j].done = true;
+                                            }
+                                            break;
+                                    default:
+                                        // ERROR
+                                        break;
+
+                        }
+
+                                        /*if (platformtype1 != PLATFORM_TIMER && platformtype2 != PLATFORM_TIMER)
+                                        {
+                                                switch (itemType)
+                                                {
+                                                case ITEM_SPRING:
+                                                        addSpring(xPosition, zPosition, leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                                                        itemType = ITEM_NOTHING;
+                                                        break;
+                                                case ITEM_ROCKET:
+                                                        addRocket(xPosition, zPosition, leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                                                        itemType = ITEM_NOTHING;
+                                                        break;
+                                                case ITEM_PROPELLER:
+                                                        addPropeller(xPosition, zPosition, leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                                                        itemType = ITEM_NOTHING;
+                                                        break;
+                                                case ITEM_BOOTS:
+                                                        addBoots(xPosition, zPosition, leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                                                        itemType = ITEM_NOTHING;
+                                                        break;
+                                                case ITEM_SHIELD:
+                                                        addShield(xPosition, zPosition, leftBoundary, rightBoundary, lowerBoundary, upperBoundary, xVelocity, zVelocity);
+                                                        itemType = ITEM_NOTHING;
+                                                        break;
+                                                default:
+                                                        // ERROR
+                                                        break;
+                                                }
+                                        }*/
+                    }
+                }
+            }
+
+            //Add items
+        int numNewPlatforms = platformList.size();
+
+        if (numNewPlatforms > 0)
+        {
+                JumpPlatform* itemPlatform = platformList[rand()%numNewPlatforms];
+
+                        switch (ITEM_BOOTS)
+                        {
+                        case ITEM_SPRING:
+                                addSpring(itemPlatform);
+                                break;
+                        case ITEM_ROCKET:
+                                addRocket(itemPlatform);
+                                break;
+                        case ITEM_PROPELLER:
+                                addPropeller(itemPlatform);
+                                break;
+                        case ITEM_BOOTS:
+                                addBoots(itemPlatform);
+                                break;
+                        case ITEM_SHIELD:
+                                addShield(itemPlatform);
+                                break;
+                        default:
+                                break;
+                        }
+        }
+
+        if (sectionNumber_ >= 5 && rand()%3 == 0)
+        {
+                //  BEWEGUNG Verbessern, Grenzen anpassen !!!!!!!! Auch Vertikale Bewegung zulassen
+
+
+            switch(rand()%4)
+                {
+            case 0:
+                addEnemy(1, randomXPosition(), randomPosition(sectionBegin, sectionBegin + sectionLength), -fieldWidth, fieldWidth, sectionBegin, sectionBegin + sectionLength, 5.0, 0.0);
+                break;
+            case 1:
+                addEnemy(2, randomXPosition(), randomPosition(sectionBegin, sectionBegin + sectionLength), -fieldWidth, fieldWidth, sectionBegin, sectionBegin + sectionLength, 5.0, 0.0);
+                break;
+            case 2:
+                addEnemy(3, randomXPosition(), randomPosition(sectionBegin, sectionBegin + sectionLength), -fieldWidth, fieldWidth, sectionBegin, sectionBegin + sectionLength, 5.0, 0.0);
+                break;
+            case 3:
+                addEnemy(4, randomXPosition(), randomPosition(sectionBegin, sectionBegin + sectionLength), -fieldWidth, fieldWidth, sectionBegin, sectionBegin + sectionLength, 5.0, 0.0);
+                break;
+                }
+        }
+                ++ sectionNumber_;
+    }
+
+    bool Jump::addAdventure(int number)
+    {
+        float fieldWidth = center_->getFieldDimension().x;
+        float sectionLength = center_->getSectionLength();
+        float sectionBegin = sectionNumber_ * sectionLength;
+        sectionLength *= 2;
+
+        switch(number)
+        {
+        case 0:
+                        {
+                                int numI = 10;
+                                for (int i = 0; i < numI; ++ i)
+                                {
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+i*sectionLength/numI);
+                                }
+                                break;
+                        }
+        case 1:
+                {
+                        int numI = 7;
+
+                        addPlatformStatic(0.0, sectionBegin);
+                        for (int i = 1; i < numI; ++ i)
+                        {
+                                addPlatformStatic((fieldWidth-platformWidth_/2)*i/numI, sectionBegin+i*sectionLength/numI);
+                                addPlatformStatic(-(fieldWidth-platformWidth_/2)*i/numI, sectionBegin+i*sectionLength/numI);
+                        }
                         break;
-                case 4:
-                        // statisch mit 3 horizontal
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                if (i == randPos1 || i == randPos2 || i == randPos3)
+                }
+        case 2:
+                        {
+                                int numI = 5;
+                                for (int i = 0; i < numI; ++ i)
                                 {
-                                        addPlatformHMove(randomXPosition(), sectionBegin + i*sectionLength/10, -fieldWidth, fieldWidth, 30.0);
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin);
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+sectionLength/5);
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+sectionLength*2/5);
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+sectionLength*3/5);
+                                        addPlatformStatic((2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+sectionLength*4/5);
+                                        addEnemy(4, (2*fieldWidth-platformWidth_)*i/numI-fieldWidth+platformWidth_/2, sectionBegin+sectionLength/2, -fieldWidth, fieldWidth, sectionBegin, sectionBegin + sectionLength, 0.0, 0.0);
                                 }
-                                else
-                                {
-                                        addPlatformStatic(randomXPosition(), sectionBegin + i*sectionLength/10);
-                                }
-                        }
-                        break;
-                case 5:
-                        // statisch mit 4 horizontal
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                if (i == randPos1 || i == randPos2 || i == randPos3 || i == randPos4)
-                                {
-                                        addPlatformHMove(randomXPosition(), sectionBegin + i*sectionLength/10, -fieldWidth, fieldWidth, 30.0);
-                                }
-                                else
-                                {
-                                        addPlatformStatic(randomXPosition(), sectionBegin + i*sectionLength/10);
-                                }
-                        }
-                        break;
-                        // Einfach horizontal
-                case 6:
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                addPlatformHMove(randomXPosition(), sectionBegin + i*sectionLength/10, -fieldWidth, fieldWidth, 30.0);
-                        }
-                        break;
-                        // Doppelt horizontal
-                case 7:
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                        float mediumPos = randomXPosition(3, 1);
-                                        addPlatformHMove(randomXPosition(3, 0), sectionBegin + i*sectionLength/10, -fieldWidth, mediumPos - platformLength/2, 30.0);
-                                        addPlatformHMove(randomXPosition(3, 2), sectionBegin + i*sectionLength/10, mediumPos+platformLength/2, fieldWidth, 30.0);
-                        }
-                        break;
-                        // Einfach vertikal
-                case 8:
-                        for (int i = 0; i < 7; ++i)
-                        {
-                                addPlatformVMove(-fieldWidth + i*fieldWidth*2/10, randomYPosition(sectionBegin, sectionEnd), sectionBegin, sectionEnd, 20.0);
-                        }
-                        break;
-                        // Doppelt vertikal
-                case 9:
-                        for (int i = 0; i < 14; ++i)
-                        {
-                                addPlatformVMove(-fieldWidth + i*fieldWidth*2/10, randomYPosition(sectionBegin, sectionEnd), sectionBegin, sectionEnd, 20.0);
-                        }
-                        break;
-                        // Doppelt verschwindend
-                case 10:
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                for (int j = 0; j < 2; ++j)
-                                {
-                                        addPlatformDisappear(randomXPosition(2, j), randomYPosition(sectionBegin, sectionEnd));
-                                }
-                        }
-                        break;
-                        // Doppelt Timer
-                case 11:
-                        for (int i = 0; i < 10; ++i)
-                        {
-                                for (int j = 0; j < 2; ++j)
-                                {
-                                        addPlatformTimer(randomXPosition(2, j), randomYPosition(sectionBegin, sectionEnd), 6.0, 1.5);
-                                }
-                        }
-                        break;
-                }
-                orxout() << "new section added with number "<< sectionNumber << endl;
-
-                fakeAdded_ = false;
-
-                ++ sectionNumber;
+                                break;
+                        }
+        default:
+                return false;
+        }
+        sectionNumber_ +=2;
+        return true;
     }
 
@@ -746 +1195 @@
     float Jump::randomXPosition(int totalColumns, int culomn)
     {
-        float fieldWidth = center_->getFieldDimension().x;
-
-        float width = 2*fieldWidth/totalColumns;
-        float leftBound = culomn*width-fieldWidth;
-        float platformLength = center_->getPlatformLength();
-
-        return (float)(rand()%(int)(width-platformLength)) + leftBound + platformLength/2;
-    }
-
-    float Jump::randomYPosition(float lowerBoundary, float upperBoundary)
-    {
+        float fieldWidth = center_->getFieldDimension().x; //Width of the half field
+
+        float halfWidth = fieldWidth/totalColumns; //Width of a half column
+        float leftBound = culomn*halfWidth*2-fieldWidth; //Left beginning of the column
+        float rightBound = leftBound + 2*halfWidth;
+
+        return randomPosition(leftBound+platformWidth_/2, rightBound-platformWidth_/2);
+    }
+
+    float Jump::randomXPositionLeft(int totalColumns, int culomn)
+    {
+        float fieldWidth = center_->getFieldDimension().x; //Width of the half field
+
+        float halfWidth = fieldWidth/totalColumns; //Width of a half column
+        float leftBound = culomn*halfWidth*2-fieldWidth; //LeftBeginning of the column
+        float rightBound = leftBound + 2*halfWidth/3;
+
+        return randomPosition(leftBound+platformWidth_/2, rightBound-platformWidth_/2);
+    }
+
+    float Jump::randomXPositionRight(int totalColumns, int culomn)
+    {
+        float fieldWidth = center_->getFieldDimension().x; //Width of the half field
+
+        float halfWidth = fieldWidth/totalColumns; //Width of a half column
+        float rightBound = (culomn+1)*halfWidth*2-fieldWidth;
+        float leftBound = rightBound - 2*halfWidth/3;
+        return randomPosition(leftBound+platformWidth_/2, rightBound-platformWidth_/2);
+    }
+
+    float Jump::randomZPosition(int totalRows, int row, float sectionBegin, float SectionEnd)
+    {
+        float fieldHeight = SectionEnd - sectionBegin; //Heigt of the half field
+        float halfHeight = fieldHeight/totalRows; //Height of a half row
+        float lowerBound = row*halfHeight*2+sectionBegin; //Lower beginning of the row
+        float upperBound = lowerBound + 2*halfHeight;
+
+        return randomPosition(lowerBound+platformHeight_/2, upperBound-platformHeight_/2);
+    }
+
+    float Jump::randomZPositionLower(int totalRows, int row, float sectionBegin, float SectionEnd)
+    {
+        float fieldHeight = SectionEnd - sectionBegin; //Heigt of the half field
+        float rowHeight = fieldHeight/totalRows; //Height of a row
+        float lowerBound = row*rowHeight+sectionBegin; //Lower beginning of the row
+        float upperBound = lowerBound + rowHeight/3;
+
+        return randomPosition(lowerBound+platformHeight_/2, upperBound-platformHeight_/2);
+    }
+
+    float Jump::randomZPositionUpper(int totalRows, int row, float sectionBegin, float SectionEnd)
+    {
+        float fieldHeight = SectionEnd - sectionBegin; //Heigt of the half field
+        float rowHeight = fieldHeight/totalRows; //Height of a row
+        float lowerBound = (row+1)*rowHeight+sectionBegin; //Upper end of the row
+        float upperBound = lowerBound - rowHeight/3;
+
+        return randomPosition(lowerBound+platformHeight_/2, upperBound-platformHeight_/2);
+    }
+
+    float Jump::randomPosition(float lowerBoundary, float upperBoundary)
+    {
+        if (lowerBoundary >= upperBoundary)
+        {
+                return (lowerBoundary + upperBoundary)/2;
+        }
+
         return (float)(rand()%(int)(100*(upperBoundary - lowerBoundary)))/100 + lowerBoundary;
     }
 
+    float Jump::randomSpeed()
+    {
+        float platformSpeed = center_->getPlatformSpeed();
+        return randomPosition(0.5*platformSpeed, 1.5*platformSpeed);
+    }
+
     int Jump::getScore(PlayerInfo* player) const
     {
-        return sectionNumber - 2;
-    }
-
+        return sectionNumber_ - 2;
+    }
+
+    bool Jump::getDead(PlayerInfo* player) const
+    {
+        return figure_->dead_;
+    }
 }

code/branches/pickupsFS14/src/modules/jump/Jump.h

@@ -81 +81 @@
 
             int getScore(PlayerInfo* player) const;
+            bool getDead(PlayerInfo* player) const;
 
             /**
@@ -87 +88 @@
             */
             void setCenterpoint(JumpCenterpoint* center)
-                { this->center_ = center; }
+                { center_ = center; }
             void setConfigValues(); //!< Makes scoreLimit configurable.
 
@@ -93 +94 @@
 
         protected:
-            virtual void spawnPlayersIfRequested(); //!< Spawns players, and fills the rest up with bots.
-
             void startBall(); //!< Starts the ball with some default speed.
             void cleanup(); //!< Cleans up the Gametype by destroying the ball and the bats.
@@ -100 +99 @@
             virtual void addPlatform(JumpPlatform* newPlatform, std::string platformTemplate, float xPosition, float zPosition);
 
-            virtual void addPlatformStatic(float xPosition, float zPosition);
-            virtual void addPlatformHMove(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float speed);
-            virtual void addPlatformVMove(float xPosition, float zPosition, float lowerBoundary, float upperBoundary, float speed);
-            virtual void addPlatformDisappear(float xPosition, float zPosition);
-            virtual void addPlatformTimer(float xPosition, float zPosition, float time, float variance);
-            virtual void addPlatformFake(float xPosition, float zPosition);
-            virtual void addProjectile(float xPosition, float zPosition, float xVelocity, float zVelocity);
-            virtual void addEnemy1(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual JumpPlatformStatic* addPlatformStatic(float xPosition, float zPosition);
+            virtual JumpPlatformHMove* addPlatformHMove(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float speed);
+            virtual JumpPlatformVMove* addPlatformVMove(float xPosition, float zPosition, float lowerBoundary, float upperBoundary, float speed);
+            virtual JumpPlatformDisappear* addPlatformDisappear(float xPosition, float zPosition);
+            virtual JumpPlatformTimer* addPlatformTimer(float xPosition, float zPosition, float time, float variance);
+            virtual JumpPlatformFake* addPlatformFake(float xPosition, float zPosition);
+            virtual void addProjectile(float xPosition, float zPosition);
+            virtual void addEnemy(int type, float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addSpring(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addSpring(JumpPlatform* platform);
+            virtual void addRocket(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addRocket(JumpPlatform* platform);
+            virtual void addPropeller(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addPropeller(JumpPlatform* platform);
+            virtual void addBoots(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addBoots(JumpPlatform* platform);
+            virtual void addShield(float xPosition, float zPosition, float leftBoundary, float rightBoundary, float lowerBoundary, float upperBoundary, float xVelocity, float zVelocity);
+            virtual void addShield(JumpPlatform* platform);
 
             virtual void addStartSection();
             virtual void addSection();
+            virtual bool addAdventure(int number);
 
             virtual float randomXPosition();
             virtual float randomXPosition(int totalColumns, int culomn);
-            virtual float randomYPosition(float lowerBoundary, float upperBoundary);
+            virtual float randomXPositionLeft(int totalColumns, int culomn);
+            virtual float randomXPositionRight(int totalColumns, int culomn);
+            virtual float randomZPosition(int totalRows, int row, float sectionBegin, float SectionEnd);
+            virtual float randomZPositionLower(int totalRows, int row, float sectionBegin, float SectionEnd);
+            virtual float randomZPositionUpper(int totalRows, int row, float sectionBegin, float SectionEnd);
+
+            virtual float randomPosition(float lowerBoundary, float upperBoundary);
+            virtual float randomSpeed();
 
             WeakPtr<JumpCenterpoint> center_; //!< The playing field.
             WeakPtr<JumpFigure> figure_; //!< The two bats.
             WeakPtr<Camera> camera;
-            Timer starttimer_; //!< A timer to delay the start of the game.
             int scoreLimit_; //!< If a player scored that much points, the game is ended.
 
             float totalScreenShift;
             float screenShiftSinceLastUpdate;
-            int sectionNumber;
-
-            bool fakeAdded_;
+            int sectionNumber_;
+            int adventureNumber_;
+            float platformWidth_;
+            float platformHeight_;
     };
 }

code/branches/pickupsFS14/src/modules/jump/JumpCenterpoint.cc

@@ -55 +55 @@
         height_ = 120;
         sectionLength_ = 120;
+        platformSpeed_ = 20.0;
 
-        this->checkGametype();
+        checkGametype();
     }
 
@@ -69 +70 @@
         XMLPortParam(JumpCenterpoint, "dimension", setFieldDimension, getFieldDimension, xmlelement, mode);
         XMLPortParam(JumpCenterpoint, "sectionLength", setSectionLength, getSectionLength, xmlelement, mode);
-        XMLPortParam(JumpCenterpoint, "platformLength", setPlatformLength, getPlatformLength, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "platformSpeed", setPlatformSpeed, getPlatformSpeed, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "cameraOffset", setCameraOffset, getCameraOffset, xmlelement, mode);
         XMLPortParam(JumpCenterpoint, "platformStaticTemplate", setPlatformStaticTemplate, getPlatformStaticTemplate, xmlelement, mode);
         XMLPortParam(JumpCenterpoint, "platformHMoveTemplate", setPlatformHMoveTemplate, getPlatformHMoveTemplate, xmlelement, mode);
@@ -78 +80 @@
         XMLPortParam(JumpCenterpoint, "figureTemplate", setFigureTemplate, getFigureTemplate, xmlelement, mode);
         XMLPortParam(JumpCenterpoint, "projectileTemplate", setProjectileTemplate, getProjectileTemplate, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "springTemplate", setSpringTemplate, getSpringTemplate, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "rocketTemplate", setRocketTemplate, getRocketTemplate, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "propellerTemplate", setPropellerTemplate, getPropellerTemplate, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "bootsTemplate", setBootsTemplate, getBootsTemplate, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "shieldTemplate", setShieldTemplate, getShieldTemplate, xmlelement, mode);
         XMLPortParam(JumpCenterpoint, "enemy1Template", setEnemy1Template, getEnemy1Template, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "enemy2Template", setEnemy2Template, getEnemy2Template, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "enemy3Template", setEnemy3Template, getEnemy3Template, xmlelement, mode);
+        XMLPortParam(JumpCenterpoint, "enemy4Template", setEnemy4Template, getEnemy4Template, xmlelement, mode);
     }
 
@@ -90 +100 @@
 
         // Check, whether it's still Jump.
-        this->checkGametype();
+        checkGametype();
     }
 

code/branches/pickupsFS14/src/modules/jump/JumpCenterpoint.h

@@ -99 +99 @@
         @endcode
         As can be seen, there are actually two templates. The first template is needed to set the camera for the @ref orxonox::JumpFigure "JumpFigure". The second template ist the actual template for the @ref orxonox::JumpFigure "JumpFigure", the template for the camera position is added and a @ref orxonox::Model "Model" for the @ref orxonox::JumpFigure "JumpFigure" is attached.
-        
+        propellerTemplate_
         Finally the JumpCenterpoint is created.
         @code
@@ -171 +171 @@
                 { return this->projectileTemplate_; }
 
+            void setSpringTemplate(const std::string& newTemplate)
+                { this->springTemplate_ = newTemplate; }
+
+            const std::string& getSpringTemplate() const
+                { return this->springTemplate_; }
+
+            void setRocketTemplate(const std::string& newTemplate)
+                { this->rocketTemplate_ = newTemplate; }
+
+            const std::string& getRocketTemplate() const
+                { return this->rocketTemplate_; }
+
+            void setPropellerTemplate(const std::string& newTemplate)
+                { this->propellerTemplate_ = newTemplate; }
+
+            const std::string& getPropellerTemplate() const
+                { return this->propellerTemplate_; }
+
+            void setBootsTemplate(const std::string& newTemplate)
+                { this->bootsTemplate_ = newTemplate; }
+
+            const std::string& getBootsTemplate() const
+                { return this->bootsTemplate_; }
+
+            void setShieldTemplate(const std::string& newTemplate)
+                { this->shieldTemplate_ = newTemplate; }
+
+            const std::string& getShieldTemplate() const
+                { return this->shieldTemplate_; }
+
             void setFigureTemplate(const std::string& newTemplate)
                 { this->figureTemplate_ = newTemplate; }
@@ -182 +212 @@
             const std::string& getEnemy1Template() const
                 { return this->enemy1Template_; }
+
+            void setEnemy2Template(const std::string& newTemplate)
+                { this->enemy2Template_ = newTemplate; }
+
+            const std::string& getEnemy2Template() const
+                { return this->enemy2Template_; }
+
+            void setEnemy3Template(const std::string& newTemplate)
+                { this->enemy3Template_ = newTemplate; }
+
+            const std::string& getEnemy3Template() const
+                { return this->enemy3Template_; }
+
+            void setEnemy4Template(const std::string& newTemplate)
+                { this->enemy4Template_ = newTemplate; }
+
+            const std::string& getEnemy4Template() const
+                { return this->enemy4Template_; }
 
 
@@ -210 +258 @@
                 { return sectionLength_; }
 
-            /**
-            @brief Set the dimensions of the playing field.
-            @param dimension A vector with the width of the playing field as first component and the height as second.
-            */
-            void setPlatformLength(const float platformLength)
-                { this->platformLength_ = platformLength; }
-            /**
-            @brief Get the dimensions of the playing field.
-            @return Returns a vector with the width of the playing field as first component and the height as second.
-            */
-            float getPlatformLength() const
-                { return platformLength_; }
+            void setPlatformSpeed(const float platformSpeed)
+                { this->platformSpeed_ = platformSpeed; }
+
+            float getPlatformSpeed() const
+                { return platformSpeed_; }
+
+            void setCameraOffset(const float cameraOffset)
+                { this->cameraOffset_ = cameraOffset; }
+
+            float getCameraOffset() const
+                { return cameraOffset_; }
+
 
         private:
@@ -233 +281 @@
             std::string platformFakeTemplate_; //!< The template for the ball.
             std::string projectileTemplate_; //!< The template for the ball.
+            std::string springTemplate_; //!< The template for the ball.
+            std::string rocketTemplate_; //!< The template for the ball.
+            std::string propellerTemplate_; //!< The template for the ball.
+            std::string bootsTemplate_; //!< The template for the ball.
+            std::string shieldTemplate_; //!< The template for the ball.
             std::string figureTemplate_; //!< The template for the bats.
             std::string enemy1Template_; //!< The template for the bats.
+            std::string enemy2Template_; //!< The template for the bats.
+            std::string enemy3Template_; //!< The template for the bats.
+            std::string enemy4Template_; //!< The template for the bats.
 
             float width_; //!< The height of the playing field.
             float height_; //!< The width of the playing field.
             float sectionLength_; //!< Height of one section
-            float platformLength_; // Avoids intersecting platforms
+            float platformSpeed_; //!< Height of one section
+            float cameraOffset_; //!< Height of one section
     };
 }

code/branches/pickupsFS14/src/modules/jump/JumpEnemy.cc

@@ -56 +56 @@
         RegisterObject(JumpEnemy);
 
-        this->figure_ = 0;
+        dead_ = false;
+        figure_ = 0;
+        width_ = 0.0;
+        height_ = 0.0;
+        setPosition(Vector3(0,0,0));
+        setVelocity(Vector3(0,0,0));
+        setAcceleration(Vector3(0,0,0));
         setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-        this->setPosition(Vector3(0,0,0));
-        this->setVelocity(Vector3(0,0,0));
-        this->setAcceleration(Vector3(0,0,0));
     }
 
@@ -82 +85 @@
     {
         SUPER(JumpEnemy, XMLPort, xmlelement, mode);
+
+        XMLPortParam(JumpEnemy, "height", setHeight, getHeight, xmlelement, mode);
+        XMLPortParam(JumpEnemy, "width", setWidth, getWidth, xmlelement, mode);
     }
 
@@ -116 +122 @@
 
 
+        // Interact with Figure
+        Vector3 enemyPosition = getPosition();
+
+        if (figure_ != NULL)
+        {
+            Vector3 figurePosition = figure_->getPosition();
+            if(figurePosition.x > enemyPosition.x-width_ && figurePosition.x < enemyPosition.x+width_ && figurePosition.z > enemyPosition.z-height_ && figurePosition.z < enemyPosition.z+height_)
+            {
+                touchFigure();
+            }
+        }
     }
 
@@ -141 +158 @@
     void JumpEnemy::touchFigure()
     {
-
+        if (dead_ == false)
+        {
+                figure_->CollisionWithEnemy(this);
+        }
     }
 }

code/branches/pickupsFS14/src/modules/jump/JumpEnemy.h

@@ -87 +87 @@
                 { return Vector2(this->fieldWidth_, this->fieldHeight_); }
 
+            void setWidth(const float width)
+                { this->width_ = width; }
+            float getWidth() const
+                { return width_; }
+            void setHeight(const float height)
+                { this->height_ = height; }
+            float getHeight() const
+                { return height_; }
+
             virtual void setProperties(float newLeftBoundary, float newRightBoundary, float newLowerBoundary, float newUpperBoundary, float newHSpeed, float newVSpeed);
 
             void setFigure(WeakPtr<JumpFigure> bats); //!< Set the bats for the ball.
+            virtual void touchFigure();
+            bool dead_;
+        protected:
 
-            virtual void touchFigure();
+            float width_;
+            float height_;
 
-        protected:
             float fieldWidth_; //!< The width of the playing field.
             float fieldHeight_; //!< The height of the playing field.

code/branches/pickupsFS14/src/modules/jump/JumpFigure.cc

@@ -49 +49 @@
         RegisterObject(JumpFigure);
 
-        this->movement_ = 0;
-        this->bMoveLocal_ = false;
-        this->length_ = 0.25;
-        this->fieldWidth_ = 180;
-        this->bSteadiedPosition_ = false;
+        leftHand_ = NULL;
+        rightHand_ = NULL;
+
+        fieldHeight_ = 0;
+        fieldWidth_ = 0;
+
+        jumpSpeed_ = 0.0;
+        handSpeed_ = 0.0;
+        handMaxAngle_ = 0.0;
+        handMinAngle_ = 0.0;
+        rocketPos_ = 0.0;
+        propellerPos_ = 0.0;
+        bootsPos_ = 0.0;
 
         moveUpPressed = false;
@@ -66 +74 @@
         mouseFactor_ = 75.0;
         maxFireRate = 0.3;
+
+        handAngle_ = 0.0;
+        animateHands_ = false;
+        turnUp_ = false;
+
+        rocketActive_ = false;
+        propellerActive_ = false;
+        bootsActive_ = false;
+        shieldActive_ = false;
+        rocketSpeed_ = 0.0;
+        propellerSpeed_ = 0.0;
+
+        dead_ = false;
     }
 
@@ -76 +97 @@
         SUPER(JumpFigure, XMLPort, xmlelement, mode);
         XMLPortParam(JumpFigure, "mouseFactor", setMouseFactor, getMouseFactor, xmlelement, mode);
+        XMLPortParam(JumpFigure, "modelLefthand", setModelLeftHand, getModelLeftHand, xmlelement, mode);
+        XMLPortParam(JumpFigure, "modelRighthand", setModelRightHand, getModelRightHand, xmlelement, mode);
+        XMLPortParam(JumpFigure, "rocketPos", setRocketPos, getRocketPos, xmlelement, mode);
+        XMLPortParam(JumpFigure, "propellerPos", setPropellerPos, getPropellerPos, xmlelement, mode);
+        XMLPortParam(JumpFigure, "bootsPos", setBootsPos, getBootsPos, xmlelement, mode);
+        XMLPortParam(JumpFigure, "jumpSpeed", setJumpSpeed, getJumpSpeed, xmlelement, mode);
+        XMLPortParam(JumpFigure, "rocketSpeed", setRocketSpeed, getRocketSpeed, xmlelement, mode);
+        XMLPortParam(JumpFigure, "propellerSpeed", setPropellerSpeed, getPropellerSpeed, xmlelement, mode);
+        XMLPortParam(JumpFigure, "handMinAngle", setHandMinAngle, getHandMinAngle, xmlelement, mode);
+        XMLPortParam(JumpFigure, "handMaxAngle", setHandMaxAngle, getHandMaxAngle, xmlelement, mode);
+        XMLPortParam(JumpFigure, "handSpeed", setHandSpeed, getHandSpeed, xmlelement, mode);
     }
 
@@ -90 +122 @@
 
         // If the bat is controlled (but not over the network).
-        if (this->hasLocalController())
+        if (hasLocalController())
         {
                 timeSinceLastFire += dt;
 
-            /*if (this->movement_ != 0)
-            {
-                // The absolute value of the movement is restricted to be lesser or equal than the speed of the bat.
-                this->movement_ = clamp(this->movement_, -1.0f, 1.0f) * this->speed_;
-
-                // If moveRightLeft() is used the movement is dependento on wehther it is the right or the left bat, so, it is i.e. dependent on the orientation of the bat.
-                if (this->bMoveLocal_)
-                    this->setVelocity(this->getOrientation() * Vector3(this->movement_, 0, 0));
-                else
-                    this->setVelocity(0, 0, this->movement_);
-
-                this->movement_ = 0;
-                this->bSteadiedPosition_ = false;
-            }
-            // If there is no movement but the position has not been steadied, the velocity is set to zero and the position is reaffirmed.
-            else if (!this->bSteadiedPosition_)
-            {
-                // To ensure network synchronicity
-                this->setVelocity(0, 0, 0);
-                this->setPosition(this->getPosition());
-                this->bSteadiedPosition_ = true;
-            }*/
-
-
+                // Move up/down
                 Vector3 velocity = getVelocity();
-
-                velocity.z -= gravityAcceleration;
-
-                /*if (moveLeftPressed == true)
-                {
-                        velocity.x = -accelerationFactor;
-                        moveLeftPressed = false;
-                }
-                if (moveRightPressed == true)
-                {
-                        velocity.x = accelerationFactor;
-                        moveRightPressed = false;
-                }*/
-
-                velocity.x = -mouseFactor_*horizontalSpeed;
-
+                if (rocketActive_ == true)
+                {
+                        velocity.z = rocketSpeed_;
+                }
+                else if (propellerActive_ == true)
+                {
+                        velocity.z = propellerSpeed_;
+                }
+                else
+                {
+                        velocity.z -= gravityAcceleration;
+                }
+
+                // Animate Hands
+                if (animateHands_ == true)
+                {
+                        if (turnUp_ == true)
+                        {
+                                handAngle_ += handSpeed_ * dt;
+                        }
+                        else
+                                {
+                                        handAngle_ -= handSpeed_ * dt;
+                                }
+                if (handAngle_ > handMaxAngle_)
+                {
+                        turnUp_ = false;
+                }
+                if (handAngle_ <= handMinAngle_)
+                {
+                        animateHands_ = false;
+                }
+
+                                if (leftHand_ != NULL)
+                                {
+                                        leftHand_->setOrientation(Vector3(0.0, 1.0, 0.0), Degree(-handAngle_));
+                                }
+                                if (rightHand_ != NULL)
+                                {
+                                        rightHand_->setOrientation(Vector3(0.0, 1.0, 0.0), Degree(handAngle_));
+                                }
+                }
+
+                // Move left/right
+                if (dead_ == false)
+                {
+                        velocity.x = -mouseFactor_*horizontalSpeed;
+                }
+                else
+                {
+                        velocity.x = 0.0;
+                }
+
+                // Cheats
                 if (moveUpPressed == true)
                 {
                         velocity.z = 200.0f;
                         moveUpPressed = false;
+                        dead_ = false;
                 }
                 if (moveDownPressed == true)
@@ -146 +194 @@
 
                 setVelocity(velocity);
+
 
                 if (firePressed && timeSinceLastFire >= maxFireRate)
@@ -156 +205 @@
         }
 
-        Vector3 position = this->getPosition();
-
+        // Move through the left and right screen boundaries
+        Vector3 position = getPosition();
         if (position.x < -fieldWidth_*1.1)
         {
@@ -166 +215 @@
                 position.x = -fieldWidth_*1.1;
         }
-
-        this->setPosition(position);
-
+        setPosition(position);
+
+        // Reset key variables
         moveUpPressed = false;
         moveDownPressed = false;
@@ -178 +227 @@
     void JumpFigure::JumpFromPlatform(JumpPlatform* platform)
     {
-        Vector3 velocity = getVelocity();
-        velocity.z = 200.0f;
-        setVelocity(velocity);
-    }
-
+        if (dead_ == false)
+        {
+                Vector3 velocity = getVelocity();
+                velocity.z = (bootsActive_ ? 1.2*jumpSpeed_ : jumpSpeed_);
+                setVelocity(velocity);
+
+                animateHands_ = true;
+                handAngle_ = 0.0;
+                turnUp_ = true;
+        }
+    }
+
+    void JumpFigure::JumpFromSpring(JumpSpring* spring)
+    {
+        if (dead_ == false)
+        {
+                Vector3 velocity = getVelocity();
+                velocity.z = 1.2*jumpSpeed_;
+                setVelocity(velocity);
+        }
+    }
+
+    void JumpFigure::CollisionWithEnemy(JumpEnemy* enemy)
+        {
+        if (rocketActive_ == false && propellerActive_ == false && shieldActive_ == false)
+                {
+                        dead_ = true;
+                }
+        }
+
+    bool JumpFigure::StartRocket(JumpRocket* rocket)
+    {
+        if (rocketActive_ == false && propellerActive_ == false && bootsActive_ == false)
+        {
+                attach(rocket);
+                rocket->setPosition(0.0, rocketPos_, 0.0);
+                rocket->setVelocity(0.0, 0.0, 0.0);
+                rocketActive_ = true;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    void JumpFigure::StopRocket(JumpRocket* rocket)
+    {
+                rocket->setPosition(0.0, 0.0, -1000.0);
+        rocket->setVelocity(0.0, 0.0, 0.0);
+        detach(rocket);
+                rocket->destroy();
+                rocketActive_ = false;
+    }
+
+    bool JumpFigure::StartPropeller(JumpPropeller* propeller)
+    {
+        if (rocketActive_ == false && propellerActive_ == false && bootsActive_ == false)
+        {
+                attach(propeller);
+                propeller->setPosition(0.0, 0.0, propellerPos_);
+                propeller->setVelocity(0.0, 0.0, 0.0);
+                propellerActive_ = true;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    void JumpFigure::StopPropeller(JumpPropeller* propeller)
+    {
+        propeller->setPosition(0.0, 0.0, -1000.0);
+        propeller->setVelocity(0.0, 0.0, 0.0);
+        detach(propeller);
+        propeller->destroy();
+        propellerActive_ = false;
+    }
+
+    bool JumpFigure::StartBoots(JumpBoots* boots)
+    {
+        if (rocketActive_ == false && propellerActive_ == false && bootsActive_ == false)
+        {
+                attach(boots);
+                boots->setPosition(0.0, 0.0, bootsPos_);
+                boots->setVelocity(0.0, 0.0, 0.0);
+                bootsActive_ = true;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    void JumpFigure::StopBoots(JumpBoots* boots)
+    {
+        boots->setPosition(0.0, 0.0, -1000.0);
+        boots->setVelocity(0.0, 0.0, 0.0);
+        detach(boots);
+        boots->destroy();
+        bootsActive_ = false;
+    }
+
+    bool JumpFigure::StartShield(JumpShield* shield)
+    {
+        if (shieldActive_ == false)
+        {
+                attach(shield);
+                shield->setPosition(0.0, 0.0, propellerPos_);
+                shield->setVelocity(0.0, 0.0, 0.0);
+                shieldActive_ = true;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    void JumpFigure::StopShield(JumpShield* shield)
+    {
+        shield->setPosition(0.0, 0.0, -1000.0);
+        shield->setVelocity(0.0, 0.0, 0.0);
+        detach(shield);
+        shield->destroy();
+        shieldActive_ = false;
+    }
+
+    void JumpFigure::InitializeAnimation(Context* context)
+    {
+        leftHand_ = new Model(context);
+        rightHand_ = new Model(context);
+
+        leftHand_->addTemplate(modelLeftHand_);
+        rightHand_->addTemplate(modelRightHand_);
+
+                attach(leftHand_);
+                attach(rightHand_);
+    }
 
     /**
-    @brief
+    @briefhandPosition_
         Overloaded the function to steer the bat up and down.
     @param value
@@ -216 +397 @@
         if (value.x > 0)
         {
-                //orxout() << "right pressed" << endl;
                 moveLeftPressed = false;
                 moveRightPressed = true;
@@ -222 +402 @@
         else
         {
-                //orxout() << "left pressed" << endl;
                 moveLeftPressed = true;
                 moveRightPressed = false;
         }
-        /*this->bMoveLocal_ = true;
-        this->movement_ = value.x;*/
     }
 
@@ -233 +410 @@
     {
         horizontalSpeed = value.x;
-
     }
 
@@ -248 +424 @@
     }
 
+    void JumpFigure::fire(unsigned int firemode)
+    {
+        //SUPER(JumpFigure, fire, firemode);
+    }
+
     void JumpFigure::fired(unsigned int firemode)
     {
-        orxout() << "fire pressed" << endl;
+        //SUPER(JumpFigure, fired, firemode);
         firePressed = true;
     }

code/branches/pickupsFS14/src/modules/jump/JumpFigure.h

@@ -71 +71 @@
             virtual void rotateRoll(const Vector2& value);
 
+            void fire(unsigned int firemode);
             virtual void fired(unsigned int firemode);
 
             virtual void JumpFromPlatform(JumpPlatform* platform);
-
-            /**
-            @brief Set the height of the playing field.
-            @param height The height of the playing field.
-            */
+            virtual void JumpFromSpring(JumpSpring* spring);
+            virtual void CollisionWithEnemy(JumpEnemy* enemy);
+            virtual bool StartRocket(JumpRocket* rocket);
+            virtual void StopRocket(JumpRocket* rocket);
+            virtual bool StartPropeller(JumpPropeller* propeller);
+            virtual void StopPropeller(JumpPropeller* propeller);
+            virtual bool StartBoots(JumpBoots* boots);
+            virtual void StopBoots(JumpBoots* boots);
+            virtual bool StartShield(JumpShield* shield);
+            virtual void StopShield(JumpShield* shield);
+
+            virtual void InitializeAnimation(Context* context);
+
             void setFieldDimension(float width, float height)
-                { this->fieldWidth_ = width; this->fieldHeight_ = height; }
+                { fieldWidth_ = width; fieldHeight_ = height; }
 
             void setFieldDimension(const Vector2& dimension)
-                { this->setFieldDimension(dimension.x, dimension.y); }
+                { setFieldDimension(dimension.x, dimension.y); }
+
+            Vector2 getFieldDimension() const
+                { return Vector2(fieldWidth_, fieldHeight_); }
 
             void setMouseFactor(const float mouseFactor)
-                { this->mouseFactor_ = mouseFactor; }
+                { mouseFactor_ = mouseFactor; }
 
             const float getMouseFactor() const
-                { return this->mouseFactor_; }
-
-            /**
-            @brief Get the height of the playing field.
-            @return Returns the height of the playing field.
-            */
-            Vector2 getFieldDimension() const
-                { return Vector2(this->fieldWidth_, this->fieldHeight_); }
-
-            /**
-            @brief Set the length of the bat.
-            @param length The length of the bat (in z-direction) as percentage of the height of the playing field.
-            */
-            void setLength(float length)
-                { this->length_ = length; }
-            /**
-            @brief Get the length of the bat.
-            @return Returns the length of the bat (in z-direction) as percentage of the height of the playing field.
-            */
-            float getLength() const
-                { return this->length_; }
+                { return mouseFactor_; }
+
+            void setModelLeftHand(const std::string& modelLeftHand)
+                { modelLeftHand_ = modelLeftHand; }
+
+            const std::string& getModelLeftHand() const
+                { return modelLeftHand_; }
+
+            void setModelRightHand(const std::string& modelRightHand)
+                { modelRightHand_ = modelRightHand; }
+
+            const std::string& getModelRightHand() const
+                { return modelRightHand_; }
+
+            void setRocketPos(const float rocketPos)
+                { rocketPos_ = rocketPos; }
+
+            const float getRocketPos() const
+                { return rocketPos_; }
+
+                        void setPropellerPos(const float propellerPos)
+                                { propellerPos_ = propellerPos; }
+
+                        const float getPropellerPos() const
+                                { return propellerPos_; }
+
+                        void setBootsPos(const float bootsPos)
+                                { bootsPos_ = bootsPos; }
+
+                        const float getBootsPos() const
+                                { return bootsPos_; }
+
+            void setJumpSpeed(const float jumpSpeed)
+                { jumpSpeed_ = jumpSpeed; }
+
+            const float getJumpSpeed() const
+                { return jumpSpeed_; }
+
+            void setRocketSpeed(const float rocketSpeed)
+                { rocketSpeed_ = rocketSpeed; }
+
+            const float getRocketSpeed() const
+                { return rocketSpeed_; }
+
+            void setPropellerSpeed(const float propellerSpeed)
+                { propellerSpeed_ = propellerSpeed; }
+
+            const float getPropellerSpeed() const
+                { return propellerSpeed_; }
+
+            void setHandMinAngle(const float handMinAngle)
+                { handMinAngle_ = handMinAngle; }
+
+            const float getHandMinAngle() const
+                { return handMinAngle_; }
+
+            void setHandMaxAngle(const float handMaxAngle)
+                { handMaxAngle_ = handMaxAngle; }
+
+            const float getHandMaxAngle() const
+                { return handMaxAngle_; }
+
+            void setHandSpeed(const float handSpeed)
+                { handSpeed_ = handSpeed; }
+
+            const float getHandSpeed() const
+                { return handSpeed_; }
 
             bool fireSignal;
+            bool dead_;
+
         private:
-            float movement_; //!< The amount (and direction), in z-direction, of movement of the bat.
-            bool bMoveLocal_; //!< Helper to know whether the movement is caused by moveFrontBack() or moveRightLeft().
-            float length_; //!< The length of the bat (in z-direction) as percentage of the height of the playing field.
-            float fieldWidth_; //!< The height of the playing field.
+            std::string modelLeftHand_;
+            std::string modelRightHand_;
+
+            Model* leftHand_;
+            Model* rightHand_;
+
+            float fieldWidth_;
             float fieldHeight_;
-            bool bSteadiedPosition_; //!< Helper boolean, to keep track of when to steady the position, to ensure network synchronicity.
             float timeSinceLastFire;
 
@@ -129 +191 @@
             float gravityAcceleration;
             float mouseFactor_;
+
+            float jumpSpeed_;
+            float handSpeed_;
+            float handMaxAngle_;
+            float handMinAngle_;
+            float rocketPos_;
+            float propellerPos_;
+            float bootsPos_;
             float maxFireRate;
 
             float horizontalSpeed;
+
+            float handAngle_;
+            bool animateHands_;
+            bool turnUp_;
+
+            bool rocketActive_;
+            bool propellerActive_;
+            bool bootsActive_;
+            bool shieldActive_;
+            float rocketSpeed_;
+            float propellerSpeed_;
     };
 }

code/branches/pickupsFS14/src/modules/jump/JumpItem.cc

@@ -56 +56 @@
         RegisterObject(JumpItem);
 
-        this->figure_ = 0;
-        setProperties(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-        this->setPosition(Vector3(0,0,0));
-        this->setVelocity(Vector3(0,0,0));
-        this->setAcceleration(Vector3(0,0,0));
+        attachedToFigure_ = false;
+
+        figure_ = 0;
+        height_ = 0.0;
+        width_ = 0.0;
+        setPosition(Vector3(0,0,0));
+        setVelocity(Vector3(0,0,0));
+        setAcceleration(Vector3(0,0,0));
     }
 
@@ -69 +72 @@
     JumpItem::~JumpItem()
     {
-        /*if (this->isInitialized())
-        {
-            if (this->bDeleteBats_)
-                delete this->figure_;
 
-            delete[] this->batID_;
-        }*/
     }
 
@@ -82 +79 @@
     {
         SUPER(JumpItem, XMLPort, xmlelement, mode);
+
+        XMLPortParam(JumpItem, "height", setHeight, getHeight, xmlelement, mode);
+        XMLPortParam(JumpItem, "width", setWidth, getWidth, xmlelement, mode);
     }
 
@@ -94 +94 @@
     {
         SUPER(JumpItem, tick, dt);
-
-        // Get the current position, velocity and acceleration of the enemy.
-        Vector3 position = getPosition();
+        // Get the current position, velocity and acceleration of the item.
+        Vector3 position = getWorldPosition();
         Vector3 velocity = getVelocity();
 
@@ -109 +108 @@
         }
 
-        // Set the position, velocity and acceleration of the enemy, if they have changed.
+        // Set the position, velocity and acceleration of the item, if they have changed.
         if (velocity != getVelocity())
+        {
             setVelocity(velocity);
-        if (position != getPosition())
-            setPosition(position);
-
-
+        }
     }
 
@@ -125 +122 @@
         upperBoundary_ = newUpperBoundary;
 
-        this->setVelocity(Vector3(newHSpeed,0,newVSpeed));
+        setVelocity(Vector3(newHSpeed,0,newVSpeed));
     }
 

code/branches/pickupsFS14/src/modules/jump/JumpItem.h

@@ -62 +62 @@
             JumpItem(Context* context);
             virtual ~JumpItem();
+            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void setProperties(float newLeftBoundary, float newRightBoundary, float newLowerBoundary, float newUpperBoundary, float newHSpeed, float newVSpeed);
+            virtual void setFigure(WeakPtr<JumpFigure> bats); //!< Set the bats for the ball.
+            virtual void touchFigure();
 
-            virtual void tick(float dt);
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-            /**
-            @brief Set the dimensions of the playing field.
-            @param width The width of the playing field.
-            @param height The height of the playing field.
-            */
             void setFieldDimension(float width, float height)
                 { this->fieldWidth_ = width; this->fieldHeight_ = height; }
-            /**
-            @brief Get the dimensions of the playing field.
-            @param dimension A vector with the width as the first and height as the second component.
-            */
             void setFieldDimension(const Vector2& dimension)
                 { this->setFieldDimension(dimension.x, dimension.y); }
-            /**
-            @brief Get the dimensions of the playing field.
-            @return Returns a vector with the width as the first and height as the second component.
-            */
             Vector2 getFieldDimension() const
                 { return Vector2(this->fieldWidth_, this->fieldHeight_); }
 
-            virtual void setProperties(float newLeftBoundary, float newRightBoundary, float newLowerBoundary, float newUpperBoundary, float newHSpeed, float newVSpeed);
+            void setWidth(const float width)
+                { this->width_ = width; }
+            float getWidth() const
+                { return width_; }
+            void setHeight(const float height)
+                { this->height_ = height; }
+            float getHeight() const
+                { return height_; }
 
-            void setFigure(WeakPtr<JumpFigure> bats); //!< Set the bats for the ball.
-
-            virtual void touchFigure();
+            bool attachedToFigure_;
 
         protected:
@@ -97 +90 @@
             float fieldHeight_; //!< The height of the playing field.
 
+            WeakPtr<JumpFigure> figure_; //!< An array with the two bats.
+            float height_;
+            float width_;
+
             float leftBoundary_;
             float rightBoundary_;
             float lowerBoundary_;
             float upperBoundary_;
-
-            WeakPtr<JumpFigure> figure_; //!< An array with the two bats.
     };
 }

code/branches/pickupsFS14/src/modules/jump/JumpPlatform.cc

@@ -58 +58 @@
         RegisterObject(JumpPlatform);
 
-        this->figure_ = 0;
+        figure_ = 0;
 
         //initialize sound
         if (GameMode::isMaster())
                  {
-                         this->defScoreSound_ = new WorldSound(this->getContext());
-                         this->defScoreSound_->setVolume(1.0f);
-                         this->defBatSound_ = new WorldSound(this->getContext());
-                         this->defBatSound_->setVolume(0.4f);
-                         this->defBoundarySound_ = new WorldSound(this->getContext());
-                         this->defBoundarySound_->setVolume(0.5f);
+                         defScoreSound_ = new WorldSound(this->getContext());
+                         defScoreSound_->setVolume(1.0f);
+                         defBatSound_ = new WorldSound(this->getContext());
+                         defBatSound_->setVolume(0.4f);
+                         defBoundarySound_ = new WorldSound(this->getContext());
+                         defBoundarySound_->setVolume(0.5f);
                  }
                  else
                  {
-                         this->defScoreSound_ = 0;
-                         this->defBatSound_ = 0;
-                         this->defBoundarySound_ = 0;
+                         defScoreSound_ = 0;
+                         defBatSound_ = 0;
+                         defBoundarySound_ = 0;
                  }
 
-        this->setPosition(Vector3(0,0,0));
-        this->setVelocity(Vector3(0,0,0));
-        this->setAcceleration(Vector3(0,0,0));
+        setPosition(Vector3(0,0,0));
+        setVelocity(Vector3(0,0,0));
+        setAcceleration(Vector3(0,0,0));
     }
 
@@ -88 +88 @@
     JumpPlatform::~JumpPlatform()
     {
-        /*if (this->isInitialized())
-        {
-            if (this->bDeleteBats_)
-                delete this->figure_;
 
-            delete[] this->batID_;
-        }*/
     }
 
@@ -101 +95 @@
     {
         SUPER(JumpPlatform, XMLPort, xmlelement, mode);
+
+        XMLPortParam(JumpPlatform, "height", setHeight, getHeight, xmlelement, mode);
+        XMLPortParam(JumpPlatform, "width", setWidth, getWidth, xmlelement, mode);
+
         XMLPortParam(JumpPlatform, "defScoreSound",  setDefScoreSound,  getDefScoreSound,  xmlelement, mode);
         XMLPortParam(JumpPlatform, "defBatSound",  setDefBatSound,  getDefBatSound,  xmlelement, mode);
@@ -124 +122 @@
             Vector3 figureVelocity = figure_->getVelocity();
 
-            if(figureVelocity.z < 0 && figurePosition.x > platformPosition.x-10 && figurePosition.x < platformPosition.x+10 && figurePosition.z > platformPosition.z-4 && figurePosition.z < platformPosition.z+4)
+            float tolerance = 3.0;
+
+            if(figureVelocity.z < 0 && figurePosition.x > platformPosition.x-width_/2 && figurePosition.x < platformPosition.x+width_/2 && figurePosition.z > platformPosition.z-height_/2*tolerance && figurePosition.z < platformPosition.z+height_/2)
             {
                 touchFigure();
             }
         }
-
-
-
-
-
-        /*
-        // If the ball has gone over the top or bottom boundary of the playing field (i.e. the ball has hit the top or bottom delimiters).
-        if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
-        {
-            defBoundarySound_->play(); //play boundary sound
-            // Its velocity in z-direction is inverted (i.e. it bounces off).
-            velocity.z = -velocity.z;
-            // And its position is set as to not overstep the boundary it has just crossed.
-            if (position.z > this->fieldHeight_ / 2)
-                position.z = this->fieldHeight_ / 2;
-            if (position.z < -this->fieldHeight_ / 2)
-                position.z = -this->fieldHeight_ / 2;
-
-            this->fireEvent();
-        }
-
-        // If the ball has crossed the left or right boundary of the playing field (i.e. a player has just scored, if the bat isn't there to parry).
-        if (position.x > this->fieldWidth_ / 2 || position.x < -this->fieldWidth_ / 2)
-        {
-            float distance = 0;
-
-            if (this->bat_ != NULL) // If there are bats.
-            {
-                // If the right boundary has been crossed.
-                if (position.x > this->fieldWidth_ / 2 && this->bat_[1] != NULL)
-                {
-                    // Calculate the distance (in z-direction) between the ball and the center of the bat, weighted by half of the effective length of the bat (with additional 10%)
-                    distance = (position.z - this->bat_[1]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
-                    if (fabs(distance) <= 1) // If the bat is there to parry.
-                    {
-                        defBatSound_->play(); //play bat sound
-                        // Set the ball to be exactly at the boundary.
-                        position.x = this->fieldWidth_ / 2;
-                        // Invert its velocity in x-direction (i.e. it bounces off).
-                        velocity.x = -velocity.x;
-                        // Adjust the velocity in the z-direction, depending on where the ball hit the bat.
-                        velocity.z = distance * distance * sgn(distance) * JumpPlatform::MAX_REL_Z_VELOCITY * this->speed_;
-                        acceleration = this->bat_[1]->getVelocity() * this->accelerationFactor_ * -1;
-
-                        this->fireEvent();
-                    }
-                    // If the left player scores.
-                    else if (GameMode::isMaster() && position.x > this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
-                    {
-                        defScoreSound_->play();//play score sound
-                        if (this->getGametype() && this->bat_[0])
-                        {
-                            this->getGametype()->playerScored(this->bat_[0]->getPlayer());
-                            return;
-                        }
-                    }
-                }
-                // If the left boundary has been crossed.
-                else if (position.x < -this->fieldWidth_ / 2 && this->bat_[0] != NULL)
-                {
-                    // Calculate the distance (in z-direction) between the ball and the center of the bat, weighted by half of the effective length of the bat (with additional 10%)
-                    distance = (position.z - this->figure_->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
-                    if (fabs(distance) <= 1) // If the bat is there to parry.
-                    {
-                        defBatSound_->play(); //play bat sound
-                        // Set the ball to be exactly at the boundary.
-                        position.x = -this->fieldWidth_ / 2;
-                        // Invert its velocity in x-direction (i.e. it bounces off).
-                        velocity.x = -velocity.x;
-                        // Adjust the velocity in the z-direction, depending on where the ball hit the bat.
-                        velocity.z = distance * distance * sgn(distance) * JumpPlatform::MAX_REL_Z_VELOCITY * this->speed_;
-                        acceleration = this->bat_[0]->getVelocity() * this->accelerationFactor_ * -1;
-
-                        this->fireEvent();
-                    }
-                    // If the right player scores.
-                    else if (GameMode::isMaster() && position.x < -this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
-                    {
-                        defScoreSound_->play();//play score sound
-                        if (this->getGametype() && this->bat_[1])
-                        {
-                            this->getGametype()->playerScored(this->bat_[1]->getPlayer());
-                            return;
-                        }
-                    }
-                }
-            }
-        }
-        */
     }
 
-    /**
-    @brief
-        Set the bats for the ball.
-    @param bats
-        An array (of size 2) of weak pointers, to be set as the new bats.
-    */
     void JumpPlatform::setFigure(WeakPtr<JumpFigure> newFigure)
     {
         figure_ = newFigure;
-    }
-
-    void JumpPlatform::accelerateFigure()
-    {
-        figure_->JumpFromPlatform(this);
     }
 

code/branches/pickupsFS14/src/modules/jump/JumpPlatform.h

@@ -62 +62 @@
             JumpPlatform(Context* context);
             virtual ~JumpPlatform();
-
             virtual void tick(float dt);
-
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-            /**
-            @brief Set the dimensions of the playing field.
-            @param width The width of the playing field.
-            @param height The height of the playing field.
-            */
-            void setFieldDimension(float width, float height)
-                { this->fieldWidth_ = width; this->fieldHeight_ = height; }
-            /**
-            @brief Get the dimensions of the playing field.
-            @param dimension A vector with the width as the first and height as the second component.
-            */
-            void setFieldDimension(const Vector2& dimension)
-                { this->setFieldDimension(dimension.x, dimension.y); }
-            /**
-            @brief Get the dimensions of the playing field.
-            @return Returns a vector with the width as the first and height as the second component.
-            */
-            Vector2 getFieldDimension() const
-                { return Vector2(this->fieldWidth_, this->fieldHeight_); }
-
-
             void setFigure(WeakPtr<JumpFigure> bats); //!< Set the bats for the ball.
-
-            virtual void accelerateFigure();
             virtual void touchFigure();
 
@@ -102 +76 @@
             const std::string& getDefBoundarySound();
 
+            void setWidth(const float width)
+                { this->width_ = width; }
+            float getWidth() const
+                { return width_; }
+            void setHeight(const float height)
+                { this->height_ = height; }
+            float getHeight() const
+                { return height_; }
+
         protected:
-            float fieldWidth_; //!< The width of the playing field.
-            float fieldHeight_; //!< The height of the playing field.
-            WeakPtr<JumpFigure> figure_; //!< An array with the two bats.
+            float width_;
+            float height_;
+            WeakPtr<JumpFigure> figure_;
             WorldSound* defScoreSound_;
             WorldSound* defBatSound_;

code/branches/pickupsFS14/src/modules/jump/JumpPlatformDisappear.cc

@@ -101 +101 @@
         if (isActive())
         {
-                accelerateFigure();
+                figure_->JumpFromPlatform(this);
                 active_ = false;
-                orxout() << "platform deactivated" << endl;
         }
     }

code/branches/pickupsFS14/src/modules/jump/JumpPlatformFake.cc

@@ -44 +44 @@
 #include "core/XMLPort.h"
 
-#include "graphics/Backlight.h"
-
 namespace orxonox
 {

code/branches/pickupsFS14/src/modules/jump/JumpPlatformHMove.cc

@@ -116 +116 @@
     void JumpPlatformHMove::touchFigure()
     {
-        accelerateFigure();
+        figure_->JumpFromPlatform(this);
     }
 }

code/branches/pickupsFS14/src/modules/jump/JumpPlatformStatic.cc

@@ -87 +87 @@
     void JumpPlatformStatic::touchFigure()
     {
-        accelerateFigure();
+        figure_->JumpFromPlatform(this);
     }
 }

code/branches/pickupsFS14/src/modules/jump/JumpPlatformTimer.cc

@@ -117 +117 @@
     void JumpPlatformTimer::touchFigure()
     {
-        accelerateFigure();
         if (isActive())
         {
-                accelerateFigure();
+                figure_->JumpFromPlatform(this);
         }
     }

code/branches/pickupsFS14/src/modules/jump/JumpPlatformVMove.cc

@@ -113 +113 @@
     void JumpPlatformVMove::touchFigure()
     {
-        accelerateFigure();
+        figure_->JumpFromPlatform(this);
     }
 }

code/branches/pickupsFS14/src/modules/jump/JumpPrereqs.h

@@ -79 +79 @@
     class JumpEnemy;
     class JumpItem;
+    class JumpSpring;
+    class JumpRocket;
+    class JumpPropeller;
+    class JumpBoots;
+    class JumpShield;
     class JumpFigure;
     class JumpCenterpoint;

code/branches/pickupsFS14/src/modules/jump/JumpProjectile.cc

@@ -56 +56 @@
         RegisterObject(JumpProjectile);
 
-        this->figure_ = 0;
+        figure_ = 0;
 
-        this->registerVariables();
+        registerVariables();
 
-        this->setPosition(Vector3(0,0,0));
-        this->setVelocity(Vector3(0,0,0));
-        this->setAcceleration(Vector3(0,0,0));
+        setPosition(Vector3(0,0,0));
+        setVelocity(Vector3(0,0,250.0));
+        setAcceleration(Vector3(0,0,0));
     }
 
@@ -108 +108 @@
         SUPER(JumpProjectile, tick, dt);
 
-        Vector3 platformPosition = this->getPosition();
+        Vector3 projectilePosition = getPosition();
 
-        if (figure_ != NULL)
-        {
-            Vector3 figurePosition = figure_->getPosition();
-            Vector3 figureVelocity = figure_->getVelocity();
+                for (ObjectList<JumpEnemy>::iterator it = ObjectList<JumpEnemy>::begin(); it != ObjectList<JumpEnemy>::end(); ++it)
+                {
+                        Vector3 enemyPosition = it->getPosition();
+                        float enemyWidth = it->getWidth();
+                        float enemyHeight = it->getHeight();
 
-            if(figureVelocity.z < 0 && figurePosition.x > platformPosition.x-10 && figurePosition.x < platformPosition.x+10 && figurePosition.z > platformPosition.z-4 && figurePosition.z < platformPosition.z+4)
-            {
-                touchFigure();
-            }
-        }
+                        if(projectilePosition.x > enemyPosition.x-enemyWidth && projectilePosition.x < enemyPosition.x+enemyWidth && projectilePosition.z > enemyPosition.z-enemyHeight && projectilePosition.z < enemyPosition.z+enemyHeight)
+                        {
+                                it->dead_ = true;
+                        }
+                }
     }
 
@@ -128 +129 @@
         An array (of size 2) of weak pointers, to be set as the new bats.
     */
-    void JumpProjectile::setFigure(WeakPtr<JumpFigure> newFigure)
+    void JumpProjectile::setFigure(WeakPtr<JumpFigure> figure)
     {
-        figure_ = newFigure;
-    }
-
-    void JumpProjectile::accelerateFigure()
-    {
-
-    }
-
-    void JumpProjectile::touchFigure()
-    {
-
+        figure_ = figure;
     }
 }

code/branches/pickupsFS14/src/modules/jump/JumpProjectile.h

@@ -67 +67 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            /**
-            @brief Set the dimensions of the playing field.
-            @param width The width of the playing field.
-            @param height The height of the playing field.
-            */
             void setFieldDimension(float width, float height)
                 { this->fieldWidth_ = width; this->fieldHeight_ = height; }
-            /**
-            @brief Get the dimensions of the playing field.
-            @param dimension A vector with the width as the first and height as the second component.
-            */
+
             void setFieldDimension(const Vector2& dimension)
                 { this->setFieldDimension(dimension.x, dimension.y); }
-            /**
-            @brief Get the dimensions of the playing field.
-            @return Returns a vector with the width as the first and height as the second component.
-            */
+
             Vector2 getFieldDimension() const
                 { return Vector2(this->fieldWidth_, this->fieldHeight_); }
 
 
-            void setFigure(WeakPtr<JumpFigure> bats); //!< Set the bats for the ball.
-
-            virtual void accelerateFigure();
-            virtual void touchFigure();
+            void setFigure(WeakPtr<JumpFigure> figure);
 
         protected:

code/branches/pickupsFS14/src/modules/jump/JumpScore.cc

@@ -55 +55 @@
         RegisterObject(JumpScore);
 
-        this->owner_ = NULL;
-
+        owner_ = NULL;
+        showScore_ = false;
+        showMessages_ = false;
     }
 
@@ -75 +76 @@
     {
         SUPER(JumpScore, XMLPort, xmlelement, mode);
+
+        XMLPortParam(JumpScore, "showScore", setShowScore, getShowScore, xmlelement, mode);
+        XMLPortParam(JumpScore, "showMessages", setShowMessages, getShowMessages, xmlelement, mode);
+        XMLPortParam(JumpScore, "gameOverText", setGameOverText, getGameOverText, xmlelement, mode);
     }
 
@@ -92 +97 @@
         if (this->owner_ != NULL)
         {
-                /*
-            if (!this->owner_->hasEnded())
-            {
-                // Get the two players.
-                player1_ = this->owner_->getPlayer();
-            }
-
-            std::string name1;
-
-            std::string score1("0");
-
-            // Save the name and score of each player as a string.
-            if (player1_ != NULL)
-            {
-                name1 = player1_->getName();
-                score1 = multi_cast<std::string>(this->owner_->getScore(player1_));
-            }
-
-            // Assemble the strings, depending on what should all be displayed.
-            std::string output1;
-            if (this->bShowLeftPlayer_)
-            {
-                if (this->bShowName_ && this->bShowScore_ && player1_ != NULL)
-                    output1 = name1 + " - " + score1;
-                else if (this->bShowScore_)
-                    output1 = score1;
-                else if (this->bShowName_)
-                    output1 = name1;
-            }
-
-            std::string output("JUMP");
-            if (this->bShowName_ || this->bShowScore_)
-            {
-                if (this->bShowLeftPlayer_ && this->bShowRightPlayer_)
-                    output = output1 + ':' + output2;
-                else if (this->bShowLeftPlayer_ || this->bShowRightPlayer_)
-                    output = output1 + output2;
-            }
-
-            this->setCaption(output);*/
-
-
-
-
             if (!owner_->hasEnded())
             {
@@ -142 +103 @@
                 if (player_ != NULL)
                 {
-                        int score = owner_->getScore(player_);
+                        if (showScore_ == true)
+                        {
+                        int score = owner_->getScore(player_);
 
-                        std::string str = multi_cast<std::string>(score);
-                        setCaption(str);
+                        std::string str = multi_cast<std::string>(score);
+                        setCaption(str);
+                        }
+                        else if (showMessages_ == true)
+                        {
+
+                        setCaption(owner_->getDead(player_) == true ? gameOverText_ : "");
+                        }
                 }
             }

code/branches/pickupsFS14/src/modules/jump/JumpScore.h

@@ -64 +64 @@
             virtual void changedOwner(); //!< Is called when the owner changes.
 
+            void setShowScore(const bool showScore)
+                { showScore_ = showScore; }
+
+            const bool getShowScore() const
+                { return showScore_; }
+
+            void setShowMessages(const bool showMessages)
+                { showMessages_ = showMessages; }
+
+            const bool getShowMessages() const
+                { return showMessages_; }
+
+            void setGameOverText(const std::string& gameOverText)
+                { this->gameOverText_ = gameOverText; }
+
+            const std::string& getGameOverText() const
+                { return this->gameOverText_; }
+
         private:
             Jump* owner_; //!< The Jump game that owns this JumpScore.
             WeakPtr<PlayerInfo> player_; //!< Store information about left player permanently.
             WorldSound* scoreSound_;
+            bool showScore_;
+            bool showMessages_;
+            std::string gameOverText_;
 
     };