Changeset 8891

Timestamp:

Oct 12, 2011, 7:50:43 PM (13 years ago)

Author:

jo

Message:

Ai and tutorial improvements merged back to the trunk. AI features: all weapons are used, the ai-firestrength is configurable, bots are able to collect pickups . I've set the tutorial level as default level.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• data/gui/scripts/QuestGUI.lua (modified) (4 diffs)
• data/levels/fightInOurBack.oxw (modified) (1 diff)
• data/levels/includes/weaponSettingsSpacecruiser.oxi (copied) (copied from code/branches/ai2/data/levels/includes/weaponSettingsSpacecruiser.oxi)
• data/levels/includes/weaponSettingsSwallow.oxi (modified) (1 diff)
• data/levels/includes/weaponSettingsTransporter.oxi (modified) (1 diff)
• data/levels/lastTeamStanding.oxw (modified) (1 diff)
• data/levels/lastTeamStandingII.oxw (modified) (1 diff)
• data/levels/missionOne.oxw (copied) (copied from code/branches/ai2/data/levels/missionOne.oxw)
• data/levels/planets.oxw (modified) (1 diff)
• data/levels/templates/spaceshipSpacecruiser.oxt (copied) (copied from code/branches/ai2/data/levels/templates/spaceshipSpacecruiser.oxt)
• src/modules/notifications/NotificationDispatcher.cc (modified) (6 diffs)
• src/modules/notifications/NotificationDispatcher.h (modified) (5 diffs)
• src/modules/overlays/hud/HUDNavigation.cc (modified) (7 diffs)
• src/modules/overlays/hud/HUDNavigation.h (modified) (2 diffs)
• src/modules/overlays/hud/HUDRadar.cc (modified) (5 diffs)
• src/modules/overlays/hud/HUDRadar.h (modified) (3 diffs)
• src/modules/pickup/PickupSpawner.cc (modified) (2 diffs)
• src/modules/questsystem/QuestItem.h (modified) (1 diff)
• src/modules/questsystem/QuestManager.cc (modified) (9 diffs)
• src/modules/weapons/projectiles/Rocket.cc (modified) (2 diffs)
• src/orxonox/LevelManager.cc (modified) (3 diffs)
• src/orxonox/controllers/AIController.cc (modified) (8 diffs)
• src/orxonox/controllers/ArtificialController.cc (modified) (9 diffs)
• src/orxonox/controllers/ArtificialController.h (modified) (5 diffs)
• src/orxonox/controllers/DroneController.cc (modified) (3 diffs)
• src/orxonox/controllers/DroneController.h (modified) (1 diff)
• src/orxonox/controllers/WaypointController.cc (modified) (4 diffs)
• src/orxonox/controllers/WaypointController.h (modified) (1 diff)
• src/orxonox/infos/PlayerInfo.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponSlot.h (modified) (1 diff)
• src/orxonox/worldentities/ControllableEntity.cc (modified) (4 diffs)
• src/orxonox/worldentities/ControllableEntity.h (modified) (5 diffs)
• src/orxonox/worldentities/pawns/Pawn.cc (modified) (2 diffs)
• src/orxonox/worldentities/pawns/Pawn.h (modified) (2 diffs)
• src/orxonox/worldentities/pawns/SpaceShip.cc (modified) (2 diffs)

code/trunk/data/gui/scripts/QuestGUI.lua

@@ -5 +5 @@
 P.questManager = nil -- The QuestManager.
 P.showActive = true -- Whether the active or finished quest list is displayed.
-P.currentQuest = nil -- The quest that is currently displayed.
 P.player = nil -- The player the quests are displayed for.
 P.quests = {}
@@ -29 +28 @@
 
     -- Load the list of quests to be displayed.
-    P.loadQuestsList(P.currentQuest)
+    P.loadQuestsList()
+    -- Pause the game - possible conflict for multiplayer quests
+    orxonox.execute("setPause 1")
+end
+
+function P.onQuit()
+    orxonox.execute("setPause 0")
 end
 
@@ -171 +176 @@
         window:setSize(CEGUI.UVector2(CEGUI.UDim(1, -P.borderSize-P.scrollbarWidth), CEGUI.UDim(0,offset+P.borderSize)))
     end
-
-    P.currentQuest = quest
 end
 
@@ -204 +207 @@
     end
     hints:setSize(CEGUI.UVector2(CEGUI.UDim(1, -P.scrollbarWidth-P.borderSize), CEGUI.UDim(0, 0)))
-
-    P.currentQuest = nil
 end
 

code/trunk/data/levels/fightInOurBack.oxw

@@ -2 +2 @@
   name = "Fight in our Back"
   description = "Our fleet is far ahead of us. We need to get rid of all the enemies in its back, because we do not want our enemies to attack from everywhere. So let us clear this Sector!"
-  tags = ""
+  tags = "singleplayer" 
 />
 

code/trunk/data/levels/includes/weaponSettingsSwallow.oxi

@@ -14 +14 @@
         </links>
         <Weapon>
-          <HsW01 mode=0 munitionpershot=0 delay=0 damage=2.5 material="Flares/point_lensflare" />
-          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=2.5 material="Flares/point_lensflare" muzzleoffset=" 0.5,0.6,1.7" />
+          <HsW01 mode=0 munitionpershot=0 delay=0 damage=3.14159 material="Flares/point_lensflare" />
+          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 0.5,0.6,1.7" />
+
           <LightningGun mode=1 muzzleoffset="0,0,0" damage=3.14159 shielddamage=20/>
         </Weapon>
         <Weapon>
-          <HsW01 mode=0 munitionpershot=0 delay=0  damage=2.5 material="Flares/point_lensflare" />
-          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=2.5 material="Flares/point_lensflare" muzzleoffset="-0.5,0.6,1.7" />
+          <HsW01 mode=0 munitionpershot=0 delay=0  damage=3.14159 material="Flares/point_lensflare" />
+          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-0.5,0.6,1.7" />
           <LightningGun mode=1 muzzleoffset="0,0,0" damage=3.14159 shielddamage=20/>
         </Weapon>

code/trunk/data/levels/includes/weaponSettingsTransporter.oxi

@@ -14 +14 @@
         </links>
         <Weapon>
-          <HsW01 mode=0 munitionpershot=0 delay=0.1   damage=3.14159 material="Flares/point_lensflare" muzzleoffset="0,0,0" />
-          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset="0.5,0.6,1.7" />
+          <HsW01 mode=0 munitionpershot=0 delay=0.1   damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 0.1, 1.6,-2" />
+          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-1.6, 1.3,-2" />
           <LightningGun mode=1 muzzleoffset="0,0,0"   damage=3.14159 shielddamage=20 />
         </Weapon>
         <Weapon>
-          <HsW01 mode=0 munitionpershot=0 delay=0.1   damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 0,0,0" />
-          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-0.5,0.6,1.7" />
+          <HsW01 mode=0 munitionpershot=0 delay=0.1   damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 0.1, 1.6,-2" />
+          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-1.6, 1.3,-2" />
           <LightningGun mode=1 muzzleoffset="0,0,0"   damage=3.14159 shielddamage=20 />
         </Weapon>

code/trunk/data/levels/lastTeamStanding.oxw

@@ -47 +47 @@
     </StaticEntity>
 
-    <PickupSpawner position="-160,65,10" triggerDistance="10" respawnTime="5" maxSpawnedItems="10"><!--EasterEgg-->
-      <pickup>
-        <InvisiblePickup template=mediuminvisiblepickup />
-      </pickup>
-    </PickupSpawner>
-    <PickupSpawner position="-160,60,17" triggerDistance="10" respawnTime="5" maxSpawnedItems="10"><!--EasterEgg-->
+    <PickupSpawner position="-160,60,17" triggerDistance="20" respawnTime="5" maxSpawnedItems="10"><!--EasterEgg-->
       <pickup>
         <InvisiblePickup template=hugeinvisiblepickup />

code/trunk/data/levels/lastTeamStandingII.oxw

@@ -17 +17 @@
  name         = "On the fly"
  description  = "testmap for gametype last team standing"
- gametype     =  "LastTeamStanding"
+ gametype     = "LastTeamStanding"
 >
   <templates>

code/trunk/data/levels/planets.oxw

@@ -80 +80 @@
       mass="5000000"
       pitch="0"
-      mesh="planets/ganymede.mesh"
+      mesh="planets/muunilinst.mesh"
       atmosphere="atmosphere1"
       rotationaxis="1,0,0"

code/trunk/src/modules/notifications/NotificationDispatcher.cc

@@ -50 +50 @@
     CreateUnloadableFactory(NotificationDispatcher);
 
+    registerMemberNetworkFunction(NotificationDispatcher, broadcastHelper);
     registerMemberNetworkFunction(NotificationDispatcher, dispatch);
 
@@ -61 +62 @@
 
         this->sender_ = NotificationListener::NONE;
+        this->bBroadcast_ = false;
         this->registerVariables();
     }
@@ -81 +83 @@
         SUPER(NotificationDispatcher, XMLPort, xmlelement, mode);
 
-        XMLPortParam(NotificationDispatcher, "sender", getSender, setSender, xmlelement, mode);
-        
-        XMLPortEventSink(NotificationDispatcher, BaseObject, "trigger", trigger, xmlelement, mode); //TODO: Change BaseObject to MultiTrigger as soon as MultiTrigger is the base of all triggers.
+        XMLPortParam(NotificationDispatcher, "sender", setSender, getSender, xmlelement, mode);
+        XMLPortParam(NotificationDispatcher, "broadcast", setBroadcasting, isBroadcasting, xmlelement, mode);
+
+        XMLPortEventSink(NotificationDispatcher, BaseObject, "trigger", trigger, xmlelement, mode);
     }
 
@@ -100 +103 @@
     {
         registerVariable(this->sender_, VariableDirection::ToClient);
+    }
+
+    /**
+    @brief
+        Broadcasts a specific Notification.
+    */
+    void NotificationDispatcher::broadcast(void)
+    {
+        // TODO: Needed?
+        const std::string message = this->createNotificationMessage();
+        NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::local);
+
+        // Broadcast
+        if(!GameMode::isStandalone())
+        {
+            callMemberNetworkFunction(NotificationDispatcher, broadcastHelper, this->getObjectID(), NETWORK_PEER_ID_BROADCAST);
+        }
+    }
+
+    /**
+    @brief
+        Helper function for broadcast.
+    */
+    void NotificationDispatcher::broadcastHelper(void)
+    {
+        this->dispatch(Host::getPlayerID());
     }
 
@@ -110 +139 @@
     void NotificationDispatcher::dispatch(unsigned int clientId)
     {
-        if(GameMode::isStandalone() || Host::getPlayerID() == clientId || this->getSyncMode() == 0x0)
+        // We don't call sendNotification() directly on the server, because if might be necessary that createNotificationMessage() is executed on the client as the message may be client-specific.
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId || this->getSyncMode() == ObjectDirection::None)
         {
             const std::string message = this->createNotificationMessage();
@@ -139 +169 @@
         orxout(verbose, context::notifications) << "NotificationDispatcher (&" << this << ") triggered." << endl;
 
+        // If the NotificationDispatcher is set to broadcast.
+        if(this->isBroadcasting())
+        {
+            this->broadcast();
+            return true;
+        }
+
         PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
         PlayerInfo* player = NULL;

code/trunk/src/modules/notifications/NotificationDispatcher.h

@@ -50 +50 @@
         A NotificationDispatcher is an entity that, upon being triggered, dispatches (or sends) a specified @ref orxonox::Notification "Notification".
 
-        There is one parameter to be set, the @b sender . The sender specifies the part of Orxonox the sent @ref orxonox::Notification "Notification" comes from. The default value is set by the classes implementing NotificationDispatcher.
+        There are two parameter to be set:
+        - The @b sender . The sender specifies the part of Orxonox the sent @ref orxonox::Notification "Notification" comes from. The default value is set by the classes implementing NotificationDispatcher.
+        - The @b broadcast . Specifies whether messages are broadcast (i.e. sent to all clients) or just sent to a specific player.
 
         Its standard usage is:
@@ -62 +64 @@
         </NotificationDispatcher>
         @endcode
-        But keep in mind, that NotificationDispatcher is an abstract class and in this example @ref orxonox::PlayerTrigger "PlayerTrigger" stands for any event that is caused by a @ref orxonox::PlayerTrigger "PlayerTrigger", so instead of @ref orxonox::PlayerTrigger "PlayerTrigger", there could be a @ref orxonox::DistanceTrigger "DistanceTrigger", or a @ref orxonox::DistanceMultiTrigger "DistanceMutliTrigger", or even an @ref orxonox::EventListener "EventListener" that waits for an event coming from any kind of @ref orxonox::PlayerTrigger "PlayerTrigger".
+        But keep in mind, that NotificationDispatcher is an abstract class.
+        Also in this example @ref orxonox::PlayerTrigger "PlayerTrigger" stands for any event that is caused by a @ref orxonox::PlayerTrigger "PlayerTrigger", so instead of @ref orxonox::PlayerTrigger "PlayerTrigger", there could be a @ref orxonox::DistanceTrigger "DistanceTrigger", or a @ref orxonox::DistanceMultiTrigger "DistanceMutliTrigger", or even an @ref orxonox::EventListener "EventListener" that waits for an event coming from any kind of @ref orxonox::PlayerTrigger "PlayerTrigger".
+        If the NotificationDispatcher is not set to broadcast only events caused by @ref orxonox::PlayerTrigger "PlayerTriggers" trigger a message since the information obtained by the @ref orxonox::PlayerTrigger "PlayerTrigger" is used to identify the client to which the message should be sent.
 
     @author
@@ -84 +88 @@
             const std::string& getSender(void) const
                 { return this->sender_; }
-                        /**
+            /**
             @brief Set the sender of the Notification dispatched by this NotificationDispatcher.
             @param sender The name of the sender.
@@ -91 +95 @@
                 { this->sender_ = sender; }
 
-            void dispatch(unsigned int clientId); //!< Dispatches a specific Notification.
+            /**
+            @brief Check whether the NotificationDispatcher is set to broadcast.
+            @return Returns true if the NotificationDispatcher is set to broadcast.
+            */
+            bool isBroadcasting(void) const
+                { return this->bBroadcast_; }
+            /**
+            @brief Set the NotificationDispatcher to broadcast.
+            @param broadcast Whether the NotificationDispatcher is set to broadcast or singlecast.
+            */
+            void setBroadcasting(bool v)
+                { this->bBroadcast_ = v; }
+
+            void broadcast(void); //!< Broadcasts a specific Notification.
+            void broadcastHelper(void); //!< Helper function for broadcast.
+            void dispatch(unsigned int clientId); //!< Dispatches a specific Notification to a given client.
             bool trigger(bool triggered, BaseObject* trigger); //!< Is called when the NotificationDispatcher is triggered.
 
         protected:
             std::string sender_; //!< The name of the sender of the Notification dispatched by this NotificationDispatcher.
+            bool bBroadcast_; //!< Whether the NotificationDispatcher is broadcasting.
 
             void registerVariables(void); //!< Register some variables for synchronisation.
@@ -105 +125 @@
             */
             virtual const std::string& createNotificationMessage(void)
-                { return *(new std::string("")); }
+                { return BLANKSTRING; }
 
     };

code/trunk/src/modules/overlays/hud/HUDNavigation.cc

@@ -63 +63 @@
 {
   SetConfigValue(markerLimit_, 3);
+
 }
 
@@ -77 +78 @@
     setTextSize ( 0.05f );
     setNavMarkerSize ( 0.05f );
+    setDetectionLimit( 10000.0f );
 }
 
@@ -95 +97 @@
     SUPER ( HUDNavigation, XMLPort, xmlelement, mode );
 
-    XMLPortParam ( HUDNavigation, "font",          setFont,          getFont,          xmlelement, mode );
-    XMLPortParam ( HUDNavigation, "textSize",      setTextSize,      getTextSize,      xmlelement, mode );
-    XMLPortParam ( HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "font",           setFont,           getFont,           xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "textSize",       setTextSize,       getTextSize,       xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "navMarkerSize",  setNavMarkerSize,  getNavMarkerSize,  xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "detectionLimit", setDetectionLimit, getDetectionLimit, xmlelement, mode );
 }
 
@@ -161 +164 @@
 
     unsigned int markerCount_ = 0;
-
+    bool closeEnough_ = false; //only display objects that are close enough to be relevant for the player
 //         for (ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it)
     for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++markerCount_, ++listIt )
     {
         ObjectMap::iterator it = activeObjectList_.find ( listIt->first );
-
-        if ( markerCount_ < markerLimit_ )
+        closeEnough_ = listIt->second < detectionLimit_ ;
+        if ( markerCount_ < markerLimit_ && (closeEnough_ ||  detectionLimit_ < 0) ) // display on HUD if the statement is true
         {
 
@@ -277 +280 @@
             it->second.text_->show();
         }
-        else
+        else // do not display on HUD
         {
             it->second.panel_->hide();
@@ -309 +312 @@
 void HUDNavigation::addObject ( RadarViewable* object )
 {
-    if( showObject(object)==false )
+    if( showObject(object) == false )
         return;
 
@@ -396 +399 @@
         return false;
     assert( rv->getWorldEntity() );
-    if ( rv->getWorldEntity()->isVisible()==false || rv->getRadarVisibility()==false )
+    if ( rv->getWorldEntity()->isVisible() == false || rv->getRadarVisibility() == false )
         return false;
     return true;

code/trunk/src/modules/overlays/hud/HUDNavigation.h

@@ -85 +85 @@
     { return navMarkerSize_; }
 
+    void setDetectionLimit( float limit )
+    { this->detectionLimit_ = limit; }
+    float getDetectionLimit() const
+    { return this->detectionLimit_; }
+
     void setTextSize ( float size );
     float getTextSize() const;
@@ -102 +107 @@
     float textSize_;
 
-    unsigned int markerLimit_;; //TODO: is it possible to set this over the console and/or the IG-Setting
-
-
+    unsigned int markerLimit_; //TODO: is it possible to set this over the console and/or the IG-Setting
+    float detectionLimit_; //!< Objects that are more far away than detectionLimit_ are not displayed on the HUD. 10000.0f is the default value.
+                           //!< In order to bypass this behaviour, set a negative detectionLimit_. Then the detection range is "infinite".
 };
 }

code/trunk/src/modules/overlays/hud/HUDRadar.cc

@@ -64 +64 @@
         this->shapeMaterials_[RadarViewable::Triangle] = "RadarTriangle.png";
         this->shapeMaterials_[RadarViewable::Square]   = "RadarSquare.png";
-
+        this->setDetectionLimit( 10000.0f );
         this->owner_ = 0;
     }
@@ -93 +93 @@
     {
         if (object == dynamic_cast<RadarViewable*>(this->owner_))
+            return;
+        if( showObject(object) == false ) //do not show objects that are "invisible" or "radar invisible"
             return;
 
@@ -123 +125 @@
 
     void HUDRadar::objectChanged( RadarViewable* rv )
-    {
-        if (rv == dynamic_cast<RadarViewable*>(this->owner_))
-            return;
-        assert( this->radarObjects_.find(rv) != this->radarObjects_.end() );
-        Ogre::PanelOverlayElement* panel = this->radarObjects_[rv];
-        panel->setMaterialName(TextureGenerator::getMaterialName(
-            shapeMaterials_[rv->getRadarObjectShape()], rv->getRadarObjectColour()));
+    {// The new implementation behaves more precisely, since inactive RadarViewables are not displayed anymore.
+        this->removeObject(rv);
+        this->addObject(rv);
     }
 
@@ -174 +172 @@
             coord *= math::pi / 3.5f; // small adjustment to make it fit the texture
             it->second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
-            it->second->show();
+            if( distance < detectionLimit_ || detectionLimit_ < 0 )
+                it->second->show();
+            else
+                it->second->hide();
 
             // if this object is in focus, then set the focus marker
@@ -186 +187 @@
     }
 
+    bool HUDRadar::showObject(RadarViewable* rv)
+    {
+        if ( rv == dynamic_cast<RadarViewable*> ( this->getOwner() ) )
+            return false;
+        assert( rv->getWorldEntity() );
+        if ( rv->getWorldEntity()->isVisible()==false || rv->getRadarVisibility()==false )
+            return false;
+        return true;
+    }
+
+
     void HUDRadar::changedOwner()
     {

code/trunk/src/modules/overlays/hud/HUDRadar.h

@@ -57 +57 @@
         void setHalfDotSizeDistance(float distance) { this->halfDotSizeDistance_ = distance; }
 
+        void setDetectionLimit( float limit )
+        { this->detectionLimit_ = limit; }
+        float getDetectionLimit() const
+        { return this->detectionLimit_; }
+
         float getMaximumDotSize() const { return this->maximumDotSize_; }
         void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
@@ -69 +74 @@
         virtual void objectChanged( RadarViewable* rv );
         void radarTick(float dt);
+        bool showObject( RadarViewable* rv ); //!< Do not display an object on radar, if showObject(.) is false.
 
         void gatherObjects();
@@ -83 +89 @@
 
         float sensitivity_;
-
+        float detectionLimit_;
         ControllableEntity* owner_;
     };

code/trunk/src/modules/pickup/PickupSpawner.cc

@@ -181 +181 @@
         if(GameMode::isMaster() && this->isActive())
         {
-            SmartPtr<PickupSpawner> temp = this; //Create a smart pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
+            WeakPtr<PickupSpawner> spawner = this; // Create a smart pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
 
             // Remove PickupCarriers from the blocked list if they have exceeded their time.
@@ -195 +195 @@
             for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
             {
+                if(spawner == NULL) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
+                    break;
+
                 Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
                 PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(*it);
-                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawnder, is in trigger-distance and the carrier is not blocked.
+                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
                 if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
                 {

code/trunk/src/modules/questsystem/QuestItem.h

@@ -105 +105 @@
             QuestDescription* description_; //!< The QuestDescription of the QuestItem.
 
-            bool registered_;
+            bool registered_; //!< Whether the QuestItem is registered with the QuestManager.
 
     };

code/trunk/src/modules/questsystem/QuestManager.cc

@@ -35 +35 @@
 
 #include "util/Exception.h"
+#include "util/OrxAssert.h"
 #include "util/ScopedSingletonManager.h"
 #include "core/command/ConsoleCommand.h"
@@ -60 +61 @@
     {
         RegisterRootObject(QuestManager);
-
         orxout(internal_info, context::quests) << "QuestManager created." << endl;
     }
@@ -95 +95 @@
     bool QuestManager::registerQuest(Quest* quest)
     {
-        assert(quest);
+        if(quest == NULL)
+        {
+            COUT(1) << "Quest pointer is NULL." << endl;
+            return false;
+        }
 
         std::pair<std::map<std::string, Quest*>::iterator,bool> result;
@@ -133 +137 @@
     bool QuestManager::registerHint(QuestHint* hint)
     {
-        assert(hint);
+        if(hint == NULL)
+        {
+            COUT(1) << "Hint pointer is NULL." << endl;
+            return false;
+        }
 
         std::pair<std::map<std::string, QuestHint*>::iterator,bool> result;
@@ -361 +369 @@
     Quest* QuestManager::getParentQuest(Quest* quest)
     {
+        OrxAssert(quest, "The input Quest is NULL.");
         return quest->getParentQuest();
     }
@@ -374 +383 @@
     QuestDescription* QuestManager::getDescription(Quest* item)
     {
+        OrxAssert(item, "The input Quest is NULL.");
         return item->getDescription();
     }
@@ -387 +397 @@
     QuestDescription* QuestManager::getDescription(QuestHint* item)
     {
+        OrxAssert(item, "The input QuestHint is NULL.");
         return item->getDescription();
     }
@@ -400 +411 @@
     const std::string QuestManager::getId(Quest* item) const
     {
+        OrxAssert(item, "The input Quest is NULL.");
         return item->getId();
     }
@@ -413 +425 @@
     const std::string QuestManager::getId(QuestHint* item) const
     {
+        OrxAssert(item, "The input QuestHint is NULL.");
         return item->getId();
     }

code/trunk/src/modules/weapons/projectiles/Rocket.cc

@@ -66 +66 @@
         this->localAngularVelocity_ = 0;
         this->lifetime_ = 100.0f;
+        this->bIsRocket_= true;
 
         if (GameMode::isMaster())
@@ -134 +135 @@
         if(this->isInitialized())
         {
+            this->bIsRocket_= false;
             if (GameMode::isMaster())
             {

code/trunk/src/orxonox/LevelManager.cc

@@ -87 +87 @@
     void LevelManager::setConfigValues()
     {
-        SetConfigValue(defaultLevelName_, "presentationDM.oxw")
+        SetConfigValue(defaultLevelName_, "missionOne.oxw")
             .description("Sets the pre selection of the level in the main menu.");
     }
@@ -158 +158 @@
         if (this->levels_.size() > 0)
         {
-            // Activate the level that is the first in the list of levels whose activity has been requested. 
+            // Activate the level that is the first in the list of levels whose activity has been requested.
             this->levels_.front()->setActive(true);
             // Make every player enter the newly activated level.
@@ -272 +272 @@
                 Loader::unload(&file);
 
-                if(info == NULL) 
+                if(info == NULL)
                 {
                     // Create a default LevelInfoItem object that merely contains the name

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

@@ -65 +65 @@
                 if (this->freedomCount_ == 1)
                 {
-                this->state_ = SLAVE;
-                this->freedomCount_ = 0;
+                    this->state_ = SLAVE;
+                    this->freedomCount_ = 0;
                 }
 
@@ -76 +76 @@
             // search enemy
             random = rnd(maxrand);
-            if (random < 15 && (!this->target_))
+            if (random < (15 + botlevel_* 20) && (!this->target_))
                 this->searchNewTarget();
 
             // forget enemy
             random = rnd(maxrand);
-            if (random < 5 && (this->target_))
+            if (random < ((1-botlevel_)*6) && (this->target_))
                 this->forgetTarget();
 
             // next enemy
             random = rnd(maxrand);
-            if (random < 10 && (this->target_))
+            if (random < (botlevel_*20) && (this->target_))
                 this->searchNewTarget();
 
@@ -106 +106 @@
             // shoot
             random = rnd(maxrand);
-            if (!(this->passive_) && random < 75 && (this->target_ && !this->bShooting_))
+            if (!(this->passive_) && random < (75 + botlevel_*25) && (this->target_ && !this->bShooting_))
                 this->bShooting_ = true;
 
             // stop shooting
             random = rnd(maxrand);
-            if (random < 25 && (this->bShooting_))
+            if (random < ((1 - botlevel_)*25) && (this->bShooting_))
                 this->bShooting_ = false;
+
+            // boost
+            random = rnd(maxrand);
+            if (random < botlevel_*100 )
+                this->boostControl();
+
+            // update Checkpoints
+            /*random = rnd(maxrand);
+            if (this->defaultWaypoint_ && random > (maxrand-10))
+                this->manageWaypoints();
+            else //if(random > maxrand-10) //CHECK USABILITY!!*/
+            if (this->waypoints_.size() == 0 )
+                this->manageWaypoints();
 
         }
@@ -159 +172 @@
                 // search enemy
                 random = rnd(maxrand);
-                if (random < 15 && (!this->target_))
+                if (random < (botlevel_)*25 && (!this->target_))
                     this->searchNewTarget();
 
                 // forget enemy
                 random = rnd(maxrand);
-                if (random < 5 && (this->target_))
+                if (random < (1-botlevel_)*6 && (this->target_))
                     this->forgetTarget();
 
@@ -185 +198 @@
                 // shoot
                 random = rnd(maxrand);
-                if (!(this->passive_) && random < 9 && (this->target_ && !this->bShooting_))
-                {
-                this->bShooting_ = true;
-                this->forceFreeSlaves();
+                if (!(this->passive_) && random < 25*(botlevel_)+1 && (this->target_ && !this->bShooting_))
+                {
+                    this->bShooting_ = true;
+                    this->forceFreeSlaves();
                 }
 
                 // stop shooting
                 random = rnd(maxrand);
-                if (random < 25 && (this->bShooting_))
+                if (random < ( (1- botlevel_)*25 ) && (this->bShooting_))
                     this->bShooting_ = false;
 
+                // boost
+                random = rnd(maxrand);
+                if (random < botlevel_*100 )
+                    this->boostControl();
+
+                // update Checkpoints
+                /*random = rnd(maxrand);
+                if (this->defaultWaypoint_ && random > (maxrand-10))
+                    this->manageWaypoints();
+                else //if(random > maxrand-10) //CHECK USABILITY!!*/
+                if (this->waypoints_.size() == 0 )
+                    this->manageWaypoints();
             }
         }
@@ -206 +231 @@
             return;
 
-        if (this->state_ == MASTER)
+        float random;
+        float maxrand = 100.0f / ACTION_INTERVAL;
+        ControllableEntity* controllable = this->getControllableEntity();
+
+        if (controllable && this->mode_ == DEFAULT)// bot is ready to move to a target
         {
-            if (this->specificMasterAction_ ==  NONE)
+            if (this->waypoints_.size() > 0 ) //Waypoint functionality.
+            {
+                WorldEntity* wPoint = this->waypoints_[this->waypoints_.size()-1];
+                if(wPoint)
+                {
+                    this->moveToPosition(wPoint->getWorldPosition()); //BUG ?? sometime wPoint->getWorldPosition() causes crash
+                    if (wPoint->getWorldPosition().squaredDistance(controllable->getPosition()) <= this->squaredaccuracy_)
+                        this->waypoints_.pop_back(); // if goal is reached, remove it from the list
+                }
+                else
+                    this->waypoints_.pop_back(); // remove invalid waypoints
+
+            }
+            else if(this->defaultWaypoint_ && ((this->defaultWaypoint_->getPosition()-controllable->getPosition()).length()  > 200.0f))
+            {
+                this->moveToPosition(this->defaultWaypoint_->getPosition()); // stay within a certain range of the defaultWaypoint_
+                random = rnd(maxrand);
+            }
+        }
+        if(this->mode_ == DEFAULT)
+            {
+            if (this->state_ == MASTER)
+            {
+                if (this->specificMasterAction_ ==  NONE)
+                {
+                    if (this->target_)
+                    {
+                        if (!this->target_->getRadarVisibility()) /* So AI won't shoot invisible Spaceships */
+                            this->forgetTarget();
+                        else
+                        {
+                            this->aimAtTarget();
+                            random = rnd(maxrand);
+                            if(this->botlevel_*100 > random && !this->isCloseAtTarget(20))
+                                this->follow();  //If a bot is shooting a player, it shouldn't let him go away easily.
+                        }
+                    }
+
+                    if (this->bHasTargetPosition_)
+                        this->moveToTargetPosition();
+
+                    this->doFire();
+                }
+
+                if (this->specificMasterAction_  == TURN180)
+                    this->turn180();
+
+                if (this->specificMasterAction_ == SPIN)
+                    this->spin();
+                if (this->specificMasterAction_ == FOLLOW)
+                    this->follow();
+            }
+
+            if (this->state_ == SLAVE)
+            {
+                if (this->bHasTargetPosition_)
+                    this->moveToTargetPosition();
+            }
+
+            if (this->state_ == FREE)
             {
                 if (this->target_)
@@ -214 +302 @@
                     if (!this->target_->getRadarVisibility()) /* So AI won't shoot invisible Spaceships */
                         this->forgetTarget();
-                    else this->aimAtTarget();
+                    else
+                    {
+                        this->aimAtTarget();
+                        random = rnd(maxrand);
+
+                        if(this->botlevel_*100 > random && !this->isCloseAtTarget(20))
+                            this->follow();//If a bot is shooting a player, it shouldn't let him go away easily.
+                     }
                 }
 
@@ -220 +315 @@
                     this->moveToTargetPosition();
 
-                if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(1000) && this->isLookingAtTarget(math::pi / 20.0f))
-                    this->getControllableEntity()->fire(0);
-            }
-
-            if (this->specificMasterAction_  == TURN180)
-                    this->turn180();
-
-            if (this->specificMasterAction_ == SPIN)
-                    this->spin();
-            if (this->specificMasterAction_ == FOLLOW)
+                this->doFire();
+            }
+        }//END_OF DEFAULT MODE
+        else if (this->mode_ == ROCKET)//Rockets do not belong to a group of bots -> bot states are not relevant.
+        {   //Vector-implementation: mode_.back() == ROCKET;
+            if(controllable)
+            {
+                if(controllable->getRocket())//Check wether the bot is controlling the rocket and if the timeout is over.
+                {
                     this->follow();
-        }
-
-        if (this->state_ == SLAVE)
-        {
-
-            if (this->bHasTargetPosition_)
-                this->moveToTargetPosition();
-
-        }
-
-         if (this->state_ == FREE)
-        {
-            if (this->target_)
-            {
-                if (!this->target_->getRadarVisibility()) /* So AI won't shoot invisible Spaceships */
-                    this->forgetTarget();
-                else this->aimAtTarget();
-            }
-
-            if (this->bHasTargetPosition_)
-                this->moveToTargetPosition();
-
-            if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(1000) && this->isLookingAtTarget(math::pi / 20.0f))
-                this->getControllableEntity()->fire(0);
-        }
+                    this->timeout_ -= dt;
+                    if((timeout_< 0)||(!target_))//Check if the timeout is over or target died.
+                    {
+                       controllable->fire(0);//kill the rocket
+                       this->setPreviousMode();//get out of rocket mode
+                    }
+                }
+                else
+                    this->setPreviousMode();//no rocket entity -> get out of rocket mode
+            }
+            else
+                this->setPreviousMode();//If bot dies -> getControllableEntity == NULL -> get out of ROCKET mode
+        }//END_OF ROCKET MODE
 
         SUPER(AIController, tick, dt);

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

@@ -39 +39 @@
 #include "worldentities/pawns/Pawn.h"
 #include "worldentities/pawns/TeamBaseMatchBase.h"
+#include "worldentities/pawns/SpaceShip.h"
 #include "gametypes/TeamDeathmatch.h"
 #include "gametypes/Dynamicmatch.h"
@@ -44 +45 @@
 #include "controllers/NewHumanController.h"
 #include "controllers/DroneController.h"
+#include "weaponsystem/WeaponMode.h"
+#include "weaponsystem/WeaponPack.h"
+#include "weaponsystem/Weapon.h"
+#include "weaponsystem/WeaponSlot.h"
+#include "weaponsystem/WeaponSlot.h"
 
 namespace orxonox
@@ -52 +58 @@
     SetConsoleCommand("ArtificialController", "passivebehaviour", &ArtificialController::passivebehaviour);
     SetConsoleCommand("ArtificialController", "formationsize",    &ArtificialController::formationsize);
+    SetConsoleCommand("ArtificialController", "setbotlevel",      &ArtificialController::setAllBotLevel);
 
     static const unsigned int STANDARD_MAX_FORMATION_SIZE = 7;
@@ -84 +91 @@
 
         this->target_.setCallback(createFunctor(&ArtificialController::targetDied, this));
+        this->bSetupWorked = false;
+        this->botlevel_ = 0.5f;
+        this->mode_ = DEFAULT;////Vector-implementation: mode_.push_back(DEFAULT);
+        this->timeout_ = 0;
+        this->currentWaypoint_ = 0;
+        this->setAccuracy(5);
+        this->defaultWaypoint_ = NULL;
     }
 
@@ -89 +103 @@
     {
         if (this->isInitialized())
-        {
+        {//Vector-implementation: mode_.erase(mode_.begin(),mode_.end());
+            this->waypoints_.clear();
             this->removeFromFormation();
-
+            this->weaponModes_.clear();
             for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it; ++it)
             {
@@ -305 +320 @@
         if (!this->getControllableEntity())
             this->removeFromFormation();
+        this->bSetupWorked = false;        // reset weapon information
+        this->setupWeapons();
     }
 
@@ -387 +404 @@
         }
     }
+
+    void ArtificialController::absoluteMoveToPosition(const Vector3& target)
+    {
+        float minDistance = 40.0f;
+        if (!this->getControllableEntity())
+            return;
+
+        Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
+        float distance = (target - this->getControllableEntity()->getPosition()).length();
+
+            if (this->target_ || distance > minDistance)
+            {
+                // Multiply with ROTATEFACTOR_FREE to make them a bit slower
+                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * sgn(coord.x) * coord.x*coord.x);
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * sgn(coord.y) * coord.y*coord.y);
+                this->getControllableEntity()->moveFrontBack(SPEED_FREE);
+            }
+
+
+        if (distance < minDistance)
+        {
+            this->positionReached();
+        }
+    }
+
 
     void ArtificialController::moveToTargetPosition()
@@ -915 +957 @@
     bool ArtificialController::sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype)
     {
+        if(!entity1 || !entity2)
+            return true;
         if (entity1 == entity2)
             return true;
@@ -1020 +1064 @@
         return (team1 == team2 && team1 != -1);
     }
+
+    /**
+        @brief DoFire is called when a bot should shoot and decides which weapon is used and whether the bot shoots at all.
+    */
+    void ArtificialController::doFire()
+    {
+        if(!this->bSetupWorked)//setup: find out which weapons are active ! hard coded: laser is "0", lens flare is "1", ...
+        {
+            this->setupWeapons();
+        }
+        else if(this->getControllableEntity() && weaponModes_.size()&&this->bShooting_ && this->isCloseAtTarget((1 + 2*botlevel_)*1000) && this->isLookingAtTarget(math::pi / 20.0f))
+        {
+            int firemode;
+            float random = rnd(1);//
+            if (this->isCloseAtTarget(130) && (firemode = getFiremode("LightningGun")) > -1 )
+            {//LENSFLARE: short range weapon
+                this->getControllableEntity()->fire(firemode); //ai uses lens flare if they're close enough to the target
+            }
+            else if( this->isCloseAtTarget(400) && (random < this->botlevel_) && (firemode = getFiremode("RocketFire")) > -1 )
+            {//ROCKET: mid range weapon
+                this->mode_ = ROCKET; //Vector-implementation: mode_.push_back(ROCKET);
+                this->getControllableEntity()->fire(firemode); //launch rocket
+                if(this->getControllableEntity() && this->target_) //after fire(3) is called, getControllableEntity() refers to the rocket!
+                {
+                    float speed = this->getControllableEntity()->getVelocity().length() - target_->getVelocity().length();
+                    if(!speed) speed = 0.1f;
+                    float distance = target_->getPosition().length() - this->getControllableEntity()->getPosition().length();
+                    this->timeout_= distance/speed*sgn(speed*distance) + 1.8f; //predicted time of target hit (+ tolerance)
+                }
+                else
+                    this->timeout_ = 4.0f; //TODO: find better default value
+            }
+            else if ((firemode = getFiremode("HsW01")) > -1 ) //LASER: default weapon
+                this->getControllableEntity()->fire(firemode);
+        }
+    }
+
+    /**
+        @brief Information gathering: Which weapons are ready to use?
+    */
+    void ArtificialController::setupWeapons() //TODO: Make this function generic!! (at the moment is is based on conventions)
+    {
+        this->bSetupWorked = false;
+        if(this->getControllableEntity())
+        {
+            Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
+            if(pawn)
+            {
+                this->weaponModes_.clear(); // reset previous weapon information
+                WeaponSlot* wSlot = 0;
+                for(int l=0; (wSlot = pawn->getWeaponSlot(l)) ; l++)
+                {
+                    WeaponMode* wMode = 0;
+                    for(int i=0; (wMode = wSlot->getWeapon()->getWeaponmode(i)) ; i++)
+                    {
+                        std::string wName = wMode->getIdentifier()->getName();
+                        if(this->getFiremode(wName) == -1) //only add a weapon, if it is "new"
+                            weaponModes_[wName] = wMode->getMode();
+                    }
+                }
+                if(weaponModes_.size())//at least one weapon detected
+                    this->bSetupWorked = true;
+            }//pawn->weaponSystem_->getMunition(SubclassIdentifier< Munition > *identifier)->getNumMunition (WeaponMode *user);
+        }
+    }
+
+
+    void ArtificialController::setBotLevel(float level)
+    {
+        if (level < 0.0f)
+            this->botlevel_ = 0.0f;
+        else if (level > 1.0f)
+            this->botlevel_ = 1.0f;
+        else
+            this->botlevel_ = level;
+    }
+
+    void ArtificialController::setAllBotLevel(float level)
+    {
+        for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it)
+            it->setBotLevel(level);
+    }
+
+    void ArtificialController::setPreviousMode()
+    {
+        this->mode_ = DEFAULT; //Vector-implementation: mode_.pop_back();
+    }
+
+    /**
+        @brief Manages boost. Switches between boost usage and boost safe mode.
+    */
+    void ArtificialController::boostControl()
+    {
+        SpaceShip* ship = orxonox_cast<SpaceShip*>(this->getControllableEntity());
+        if(ship == NULL) return;
+        if(ship->getBoostPower()*1.5f > ship->getInitialBoostPower() ) //upper limit ->boost
+            this->getControllableEntity()->boost(true);
+        else if(ship->getBoostPower()*4.0f < ship->getInitialBoostPower()) //lower limit ->do not boost
+            this->getControllableEntity()->boost(false);
+    }
+
+    int ArtificialController::getFiremode(std::string name)
+    {
+        for (std::map< std::string, int >::iterator it = this->weaponModes_.begin(); it != this->weaponModes_.end(); ++it)
+        {
+            if (it->first == name)
+                return it->second;
+        }
+        return -1;
+    }
+
+    void ArtificialController::addWaypoint(WorldEntity* waypoint)
+    {
+        this->waypoints_.push_back(waypoint);
+    }
+
+    WorldEntity* ArtificialController::getWaypoint(unsigned int index) const
+    {
+        if (index < this->waypoints_.size())
+            return this->waypoints_[index];
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds first waypoint of type name to the waypoint stack, which is within the searchDistance
+        @param name object-name of a point of interest (e.g. "PickupSpawner", "ForceField")
+    */
+    void ArtificialController::updatePointsOfInterest(std::string name, float searchDistance)
+    {
+        WorldEntity* waypoint = NULL;
+        for (ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it != ObjectList<WorldEntity>::end(); ++it)
+        {
+            if((*it)->getIdentifier() == ClassByString(name))
+            {
+                ControllableEntity* controllable = this->getControllableEntity();
+                if(!controllable) continue;
+                float actualDistance = ( (*it)->getPosition() - controllable->getPosition() ).length();
+                if(actualDistance > searchDistance || actualDistance < 5.0f) continue;
+                    // TODO: PickupSpawner: adjust waypoint accuracy to PickupSpawner's triggerdistance
+                    // TODO: ForceField: analyze is angle between forcefield boost and own flying direction is acceptable
+                else
+                {
+                    waypoint = *it;
+                    break;
+                }
+            }
+        }
+        if(waypoint)
+            this->waypoints_.push_back(waypoint);
+    }
+
+    /**
+        @brief Adds point of interest depending on context. Further Possibilites: "ForceField", "PortalEndPoint", "MovableEntity", "Dock"
+    */
+    void ArtificialController::manageWaypoints()
+    {
+        if(!defaultWaypoint_)
+            this->updatePointsOfInterest("PickupSpawner", 200.0f); // long search radius if there is no default goal
+        else
+            this->updatePointsOfInterest("PickupSpawner", 20.0f); // take pickup en passant if there is a default waypoint
+    }
+
 }

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

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include <vector>
+#include <map>
 
 #include "util/Math.h"
 #include "Controller.h"
 #include "controllers/NewHumanController.h"
+#include "weaponsystem/WeaponSystem.h"
 
 namespace orxonox
@@ -78 +79 @@
             static void formationsize(const int size);
 
+            virtual void doFire();
+            void setBotLevel(float level=1.0f);
+            inline float getBotLevel() const
+                { return this->botlevel_; }
+            static void setAllBotLevel(float level);
+            //WAYPOINT FUNCTIONS
+            void addWaypoint(WorldEntity* waypoint);
+            WorldEntity* getWaypoint(unsigned int index) const;
+
+            inline void setAccuracy(float accuracy)
+                { this->squaredaccuracy_ = accuracy*accuracy; }
+            inline float getAccuracy() const
+                { return sqrt(this->squaredaccuracy_); }
+            void updatePointsOfInterest(std::string name, float distance);
+            void manageWaypoints();
+
         protected:
 
@@ -96 +113 @@
             void moveToPosition(const Vector3& target);
             void moveToTargetPosition();
+            void absoluteMoveToPosition(const Vector3& target);
 
             virtual void positionReached() {}
@@ -135 +153 @@
 
             static bool sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype); // hack
+            void boostControl(); //<! Sets and resets the boost parameter of the spaceship. Bots alternate between boosting and saving boost.
 
             bool bHasTargetPosition_;
@@ -141 +160 @@
             bool bShooting_;
 
-        private:
+            float botlevel_; //<! Makes the level of a bot configurable.
+            enum Mode {DEFAULT, ROCKET, DEFENCE, MOVING};//TODO; implement DEFENCE, MOVING modes
+            Mode mode_; //TODO: replace single value with stack-like implementation: std::vector<Mode> mode_;
+            void setPreviousMode();
+
+            //WEAPONSYSTEM DATA
+            std::map<std::string, int> weaponModes_; //<! Links each "weapon" to it's weaponmode- managed by setupWeapons()
+            //std::vector<int> projectiles_; //<! Displays amount of projectiles of each weapon. - managed by setupWeapons()
+            float timeout_; //<! Timeout for rocket usage. (If a rocket misses, a bot should stop using it.)
+            void setupWeapons(); //<! Defines which weapons are available for a bot. Is recalled whenever a bot was killed.
+            bool bSetupWorked; //<! If false, setupWeapons() is called.
+            int getFiremode(std::string name);
+
+            //WAYPOINT DATA
+            std::vector<WeakPtr<WorldEntity> > waypoints_;
+            size_t currentWaypoint_;
+            float squaredaccuracy_;
+            WorldEntity* defaultWaypoint_;
     };
 }

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

@@ -52 +52 @@
         this->drone_ = 0;
         this->isShooting_ = false;
+        this->setAccuracy(10);
 
         this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&DroneController::action, this)));
@@ -92 +93 @@
         The duration of the tick.
     */
+    /* PORTALS workaround:
+    if the owner uses a portal -> distance between owner and drone is huge -> is detected by drone
+    -> drone searches for portal -> drone adds portal as waypoint -> drone flies towards portal //ignores owner
+    -> if the drone used a portal, then the distance to the owner is small -> remove waypoint // back to normal mode
+
+    */
     void DroneController::tick(float dt)
     {
         if (this->getDrone() && this->getOwner())
         {
-            if (this->target_)
+            if (this->waypoints_.size() > 0 ) //Waypoint functionality: Drone should follow it's master through portals
+            {// Idea: after using the the portal, the master is far away.
+                WorldEntity* wPoint = this->waypoints_[this->waypoints_.size()-1];
+                if(wPoint)
+                {
+                    float distanceToOwnerSquared = (this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength();
+                    this->absoluteMoveToPosition(wPoint->getWorldPosition()); //simplified function - needs WORKAROUND
+                    if (distanceToOwnerSquared <= 90000.0f) //WORKAROUND: if the Drone is again near its owner, the portal has been used correctly.
+                    {
+                        this->waypoints_.pop_back(); // if goal is reached, remove it from the list
+                        this->positionReached(); //needed??
+                    }
+
+                }
+                else
+                    this->waypoints_.pop_back(); // remove invalid waypoints
+            }
+            else
             {
-                float distanceToTargetSquared = (this->getDrone()->getWorldPosition() - this->target_->getWorldPosition()).squaredLength();
-                if (distanceToTargetSquared < (this->getDrone()->getMaxShootingRange()*this->getDrone()->getMaxShootingRange()))
+                if (this->target_)
                 {
-                    this->isShooting_ = true;
-                    this->aimAtTarget();
-                    this->getDrone()->fire(0);
+                    float distanceToTargetSquared = (this->getDrone()->getWorldPosition() - this->target_->getWorldPosition()).squaredLength();
+                    if (distanceToTargetSquared < (this->getDrone()->getMaxShootingRange()*this->getDrone()->getMaxShootingRange()))
+                    {
+                       this->isShooting_ = true;
+                       this->aimAtTarget();
+                       if(!this->friendlyFire())
+                           this->getDrone()->fire(0);
+                    }
+               }
+
+
+                float maxDistanceSquared = this->getDrone()->getMaxDistanceToOwner()*this->getDrone()->getMaxDistanceToOwner();
+                float minDistanceSquared = this->getDrone()->getMinDistanceToOwner()*this->getDrone()->getMinDistanceToOwner();
+                if((this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength()  > 20.0f*maxDistanceSquared)
+                {//FIX: if the drone's owner uses portal, the drone searches for the portal & adds it as a waypoint.
+                    this->updatePointsOfInterest("PortalEndPoint", 500.0f); //possible conflict: speed-pickup
                 }
+                if ((this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength()  > maxDistanceSquared)
+                {
+                    this->moveToPosition(this->getOwner()->getWorldPosition()); //fly towards owner
+                }
+                else if((this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength() < minDistanceSquared)
+                {
+                    this->moveToPosition(-this->getOwner()->getWorldPosition()); //fly away from owner
+                }
+                else if (!this->isShooting_)
+                {
+                    float random = rnd(2.0f);
+                    float randomSelection = rnd(6.0f);
+                    if((int)randomSelection==0) drone_->moveUpDown(random);
+                    else if((int)randomSelection==1) drone_->moveRightLeft(random);
+                    else if((int)randomSelection==2) drone_->moveFrontBack(random);
+                    else if((int)randomSelection==3) drone_->rotateYaw(random);
+                    else if((int)randomSelection==4) drone_->rotatePitch(random);
+                    else if((int)randomSelection==5) drone_->rotateRoll(random);
+                }
+
+                this->isShooting_ = false;
             }
-
-            float maxDistanceSquared = this->getDrone()->getMaxDistanceToOwner()*this->getDrone()->getMaxDistanceToOwner();
-            float minDistanceSquared = this->getDrone()->getMinDistanceToOwner()*this->getDrone()->getMinDistanceToOwner();
-            if ((this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength()  > maxDistanceSquared)
-            {
-                this->moveToPosition(this->getOwner()->getWorldPosition()); //fly towards owner
-            }
-            else if((this->getDrone()->getWorldPosition() - this->getOwner()->getWorldPosition()).squaredLength() < minDistanceSquared)
-            {
-                this->moveToPosition(-this->getOwner()->getWorldPosition()); //fly away from owner
-            }
-            else if (!this->isShooting_)
-            {
-                float random = rnd(2.0f);
-                float randomSelection = rnd(6.0f);
-                if((int)randomSelection==0) drone_->moveUpDown(random);
-                else if((int)randomSelection==1) drone_->moveRightLeft(random);
-                else if((int)randomSelection==2) drone_->moveFrontBack(random);
-                else if((int)randomSelection==3) drone_->rotateYaw(random);
-                else if((int)randomSelection==4) drone_->rotatePitch(random);
-                else if((int)randomSelection==5) drone_->rotateRoll(random);
-            }
-
-            this->isShooting_ = false;
         }
-
         SUPER(AIController, tick, dt);
-
     }
 
@@ -147 +178 @@
             this->destroy();
     }
+
+    bool DroneController::friendlyFire()
+    {   ControllableEntity* droneEntity_ = this->getControllableEntity();
+        if (!droneEntity_) return false;
+        if(!owner_) return false;
+        if(this->bHasTargetPosition_)
+        {
+            Vector3 ownerPosition_ = owner_->getPosition();
+            Vector3 toOwner_ = owner_->getPosition() - droneEntity_->getPosition();
+            Vector3 toTarget_ = targetPosition_ - droneEntity_->getPosition();
+            if(toTarget_.length() < toOwner_.length()) return false; //owner is far away = in safty
+            float angleToOwner = getAngle(droneEntity_->getPosition(), droneEntity_->getOrientation() * WorldEntity::FRONT, ownerPosition_);
+            float angleToTarget = getAngle(droneEntity_->getPosition(), droneEntity_->getOrientation() * WorldEntity::FRONT, targetPosition_);
+            float angle = angleToOwner - angleToTarget;//angle between target and owner, observed by the drone
+            if(std::sin(angle)*toOwner_.length() < 5.0f)//calculate owner's distance to shooting line
+            return true;
+        }
+        return false;//Default return value: Usually there is no friendlyFire
+    }
 }

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

@@ -66 +66 @@
             virtual void action();
             void ownerDied();
+            bool friendlyFire(); //<! returns true if the owner_ would be hit.
             bool isShooting_;
 

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

@@ -40 +40 @@
     {
         RegisterObject(WaypointController);
-
-        this->currentWaypoint_ = 0;
         this->setAccuracy(100);
     }
@@ -47 +45 @@
     WaypointController::~WaypointController()
     {
-        if (this->isInitialized())
+        for (size_t i = 0; i < this->waypoints_.size(); ++i)
         {
-            for (size_t i = 0; i < this->waypoints_.size(); ++i)
+            if(this->waypoints_[i])
                 this->waypoints_[i]->destroy();
         }
@@ -58 +56 @@
         SUPER(WaypointController, XMLPort, xmlelement, mode);
 
-        XMLPortParam(WaypointController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
-        XMLPortObject(WaypointController, WorldEntity, "waypoints", addWaypoint, getWaypoint,  xmlelement, mode);
+        XMLPortParam(ArtificialController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
+        XMLPortObject(ArtificialController, WorldEntity, "waypoints", addWaypoint, getWaypoint,  xmlelement, mode);
     }
 
@@ -76 +74 @@
     }
 
-    void WaypointController::addWaypoint(WorldEntity* waypoint)
-    {
-        this->waypoints_.push_back(waypoint);
-    }
-
-    WorldEntity* WaypointController::getWaypoint(unsigned int index) const
-    {
-        if (index < this->waypoints_.size())
-            return this->waypoints_[index];
-        else
-            return 0;
-    }
 }

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

@@ -47 +47 @@
             virtual void tick(float dt);
 
-            void addWaypoint(WorldEntity* waypoint);
-            WorldEntity* getWaypoint(unsigned int index) const;
+        protected:
 
-            inline void setAccuracy(float accuracy)
-                { this->squaredaccuracy_ = accuracy*accuracy; }
-            inline float getAccuracy() const
-                { return sqrt(this->squaredaccuracy_); }
-
-        protected:
-            std::vector<WorldEntity*> waypoints_;
-            size_t currentWaypoint_;
-            float squaredaccuracy_;
     };
 }

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

@@ -235 +235 @@
 
         this->controllableEntity_->setController(0);
-        this->controllableEntity_->destroyHud(); // HACK-ish
+        if(this->isHumanPlayer()) // TODO: Multiplayer?
+            this->controllableEntity_->destroyHud(); // HACK-ish
         
 //        this->controllableEntity_ = this->previousControllableEntity_.back();
@@ -248 +249 @@
 
          // HACK-ish
-        if(this->controllableEntity_ != NULL)
+        if(this->controllableEntity_ != NULL && this->isHumanPlayer())
             this->controllableEntity_->createHud();
 

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

@@ -35 +35 @@
 namespace orxonox
 {
+        /**
+        @brief
+            The a WeaponSlot defines where a @ref orxonox::Weapon "Weapon" is placed on a pawn. (A WeaponSlot is a StaticEntity)
+            In a WeaponSlot there can be only one "Weapon", but a Weapon can have several @ref orxonox::WeaponMode "WeaponModes".
+            A WeaponMode is what one intuitively imagines as weapon. (E.g. RocketFire, LightningGun, LaserFire are weaponmodes)
+
+            A WeaponSlot is created in XML (in a weaponsettings file), which can be done in the following fashion:
+            @code
+            <weaponslots>
+              <WeaponSlot position="-15.0,-1.5,0" />
+              <WeaponSlot position=" 15.0,-1.5,0" />
+              <WeaponSlot position="    0,   0,0" />
+            </weaponslots>
+
+        @author
+            Martin Polak
+
+        @ingroup Weaponsystem
+    */
     class _OrxonoxExport WeaponSlot : public StaticEntity
     {

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

@@ -67 +67 @@
         this->camera_ = 0;
         this->xmlcontroller_ = 0;
-        this->controller_ = 0;
+        //this->controller_ = 0;
         this->reverseCamera_ = 0;
         this->bDestroyWhenPlayerLeft_ = false;
@@ -74 +74 @@
         this->bMouseLook_ = false;
         this->mouseLookSpeed_ = 200;
+        this->bIsRocket_ = false;
 
         this->server_position_         = Vector3::ZERO;
@@ -189 +190 @@
         return counter;
     }
-    
+
     bool ControllableEntity::setCameraPosition(unsigned int index)
     {
@@ -309 +310 @@
     }
 
+    void ControllableEntity::setController(Controller* val)
+    {
+        this->controller_ = val;
+    }
+
     void ControllableEntity::setTarget( WorldEntity* target )
     {

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

@@ -99 +99 @@
             */
             virtual void boost(bool bBoost) {}
-            
+
             virtual void greet() {}
             virtual void switchCamera();
@@ -155 +155 @@
 
             inline Controller* getController() const
-                { return this->controller_; }
-            inline void setController(Controller* val)
-                { this->controller_ = val; }
+                { return this->controller_.get(); }
+            void setController(Controller* val);
+
 
             virtual void setTarget( WorldEntity* target );
@@ -163 +163 @@
                 { return this->target_.get(); }
             void setTargetInternal( uint32_t targetID );
+            inline bool getRocket() const
+                { return this-> bIsRocket_; }
 
         protected:
@@ -181 +183 @@
 
             Ogre::SceneNode* cameraPositionRootNode_;
+            bool bIsRocket_; //Workaround to see, if the controllable entity is a Rocket.
 
         private:
@@ -234 +237 @@
             std::string cameraPositionTemplate_;
             Controller* xmlcontroller_;
-            Controller* controller_;
+            WeakPtr<Controller> controller_;
             CameraPosition* reverseCamera_;
             WeakPtr<WorldEntity> target_;

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

@@ -93 +93 @@
 
         this->isHumanShip_ = this->hasLocalController();
-        
+
         this->setSyncMode(ObjectDirection::Bidirectional); // needed to synchronise e.g. aimposition
     }
@@ -450 +450 @@
         this->isHumanShip_ = true;
     }
+
+    void Pawn::changedActivity(void)
+    {
+        SUPER(Pawn, changedActivity);
+
+        this->setRadarVisibility(this->isActive());
+    }
+
+    void Pawn::changedVisibility(void)
+    {
+        SUPER(Pawn, changedVisibility);
+        //this->setVisible(this->isVisible());
+        this->setRadarVisibility(this->isVisible());
+    }
+
 }

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

@@ -170 +170 @@
             virtual const Vector3& getCarrierPosition(void) const
                 { return this->getWorldPosition(); };
+            virtual void changedActivity(void); //!< To enable radarviewability when the activity is changed
+            virtual void changedVisibility(void); //!< To enable proper radarviewability when the visibility is changed
 
         protected:
@@ -195 +197 @@
             float maxHealth_;
             float initialHealth_;
-            
+
             float shieldHealth_;
             float maxShieldHealth_;

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

@@ -298 +298 @@
     }
 
-        /**
-    @brief
-        Add an Engine to the SpaceShip.
-    @param engine
-        A pointer to the Engine to be added.
-    */
     void SpaceShip::addEngine(orxonox::Engine* engine)
     {
@@ -504 +498 @@
     void SpaceShip::resetCamera()
     {
-        Camera *camera = this->getCamera();
-        if (camera == 0)
-        {
-            orxout(internal_warning) << "Failed to reset camera!" << endl;
-            return;
-        }
-
-        this->shakeDt_ = 0.0f;
-        camera->setPosition(this->cameraOriginalPosition_);
-        camera->setOrientation(this->cameraOriginalOrientation_);
+        if(this->hasLocalController() && this->hasHumanController())
+        {
+            Camera *camera = this->getCamera();
+            if (camera == 0)
+            {
+                orxout(internal_warning) << "Failed to reset camera!" << endl;
+                return;
+            }
+            this->shakeDt_ = 0.0f;
+            camera->setPosition(this->cameraOriginalPosition_);
+            camera->setOrientation(this->cameraOriginalOrientation_);
+        }
     }