Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Aug 11, 2010, 8:55:13 AM (14 years ago)
Author:
dafrick
Message:

Merged presentation3 branch into trunk.

Location:
code/trunk
Files:
4 deleted
100 edited
25 copied

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/modules/CMakeLists.txt

    r6524 r7163  
    3333ADD_SUBDIRECTORY(questsystem)
    3434ADD_SUBDIRECTORY(weapons)
     35ADD_SUBDIRECTORY(designtools)

  • code/trunk/src/modules/objects/CMakeLists.txt

    r5781 r7163  
    1515  PCH_FILE
    1616    ObjectsPrecompiledHeaders.h
    17   DEFINE_SYMBOL
    18     "OBJECTS_SHARED_BUILD"
    1917  LINK_LIBRARIES
    2018    orxonox

  • code/trunk/src/modules/objects/ObjectsPrereqs.h

    r6906 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(OBJECTS_STATIC_BUILD)
    4646#  ifdef OBJECTS_SHARED_BUILD
    4747#    define _ObjectsExport __declspec(dllexport)

  • code/trunk/src/modules/objects/Planet.cc

    r6501 r7163  
    7070        {
    7171            Camera* activeCamera = CameraManager::getInstance().getActiveCamera();
    72             if (activeCamera)
     72            if (activeCamera && this->billboard_.getBillboardSet())
    7373            {
    7474                float distance = this->getPosition().distance( activeCamera->getWorldPosition() );
    … …  
    8989    void Planet::init()
    9090    {
    91         float scaleFactor = this->getScale();
    92 
    93 #if OGRE_VERSION >= 0x010700
    94         Ogre::Mesh::LodValueList distList;
    95 #else
    96         Ogre::Mesh::LodDistanceList distList;
    97 #endif
    98 
    99         distList.push_back(10.0f*scaleFactor);
    100         distList.push_back(19.0f*scaleFactor);
    101         distList.push_back(27.0f*scaleFactor);
    102         distList.push_back(34.0f*scaleFactor);
    103         distList.push_back(40.0f*scaleFactor);
    104         distList.push_back(45.0f*scaleFactor);
    105         distList.push_back(49.0f*scaleFactor);
    106         distList.push_back(52.0f*scaleFactor);
    107         distList.push_back(54.0f*scaleFactor);
    108         distList.push_back(55.0f*scaleFactor);
    109 
    110         float reductionValue = 0.2f;
    111 
    112         this->mesh_.getEntity()->getMesh()->generateLodLevels(distList, Ogre::ProgressiveMesh::VRQ_PROPORTIONAL, reductionValue);
    113         billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->atmosphere_, Vector3(0,0,0));
    114 
    115         this->attachOgreObject(this->billboard_.getBillboardSet());
    116         this->billboard_.getBillboardSet()->setUseAccurateFacing(true);
    117         this->setCastShadows(true);
    118         this->billboard_.getBillboardSet()->setRenderQueueGroup(this->mesh_.getEntity()->getRenderQueueGroup());
    119         this->mesh_.setCastShadows(true);
    12091    }
    12192
    12293    void Planet::changedMesh()
    12394    {
    124         if (this->mesh_.getEntity())
    125             this->detachOgreObject(this->mesh_.getEntity());
     95        if( GameMode::showsGraphics() )
     96        {
     97            if (this->mesh_.getEntity())
     98                this->detachOgreObject(this->mesh_.getEntity());
    12699
    127         this->mesh_.setMeshSource(this->getScene()->getSceneManager(), this->meshSrc_);
     100            this->mesh_.setMeshSource(this->getScene()->getSceneManager(), this->meshSrc_);
    128101
    129         if (this->mesh_.getEntity())
    130         {
    131             this->attachOgreObject(this->mesh_.getEntity());
    132             this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
    133             this->mesh_.setVisible(this->isVisible());
     102            if (this->mesh_.getEntity())
     103            {
     104                this->attachOgreObject(this->mesh_.getEntity());
     105                this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
     106                this->mesh_.setVisible(this->isVisible());
     107
     108                float scaleFactor = this->getScale();
     109
     110    #if OGRE_VERSION >= 0x010700
     111                Ogre::Mesh::LodValueList distList;
     112    #else
     113                Ogre::Mesh::LodDistanceList distList;
     114    #endif
     115
     116                distList.push_back(10.0f*scaleFactor);
     117                distList.push_back(19.0f*scaleFactor);
     118                distList.push_back(27.0f*scaleFactor);
     119                distList.push_back(34.0f*scaleFactor);
     120                distList.push_back(40.0f*scaleFactor);
     121                distList.push_back(45.0f*scaleFactor);
     122                distList.push_back(49.0f*scaleFactor);
     123                distList.push_back(52.0f*scaleFactor);
     124                distList.push_back(54.0f*scaleFactor);
     125                distList.push_back(55.0f*scaleFactor);
     126
     127                float reductionValue = 0.2f;
     128
     129                this->mesh_.getEntity()->getMesh()->generateLodLevels(distList, Ogre::ProgressiveMesh::VRQ_PROPORTIONAL, reductionValue);
     130                billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->atmosphere_, Vector3(0,0,0));
     131
     132                this->attachOgreObject(this->billboard_.getBillboardSet());
     133                this->billboard_.getBillboardSet()->setUseAccurateFacing(true);
     134                this->setCastShadows(true);
     135                this->billboard_.getBillboardSet()->setRenderQueueGroup(this->mesh_.getEntity()->getRenderQueueGroup());
     136                this->mesh_.setCastShadows(true);
     137            }
    134138        }
    135         this->init();
    136139    }
    137140
    … …  
    151154        SUPER(Planet, XMLPort, xmlelement, mode);
    152155
    153         if (GameMode::showsGraphics())
    154         {
    155             XMLPortParam(Planet, "atmosphere", setAtmosphere, getAtmosphere, xmlelement, mode).defaultValues("planet/Atmosphere");
    156             XMLPortParam(Planet, "atmospheresize", setAtmosphereSize, getAtmosphereSize, xmlelement,mode);
    157             XMLPortParam(Planet, "imagesize", setImageSize, getImageSize, xmlelement,mode);
    158             XMLPortParam(Planet, "mesh", setMeshSource, getMeshSource, xmlelement, mode);
    159             XMLPortParam(Planet, "shadow", setCastShadows, getCastShadows, xmlelement, mode).defaultValues(true);
    160         }
     156        XMLPortParam(Planet, "atmosphere", setAtmosphere, getAtmosphere, xmlelement, mode).defaultValues("planet/Atmosphere");
     157        XMLPortParam(Planet, "atmospheresize", setAtmosphereSize, getAtmosphereSize, xmlelement,mode);
     158        XMLPortParam(Planet, "imagesize", setImageSize, getImageSize, xmlelement,mode);
     159        XMLPortParam(Planet, "mesh", setMeshSource, getMeshSource, xmlelement, mode);
     160        XMLPortParam(Planet, "shadow", setCastShadows, getCastShadows, xmlelement, mode).defaultValues(true);
    161161    }
    162162
    … …  
    164164    {
    165165        registerVariable(this->atmosphere_, VariableDirection::ToClient);
     166        registerVariable(this->atmosphereSize, VariableDirection::ToClient);
     167        registerVariable(this->imageSize, VariableDirection::ToClient);
     168        // Note: the meshSrc should be synchronised after atmosphere and other values, because the meshSrc callback setts the atmosphere billboards
    166169        registerVariable(this->meshSrc_, VariableDirection::ToClient, new NetworkCallback<Planet>(this, &Planet::changedMesh));
    167170        registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Planet>(this, &Planet::changedShadows));
    168         registerVariable(this->atmosphereSize, VariableDirection::ToClient);
    169         registerVariable(this->imageSize, VariableDirection::ToClient);
    170171    }
    171172

  • code/trunk/src/modules/objects/Planet.h

    r6501 r7163  
    9494
    9595        protected:
    96             void registerVariables();
    9796
    9897        private:
     98            void registerVariables();
    9999
    100100            void changedMesh();

  • code/trunk/src/modules/objects/collisionshapes/BoxCollisionShape.h

    r5781 r7163  
    4343            virtual ~BoxCollisionShape();
    4444
    45             void registerVariables();
    4645            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    4746
    … …  
    6766
    6867        private:
     68            void registerVariables();
     69
    6970            btCollisionShape* createNewShape() const;
    7071

  • code/trunk/src/modules/objects/collisionshapes/ConeCollisionShape.h

    r5781 r7163  
    4141            virtual ~ConeCollisionShape();
    4242
    43             void registerVariables();
    4443            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    4544
    … …  
    5554
    5655        private:
     56            void registerVariables();
     57
    5758            btCollisionShape* createNewShape() const;
    5859

  • code/trunk/src/modules/objects/collisionshapes/PlaneCollisionShape.h

    r5781 r7163  
    4343            virtual ~PlaneCollisionShape();
    4444
    45             void registerVariables();
    4645            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    4746
    … …  
    5756
    5857        private:
     58            void registerVariables();
     59
    5960            btCollisionShape* createNewShape()const;
    6061

  • code/trunk/src/modules/objects/collisionshapes/SphereCollisionShape.h

    r5781 r7163  
    4141            virtual ~SphereCollisionShape();
    4242
    43             void registerVariables();
    4443            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    4544
    … …  
    5049
    5150        private:
     51            void registerVariables();
     52
    5253            btCollisionShape* createNewShape() const;
    5354

  • code/trunk/src/modules/objects/eventsystem/EventListener.cc

    r6856 r7163  
    6161            return;
    6262        }
    63        
     63
    6464        COUT(4) << "EventListener, processing event: originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << ")" << ", activate: " << event.activate_ << ", name: " << event.name_ << std::endl;
    6565

  • code/trunk/src/modules/objects/triggers/CheckPoint.cc

    r5929 r7163  
    3838    CreateFactory(CheckPoint);
    3939
    40     CheckPoint::CheckPoint(BaseObject* creator) : DistanceTrigger(creator)
     40    CheckPoint::CheckPoint(BaseObject* creator)
     41        : DistanceTrigger(creator)
     42        , RadarViewable(creator, static_cast<WorldEntity*>(this))
    4143    {
    4244        RegisterObject(CheckPoint);

  • code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.cc

    • Property svn:eol-style set to native
    r6906 r7163  
    4040namespace orxonox
    4141{
    42    
     42
    4343    CreateFactory(DistanceMultiTrigger);
    4444
    4545    /**
    4646    @brief
    47         Default Constructor. Registers the object and initializes default values. 
     47        Default Constructor. Registers the object and initializes default values.
    4848    */
    4949    DistanceMultiTrigger::DistanceMultiTrigger(BaseObject* creator) : MultiTrigger(creator)
    5050    {
    5151        RegisterObject(DistanceMultiTrigger);
    52        
     52
    5353        this->distance_ = 100.0f;
    5454        this->targetName_ = BLANKSTRING;
    … …  
    9898                continue;
    9999            }
    100            
     100
    101101            Vector3 distanceVec = entity->getWorldPosition() - this->getWorldPosition();
    102102            // If the object is no longer in range.
    … …  
    154154                if(this->singleTargetMode_)
    155155                    entity = entity->getParent();
    156                
     156
    157157                // If no queue has been created, yet.
    158158                if(queue == NULL)
    … …  
    166166            }
    167167        }
    168        
     168
    169169        return queue;
    170170    }
    171    
     171
    172172}

  • code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.h

    • Property svn:eol-style set to native
    r6906 r7163  
    5656    class _ObjectsExport DistanceMultiTrigger : public MultiTrigger
    5757    {
    58        
     58
    5959        public:
    6060            DistanceMultiTrigger(BaseObject* creator); //!< Default Constructor. Registers the object and initializes default values.
    6161            ~DistanceMultiTrigger(); //!< Destructor.
    62            
     62
    6363            void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a DistanceMultiTrigger object through XML.
    6464
    … …  
    7575            inline const std::string& getTargetName(void)
    7676                { return this->targetName_; }
    77            
     77
    7878            /**
    7979            @brief Set the distance at which the DistanceMultiTrigger triggers.
    … …  
    8888            inline float getDistance() const
    8989                { return this->distance_; }
    90                
     90
    9191        protected:
    9292            virtual std::queue<MultiTriggerState*>* letTrigger(void); //!< This method is called by the MultiTrigger to get information about new trigger events that need to be looked at.
    … …  
    106106            inline bool removeFromRange(WorldEntity* entity)
    107107                { WeakPtr<WorldEntity>* weakptr = this->range_.find(entity)->second; bool erased = this->range_.erase(entity) > 0; if(erased) delete weakptr; return erased; }
    108                
     108
    109109        private:
    110110            float distance_; //!< The distance at which the DistanceMultiTrigger triggers.
    111111            std::string targetName_; //!< The target name, used in singleTargetMode.
    112112            bool singleTargetMode_; //!< To indicate whe the MultiDistanceTrigger is in single-target-mode.
    113            
     113
    114114            std::map<WorldEntity*, WeakPtr<WorldEntity>* > range_; //!< The set of entities that currently are in range of the DistanceMultiTrigger.
    115        
     115
    116116    };
    117    
     117
    118118}
    119119

  • code/trunk/src/modules/objects/triggers/DistanceTrigger.cc

    r6906 r7163  
    136136          continue;
    137137      }
    138      
     138
    139139      Vector3 distanceVec = entity->getWorldPosition() - this->getWorldPosition();
    140140      if (distanceVec.length() < this->distance_)
    … …  
    155155      }
    156156    }
     157
    157158    return false;
    158159  }

  • code/trunk/src/modules/objects/triggers/DistanceTriggerBeacon.cc

    • Property svn:eol-style set to native
    r6906 r7163  
    3535
    3636    CreateFactory(DistanceTriggerBeacon);
    37    
     37
    3838    DistanceTriggerBeacon::DistanceTriggerBeacon(BaseObject* creator) : StaticEntity(creator)
    3939    {
    4040        RegisterObject(DistanceTriggerBeacon);
    4141    }
    42    
     42
    4343}

  • code/trunk/src/modules/objects/triggers/DistanceTriggerBeacon.h

    • Property svn:eol-style set to native
    r6906 r7163  
    3939    class _ObjectsExport DistanceTriggerBeacon : public StaticEntity
    4040    {
    41        
     41
    4242        public:
    4343

  • code/trunk/src/modules/objects/triggers/EventMultiTrigger.cc

    • Property svn:eol-style set to native
    r6864 r7163  
    5252    EventMultiTrigger::~EventMultiTrigger()
    5353    {
    54        
     54
    5555    }
    5656
    … …  
    6161        this->setBroadcast(true);
    6262    }
    63    
     63
    6464    void EventMultiTrigger::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
    6565    {

  • code/trunk/src/modules/objects/triggers/EventMultiTrigger.h

    • Property svn:eol-style set to native
    r6864 r7163  
    4444    class _ObjectsExport EventMultiTrigger : public MultiTrigger
    4545    {
    46        
     46
    4747        public:
    4848            EventMultiTrigger(BaseObject* creator);

  • code/trunk/src/modules/objects/triggers/MultiTrigger.cc

    • Property svn:eol-style set to native
    r6864 r7163  
    4747    /*static*/ const std::string MultiTrigger::or_s = "or";
    4848    /*static*/ const std::string MultiTrigger::xor_s = "xor";
    49    
     49
    5050    CreateFactory(MultiTrigger);
    5151
    … …  
    6565        this->bSwitch_ = false;
    6666        this->bStayActive_ = false;
    67        
     67
    6868        this->remainingActivations_ = INF_s;
    6969        this->maxNumSimultaniousTriggerers_ = INF_s;
    … …  
    7575
    7676        this->parentTrigger_ = NULL;
    77        
     77
    7878        this->targetMask_.exclude(Class(BaseObject));
    7979
    8080        this->setSyncMode(0x0);
    8181    }
    82    
     82
    8383    /**
    8484    @brief
    … …  
    9595        }
    9696    }
    97    
     97
    9898    /**
    9999    @brief
    … …  
    117117        //TODO: Maybe nicer with explicit subgroup, e.g. triggers
    118118        XMLPortObject(MultiTrigger, MultiTrigger, "", addTrigger, getTrigger, xmlelement, mode);
    119        
     119
    120120        COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << ") created." << std::endl;
    121121    }
    122    
     122
    123123
    124124    /**
    … …  
    131131    {
    132132        // If this is the first tick.
    133         //TODO: Determine need for this, else kick it out. 
     133        //TODO: Determine need for this, else kick it out.
    134134        if(this->bFirstTick_)
    135135        {
    … …  
    174174                    delete state;
    175175                }
    176                
     176
    177177                queue->pop();
    178178            }
    … …  
    185185            MultiTriggerState* state;
    186186            float timeRemaining;
    187            
     187
    188188            // Go through all pending states.
    189189            for(int size = this->stateQueue_.size(); size >= 1; size--)
    … …  
    212212                                this->triggered_.erase(state->originator);
    213213                            }
    214                            
     214
    215215                            bStateChanged = true;
    216216                        }
    … …  
    229229
    230230                            bool bFire = true;
    231                            
     231
    232232                            // Add the originator to the objects activating this MultiTrigger.
    233233                            if(bActive == true)
    … …  
    266266                                else
    267267                                    this->fire(bActive, state->originator);
    268                                
     268
    269269                                bStateChanged = true;
    270270                            }
    … …  
    289289                        }
    290290                    }
    291                    
     291
    292292                    // Remove the state from the state queue.
    293293                    this->stateQueue_.pop_front();
    … …  
    509509            return returnVal;
    510510        }
    511        
     511
    512512        return true;
    513513    }
    514    
     514
    515515    /**
    516516    @brief
    … …  
    547547            return;
    548548        }
    549        
     549
    550550        MultiTriggerContainer* container = new MultiTriggerContainer(this, this, originator);
    551551        this->fireEvent(status, container);
    … …  
    563563    {
    564564        ClassTreeMask& targetMask = this->getTargetMask();
    565        
     565
    566566        for(ClassTreeMaskObjectIterator it = targetMask.begin(); it != targetMask.end(); ++it)
    567567        {
    … …  
    580580    {
    581581        assert(state);
    582        
     582
    583583        // If the originator is no target of this MultiTrigger.
    584584        if(!this->isTarget(state->originator))
    585585            return false;
    586        
     586
    587587        // Add it ot the state queue.
    588588        this->stateQueue_.push_back(std::pair<float, MultiTriggerState*>(this->delay_, state));

  • code/trunk/src/modules/objects/triggers/MultiTrigger.h

    • Property svn:eol-style set to native
    r6864 r7163  
    9494            MultiTrigger(BaseObject* creator); //!< Constructor. Registers the objects and initializes default values.
    9595            ~MultiTrigger(); //!< Destructor.
    96            
     96
    9797            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a MultiTrigger object through XML.
    9898            virtual void tick(float dt); //!< A method that is executed each tick.
    99            
     99
    100100            bool isActive(BaseObject* triggerer = NULL); //!< Get whether the MultiTrigger is active for a given object.
    101101
    … …  
    215215            void addTargets(const std::string& targets); //!< Add some target to the MultiTrigger.
    216216            void removeTargets(const std::string& targets); //!< Remove some target from the MultiTrigger.
    217            
     217
    218218            void addTrigger(MultiTrigger* trigger); //!< Adds a MultiTrigger as a sub-trigger to the trigger.
    219219            const MultiTrigger* getTrigger(unsigned int index) const; //!< Get the sub-trigger of this MultiTrigger at the given index.
    220            
     220
    221221        protected:
    222222            virtual std::queue<MultiTriggerState*>* letTrigger(void); //!< This method is called by the MultiTrigger to get information about new trigger events that need to be looked at.
    223223
    224224            void changeTriggered(BaseObject* originator = NULL); //!< This method can be called by any class inheriting from MultiTrigger to change it's triggered status for a specified originator.
    225            
     225
    226226            bool isModeTriggered(BaseObject* triggerer = NULL); //!< Checks whetherx the MultiTrigger is triggered concerning it's sub-triggers.
    227227            bool isTriggered(BaseObject* triggerer = NULL); //!< Get whether the MultiTrigger is triggered for a given object.
    … …  
    236236            inline void addParentTrigger(MultiTrigger* parent)
    237237                { this->parentTrigger_ = parent; }
    238            
     238
    239239            /**
    240240            @brief Get the target mask used to identify the targets of this MultiTrigger.
    … …  
    248248            //TODO: Check if something mus be done here.
    249249            virtual void notifyMaskUpdate(void) {}
    250            
     250
    251251        private:
    252252            static const int INF_s; //!< Magic number for infinity.
    … …  
    257257
    258258            void subTrigggerActivityChanged(BaseObject* originator); //!< This method is called by any sub-trigger to advertise changes in it's state to it's parent-trigger.
    259            
     259
    260260            bool addState(MultiTriggerState* state); //!< Helper method. Adds a state to the state queue, where the state will wait to become active.
    261            
     261
    262262            bool checkAnd(BaseObject* triggerer); //!< Checks whether the sub-triggers amount to true for the 'and' mode for a given object.
    263263            bool checkOr(BaseObject* triggerer); //!< Checks whether the sub-triggers amount to true for the 'or' mode for a given object.
    … …  
    276276            bool bSwitch_; //!< Bool for the switch-mode, if true the MultiTrigger behaves like a switch.
    277277            bool bStayActive_; //!< Bool for the stay-active-mode, if true the MultiTrigger stays active after its last activation.;
    278            
     278
    279279            int remainingActivations_; //!< The remaining activations of this MultiTrigger.
    280280            int maxNumSimultaniousTriggerers_; //!< The maximum number of objects simultaniously trigggering this MultiTrigger.
    … …  
    287287            MultiTrigger* parentTrigger_;
    288288            std::set<MultiTrigger*> subTriggers_; //!< The sub-triggers of this MultiTrigger.
    289            
     289
    290290            std::set<BaseObject*> active_; //!< The set of all objects the MultiTrigger is active for.
    291291            std::set<BaseObject*> triggered_; //!< The set of all objects the MultiTrigger is triggered for.
    292292
    293293            std::deque< std::pair<float, MultiTriggerState*> > stateQueue_; //!< The queue of states waiting to become active.
    294            
     294
    295295            ClassTreeMask targetMask_; //!< The target mask, masking all objects that can trigger this MultiTrigger.
    296            
     296
    297297    };
    298298

  • code/trunk/src/modules/objects/triggers/MultiTriggerContainer.cc

    • Property svn:eol-style set to native
    r6859 r7163  
    4040
    4141    CreateUnloadableFactory(MultiTriggerContainer);
    42    
     42
    4343    /**
    4444    @brief
    … …  
    7373    MultiTriggerContainer::~MultiTriggerContainer()
    7474    {
    75        
     75
    7676    }
    7777

  • code/trunk/src/modules/objects/triggers/MultiTriggerContainer.h

    • Property svn:eol-style set to native
    r6856 r7163  
    5050    class _ObjectsExport MultiTriggerContainer : public BaseObject
    5151    {
    52        
     52
    5353        public:
    5454            MultiTriggerContainer(BaseObject* creator); //!< Default constructor. Registers the object and creates an empty container.
    … …  
    6868            inline BaseObject* getData(void)
    6969                { return this->data_; }
    70            
     70
    7171        private:
    7272            MultiTrigger* originator_; //!< The originator.
    7373            BaseObject* data_; //!< The data.
    7474    };
    75    
     75
    7676}
    7777

  • code/trunk/src/modules/overlays/CMakeLists.txt

    r5781 r7163  
    1414  PCH_FILE
    1515    OverlaysPrecompiledHeaders.h
    16   DEFINE_SYMBOL
    17     "OVERLAYS_SHARED_BUILD"
    1816  LINK_LIBRARIES
    1917    orxonox

  • code/trunk/src/modules/overlays/GUIOverlay.cc

    r6799 r7163  
    3030
    3131#include <string>
    32 #include <sstream>
    3332
     33#include "util/Convert.h"
    3434#include "core/input/InputManager.h"
    3535#include "core/CoreIncludes.h"
    … …  
    7373        if (this->isVisible())
    7474        {
    75             std::ostringstream out;
    76             out << reinterpret_cast<long>(this);
    77             const std::string& str = out.str();
     75            const std::string& str = multi_cast<std::string>(reinterpret_cast<long>(this));
    7876            GUIManager::getInstance().showGUIExtra(this->guiName_, str);
    7977

  • code/trunk/src/modules/overlays/OverlaysPrereqs.h

    r5929 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(OVERLAYS_STATIC_BUILD)
    4646#  ifdef OVERLAYS_SHARED_BUILD
    4747#    define _OverlaysExport __declspec(dllexport)
    … …  
    7878    class ChatOverlay;
    7979    class DeathMessage;
     80    class GametypeFadingMessage;
     81    class GametypeStaticMessage;
    8082    class GametypeStatus;
    8183    class HUDBar;

  • code/trunk/src/modules/overlays/hud/CMakeLists.txt

    r5781 r7163  
    1313  UnderAttackHealthBar.cc
    1414  TeamBaseMatchScore.cc
     15  GametypeStaticMessage.cc
     16  GametypeFadingMessage.cc
    1517)

  • code/trunk/src/modules/overlays/hud/GametypeStatus.cc

    r5781 r7163  
    3030
    3131#include "util/Convert.h"
     32#include "core/ConsoleCommand.h"
    3233#include "core/CoreIncludes.h"
    3334#include "infos/GametypeInfo.h"
    … …  
    3940{
    4041    CreateFactory(GametypeStatus);
     42
     43    /*static*/ bool GametypeStatus::noCaption_s = false;
     44    SetConsoleCommand(GametypeStatus, setGametypeStatus, true);
    4145
    4246    GametypeStatus::GametypeStatus(BaseObject* creator) : OverlayText(creator)
    … …  
    5963            const GametypeInfo* gtinfo = this->owner_->getGametypeInfo();
    6064            ControllableEntity* ce = this->owner_->getControllableEntity();
     65
     66            if(GametypeStatus::noCaption_s) // No captions are displayed.
     67            {
     68                this->setCaption("");
     69                return;
     70            }
    6171
    6272            if (!gtinfo->hasStarted() && !gtinfo->isStartCountdownRunning())
    … …  
    8898        this->owner_ = orxonox_cast<PlayerInfo*>(this->getOwner());
    8999    }
     100
     101    /**
     102    @brief
     103        Sets whether the gametype status is displayed.
     104    @param bValue
     105        If true captions are displayed, if false, not.
     106    */
     107    /*static*/ void GametypeStatus::setGametypeStatus(bool bValue)
     108    {
     109        GametypeStatus::noCaption_s = !bValue;
     110    }
     111
    90112}

  • code/trunk/src/modules/overlays/hud/GametypeStatus.h

    r5781 r7163  
    4646            virtual void changedOwner();
    4747
     48            static void setGametypeStatus(bool bValue); //!< Toggles whether the gametype status is displayed.
     49
    4850        private:
    4951            PlayerInfo* owner_;
     52            static bool noCaption_s;
     53
    5054    };
    5155}

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

    r6502 r7163  
    2929#include "HUDNavigation.h"
    3030
    31 #include <string>
    3231#include <OgreCamera.h>
     32#include <OgreFontManager.h>
    3333#include <OgreOverlayManager.h>
    3434#include <OgreTextAreaOverlayElement.h>
    … …  
    4545#include "controllers/HumanController.h"
    4646#include "worldentities/pawns/Pawn.h"
     47#include "worldentities/WorldEntity.h"
     48#include "core/ConfigValueIncludes.h"
     49#include "tools/TextureGenerator.h"
     50// #include <boost/bind/bind_template.hpp>
     51
    4752
    4853namespace orxonox
    4954{
    50     CreateFactory(HUDNavigation);
    51 
    52     HUDNavigation::HUDNavigation(BaseObject* creator)
    53         : OrxonoxOverlay(creator)
    54     {
    55         RegisterObject(HUDNavigation);
    56 
    57         // create nav text
    58         navText_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
    59             .createOverlayElement("TextArea", "HUDNavigation_navText_" + getUniqueNumberString()));
    60 
    61         // create nav marker
    62         navMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
    63             .createOverlayElement("Panel", "HUDNavigation_navMarker_" + getUniqueNumberString()));
    64         navMarker_->setMaterialName("Orxonox/NavArrows");
    65 
    66 /*
    67         // create aim marker
    68         aimMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
    69             .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberString()));
    70         aimMarker_->setMaterialName("Orxonox/NavCrosshair");
    71         this->wasOutOfView_ = true; // Ensure the material is changed right the first time..
    72 
    73         setFont("Monofur");
    74         setTextSize(0.05f);
    75         setNavMarkerSize(0.05f);
    76         setAimMarkerSize(0.04f);
    77 */
    78 
    79         background_->addChild(navMarker_);
    80 //        background_->addChild(aimMarker_);
    81         background_->addChild(navText_);
    82 
    83         // hide at first
    84         this->setVisible(false);
    85     }
    86 
    87     HUDNavigation::~HUDNavigation()
    88     {
    89         if (this->isInitialized())
     55bool compareDistance ( std::pair<RadarViewable*, unsigned int > a, std::pair<RadarViewable*, unsigned int > b )
     56{
     57    return a.second<b.second;
     58
     59}
     60
     61void HUDNavigation::setConfigValues()
     62{
     63  SetConfigValue(markerLimit_, 3);
     64}
     65
     66CreateFactory ( HUDNavigation );
     67
     68HUDNavigation::HUDNavigation ( BaseObject* creator )
     69        : OrxonoxOverlay ( creator )
     70{
     71    RegisterObject ( HUDNavigation );
     72    this->setConfigValues();
     73
     74    // Set default values
     75    setFont ( "Monofur" );
     76    setTextSize ( 0.05f );
     77    setNavMarkerSize ( 0.05f );
     78}
     79
     80HUDNavigation::~HUDNavigation()
     81{
     82    if ( this->isInitialized() )
     83    {
     84        for ( ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); )
     85            removeObject ( ( it++ )->first );
     86
     87    }
     88
     89    sortedObjectList_.clear();
     90}
     91
     92void HUDNavigation::XMLPort ( Element& xmlElement, XMLPort::Mode mode )
     93{
     94    SUPER ( HUDNavigation, XMLPort, xmlElement, mode );
     95
     96    XMLPortParam ( HUDNavigation, "font",          setFont,          getFont,          xmlElement, mode );
     97    XMLPortParam ( HUDNavigation, "textSize",      setTextSize,      getTextSize,      xmlElement, mode );
     98    XMLPortParam ( HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlElement, mode );
     99}
     100
     101void HUDNavigation::setFont ( const std::string& font )
     102{
     103    const Ogre::ResourcePtr& fontPtr = Ogre::FontManager::getSingleton().getByName ( font );
     104    if ( fontPtr.isNull() )
     105    {
     106        COUT ( 2 ) << "Warning: HUDNavigation: Font '" << font << "' not found" << std::endl;
     107        return;
     108    }
     109    fontName_ = font;
     110    for ( ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it )
     111    {
     112        if ( it->second.text_ != NULL )
     113            it->second.text_->setFontName ( fontName_ );
     114    }
     115}
     116
     117const std::string& HUDNavigation::getFont() const
     118{
     119    return fontName_;
     120}
     121
     122void HUDNavigation::setTextSize ( float size )
     123{
     124    if ( size <= 0.0f )
     125    {
     126        COUT ( 2 ) << "Warning: HUDNavigation: Negative font size not allowed" << std::endl;
     127        return;
     128    }
     129    textSize_ = size;
     130    for ( ObjectMap::iterator it = activeObjectList_.begin(); it!=activeObjectList_.end(); ++it )
     131    {
     132        if ( it->second.text_ )
     133            it->second.text_->setCharHeight ( size );
     134    }
     135}
     136
     137float HUDNavigation::getTextSize() const
     138{
     139    return textSize_;
     140}
     141
     142
     143
     144void HUDNavigation::tick ( float dt )
     145{
     146    SUPER ( HUDNavigation, tick, dt );
     147
     148    Camera* cam = CameraManager::getInstance().getActiveCamera();
     149    if ( cam == NULL )
     150        return;
     151    const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
     152
     153
     154    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++listIt )
     155    {
     156        listIt->second = ( int ) ( ( listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition() ).length() + 0.5f );
     157    }
     158
     159    sortedObjectList_.sort ( compareDistance );
     160
     161    unsigned int markerCount_ = 0;
     162
     163//         for (ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it)
     164    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++markerCount_, ++listIt )
     165    {
     166        ObjectMap::iterator it = activeObjectList_.find ( listIt->first );
     167
     168        if ( markerCount_ < markerLimit_ )
    90169        {
    91             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navMarker_);
    92             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navText_);
    93 //            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->aimMarker_);
    94         }
    95     }
    96 
    97     void HUDNavigation::XMLPort(Element& xmlElement, XMLPort::Mode mode)
    98     {
    99         SUPER(HUDNavigation, XMLPort, xmlElement, mode);
    100 
    101         XMLPortParam(HUDNavigation, "font",     setFont,     getFont,     xmlElement, mode);
    102         XMLPortParam(HUDNavigation, "textSize", setTextSize, getTextSize, xmlElement, mode);
    103         XMLPortParam(HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlElement, mode);
    104 //        XMLPortParam(HUDNavigation, "aimMarkerSize", setAimMarkerSize, getAimMarkerSize, xmlElement, mode);
    105     }
    106 
    107     void HUDNavigation::setFont(const std::string& font)
    108     {
    109         if (this->navText_ && !font.empty())
    110             this->navText_->setFontName(font);
    111     }
    112 
    113     const std::string& HUDNavigation::getFont() const
    114     {
    115         if (this->navText_)
    116             return this->navText_->getFontName();
    117         else
    118             return BLANKSTRING;
    119     }
    120 
    121     void HUDNavigation::setTextSize(float size)
    122     {
    123         if (this->navText_ && size >= 0.0f)
    124             this->navText_->setCharHeight(size);
    125     }
    126 
    127     float HUDNavigation::getTextSize() const
    128     {
    129         if (this->navText_)
    130             return this->navText_->getCharHeight();
    131         else
    132             return 0.0f;
    133     }
    134 
    135     void HUDNavigation::tick(float dt)
    136     {
    137         SUPER(HUDNavigation, tick, dt);
    138 
    139         // Get radar
    140         Radar* radar = this->getOwner()->getScene()->getRadar();
    141 
    142         if (!radar->getFocus())
    143         {
    144             this->overlay_->hide();
    145             return;
    146         }
    147         else
    148         {
    149             this->overlay_->show();
    150         }
    151 
    152         // set text
    153         int dist = static_cast<int>(getDist2Focus());
    154         navText_->setCaption(multi_cast<std::string>(dist));
    155         float textLength = multi_cast<std::string>(dist).size() * navText_->getCharHeight() * 0.3f;
    156 
    157         orxonox::Camera* cam = CameraManager::getInstance().getActiveCamera();
    158         if (!cam)
    159             return;
    160         const Matrix4& transform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
    161         // transform to screen coordinates
    162         Vector3 pos = transform * radar->getFocus()->getRVWorldPosition();
    163 
    164         bool outOfView;
    165         if (pos.z > 1.0)
    166         {
    167             // z > 1.0 means that the object is behind the camera
    168             outOfView = true;
    169             // we have to switch all coordinates (if you don't know why,
    170             // try linear algebra lectures, because I can't explain..)
    171             pos.x = -pos.x;
    172             pos.y = -pos.y;
    173         }
    174         else
    175             outOfView = pos.x < -1.0 || pos.x > 1.0 || pos.y < -1.0 || pos.y > 1.0;
    176 
    177         if (outOfView)
    178         {
    179             // object is not in view
    180 //            aimMarker_->hide();
    181 
    182             if (!wasOutOfView_)
     170
     171
     172            // Get Distance to HumanController and save it in the TextAreaOverlayElement.
     173            int dist = listIt->second;
     174            it->second.text_->setCaption ( multi_cast<std::string> ( dist ) );
     175            float textLength = multi_cast<std::string> ( dist ).size() * it->second.text_->getCharHeight() * 0.3f;
     176
     177            // Transform to screen coordinates
     178            Vector3 pos = camTransform * it->first->getRVWorldPosition();
     179
     180            bool outOfView = true;
     181            if ( pos.z > 1.0 )
    183182            {
    184                 navMarker_->setMaterialName("Orxonox/NavArrows");
    185                 wasOutOfView_ = true;
     183                // z > 1.0 means that the object is behind the camera
     184                outOfView = true;
     185                // we have to switch all coordinates (if you don't know why,
     186                // try linear algebra lectures, because I can't explain..)
     187                pos.x = -pos.x;
     188                pos.y = -pos.y;
    186189            }
    187 
    188             if (pos.x < pos.y)
     190            else
     191                outOfView = pos.x < -1.0 || pos.x > 1.0 || pos.y < -1.0 || pos.y > 1.0;
     192            // Get Distance to HumanController and save it in the TextAreaOverlayElement.
     193            it->second.text_->setCaption ( multi_cast<std::string> ( dist ) );
     194
     195            if ( outOfView )
    189196            {
    190                 if (pos.y > -pos.x)
     197                // Object is not in view
     198
     199                // Change material only if outOfView changed
     200                if ( !it->second.wasOutOfView_ )
    191201                {
    192                     // up
    193                     float position = pos.x / pos.y + 1.0f;
    194                     navMarker_->setPosition((position - navMarker_->getWidth()) * 0.5f, 0.0f);
    195                     navMarker_->setUV(0.5f, 0.0f, 1.0f, 0.5f);
    196                     navText_->setLeft((position - textLength) * 0.5f);
    197                     navText_->setTop(navMarker_->getHeight());
     202                    it->second.panel_->setMaterialName( TextureGenerator::getMaterialName( "arrows.tga", it->first->getRadarObjectColour()) );
     203                    it->second.wasOutOfView_ = true;
    198204                }
     205
     206                // Switch between top, bottom, left and right position of the arrow at the screen border
     207                if ( pos.x < pos.y )
     208                {
     209                    if ( pos.y > -pos.x )
     210                    {
     211                        // Top
     212                        float position = pos.x / pos.y + 1.0f;
     213                        it->second.panel_->setPosition ( ( position - it->second.panel_->getWidth() ) * 0.5f, 0.0f );
     214                        it->second.panel_->setUV ( 0.5f, 0.0f, 1.0f, 0.5f );
     215                        it->second.text_->setLeft ( ( position - textLength ) * 0.5f );
     216                        it->second.text_->setTop ( it->second.panel_->getHeight() );
     217                    }
     218                    else
     219                    {
     220                        // Left
     221                        float position = pos.y / pos.x + 1.0f;
     222                        it->second.panel_->setPosition ( 0.0f, ( position - it->second.panel_->getWidth() ) * 0.5f );
     223                        it->second.panel_->setUV ( 0.0f, 0.0f, 0.5f, 0.5f );
     224                        it->second.text_->setLeft ( it->second.panel_->getWidth() + 0.01f );
     225                        it->second.text_->setTop ( ( position - it->second.text_->getCharHeight() ) * 0.5f );
     226                    }
     227                }
     228
    199229                else
    200230                {
    201                     // left
    202                     float position = pos.y / pos.x + 1.0f;
    203                     navMarker_->setPosition(0.0f, (position - navMarker_->getWidth()) * 0.5f);
    204                     navMarker_->setUV(0.0f, 0.0f, 0.5f, 0.5f);
    205                     navText_->setLeft(navMarker_->getWidth() + 0.01f);
    206                     navText_->setTop((position - navText_->getCharHeight()) * 0.5f);
     231
     232                    if ( pos.y < -pos.x )
     233                    {
     234                        // Bottom
     235                        float position = -pos.x / pos.y + 1.0f;
     236                        it->second.panel_->setPosition ( ( position - it->second.panel_->getWidth() ) * 0.5f, 1.0f - it->second.panel_->getHeight() );
     237                        it->second.panel_->setUV ( 0.0f, 0.5f, 0.5f, 1.0f );
     238                        it->second.text_->setLeft ( ( position - textLength ) * 0.5f );
     239                        it->second.text_->setTop ( 1.0f - it->second.panel_->getHeight() - it->second.text_->getCharHeight() );
     240                    }
     241                    else
     242                    {
     243                        // Right
     244                        float position = -pos.y / pos.x + 1.0f;
     245                        it->second.panel_->setPosition ( 1.0f - it->second.panel_->getWidth(), ( position - it->second.panel_->getHeight() ) * 0.5f );
     246                        it->second.panel_->setUV ( 0.5f, 0.5f, 1.0f, 1.0f );
     247                        it->second.text_->setLeft ( 1.0f - it->second.panel_->getWidth() - textLength - 0.01f );
     248                        it->second.text_->setTop ( ( position - it->second.text_->getCharHeight() ) * 0.5f );
     249                    }
    207250                }
    208251            }
    209252            else
    210253            {
    211                 if (pos.y < -pos.x)
     254                // Object is in view
     255
     256                // Change material only if outOfView changed
     257                if ( it->second.wasOutOfView_ )
    212258                {
    213                     // down
    214                     float position = -pos.x / pos.y + 1.0f;
    215                     navMarker_->setPosition((position - navMarker_->getWidth()) * 0.5f, 1.0f - navMarker_->getHeight());
    216                     navMarker_->setUV(0.0f, 0.5f, 0.5f, 1.0f);
    217                     navText_->setLeft((position - textLength) * 0.5f);
    218                     navText_->setTop(1.0f - navMarker_->getHeight() - navText_->getCharHeight());
     259                  //it->second.panel_->setMaterialName ( "Orxonox/NavTDC" );
     260                    it->second.panel_->setMaterialName( TextureGenerator::getMaterialName( "tdc.tga", it->first->getRadarObjectColour()) );
     261                    it->second.wasOutOfView_ = false;
    219262                }
    220                 else
    221                 {
    222                     // right
    223                     float position = -pos.y / pos.x + 1.0f;
    224                     navMarker_->setPosition(1.0f - navMarker_->getWidth(), (position - navMarker_->getHeight()) * 0.5f);
    225                     navMarker_->setUV(0.5f, 0.5f, 1.0f, 1.0f);
    226                     navText_->setLeft(1.0f - navMarker_->getWidth() - textLength - 0.01f);
    227                     navText_->setTop((position - navText_->getCharHeight()) * 0.5f);
    228                 }
     263
     264                // Position marker
     265                it->second.panel_->setUV ( 0.0f, 0.0f, 1.0f, 1.0f );
     266                it->second.panel_->setLeft ( ( pos.x + 1.0f - it->second.panel_->getWidth() ) * 0.5f );
     267                it->second.panel_->setTop ( ( -pos.y + 1.0f - it->second.panel_->getHeight() ) * 0.5f );
     268
     269                // Position text
     270                it->second.text_->setLeft ( ( pos.x + 1.0f + it->second.panel_->getWidth() ) * 0.5f );
     271                it->second.text_->setTop ( ( -pos.y + 1.0f + it->second.panel_->getHeight() ) * 0.5f );
    229272            }
     273
     274            // Make sure the overlays are shown
     275            it->second.panel_->show();
     276            it->second.text_->show();
    230277        }
    231278        else
    232279        {
    233             // object is in view
    234 /*
    235             Vector3 aimpos = transform * getPredictedPosition(SpaceShip::getLocalShip()->getPosition(),
    236                     Projectile::getSpeed(), Radar::getInstance().getFocus()->getRVWorldPosition(), Radar::getInstance().getFocus()->getRVOrientedVelocity());
     280            it->second.panel_->hide();
     281            it->second.text_->hide();
     282        }
     283
     284    }
     285}
     286
     287
     288/** Overridden method of OrxonoxOverlay.
     289@details
     290    Usually the entire overlay scales with scale().
     291    Here we obviously have to adjust this.
    237292*/
    238             if (wasOutOfView_)
    239             {
    240                 navMarker_->setMaterialName("Orxonox/NavTDC");
    241                 wasOutOfView_ = false;
    242             }
    243 
    244             // object is in view
    245             navMarker_->setUV(0.0f, 0.0f, 1.0f, 1.0f);
    246             navMarker_->setLeft((pos.x + 1.0f - navMarker_->getWidth()) * 0.5f);
    247             navMarker_->setTop((-pos.y + 1.0f - navMarker_->getHeight()) * 0.5f);
    248 
    249 /*
    250             aimMarker_->show();
    251             aimMarker_->setLeft((aimpos.x + 1.0f - aimMarker_->getWidth()) * 0.5f);
    252             aimMarker_->setTop((-aimpos.y + 1.0f - aimMarker_->getHeight()) * 0.5f);
    253 */
    254             navText_->setLeft((pos.x + 1.0f + navMarker_->getWidth()) * 0.5f);
    255             navText_->setTop((-pos.y + 1.0f + navMarker_->getHeight()) * 0.5f);
     293void HUDNavigation::sizeChanged()
     294{
     295    // Use size to compensate for aspect ratio if enabled.
     296    float xScale = this->getActualSize().x;
     297    float yScale = this->getActualSize().y;
     298
     299    for ( ObjectMap::iterator it = activeObjectList_.begin(); it!=activeObjectList_.end(); ++it )
     300    {
     301        if ( it->second.panel_ != NULL )
     302            it->second.panel_->setDimensions ( navMarkerSize_ * xScale, navMarkerSize_ * yScale );
     303        if ( it->second.text_ != NULL )
     304            it->second.text_->setCharHeight ( it->second.text_->getCharHeight() * yScale );
     305    }
     306}
     307
     308void HUDNavigation::addObject ( RadarViewable* object )
     309{
     310    if( showObject(object)==false )
     311        return;
     312
     313    if ( activeObjectList_.size() >= markerLimit_ )
     314        if ( object == NULL )
     315            return;
     316
     317    // Object hasn't been added yet (we know that)
     318    assert ( this->activeObjectList_.find ( object ) == this->activeObjectList_.end() );
     319
     320    // Scales used for dimensions and text size
     321    float xScale = this->getActualSize().x;
     322    float yScale = this->getActualSize().y;
     323
     324    // Create everything needed to display the object on the radar and add it to the map
     325
     326    // Create arrow/marker
     327    Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*> ( Ogre::OverlayManager::getSingleton()
     328                                       .createOverlayElement ( "Panel", "HUDNavigation_navMarker_" + getUniqueNumberString() ) );
     329//     panel->setMaterialName ( "Orxonox/NavTDC" );
     330    panel->setMaterialName( TextureGenerator::getMaterialName( "tdc.tga", object->getRadarObjectColour()) );
     331    panel->setDimensions ( navMarkerSize_ * xScale, navMarkerSize_ * yScale );
     332//     panel->setColour( object->getRadarObjectColour() );
     333
     334    Ogre::TextAreaOverlayElement* text = static_cast<Ogre::TextAreaOverlayElement*> ( Ogre::OverlayManager::getSingleton()
     335                                         .createOverlayElement ( "TextArea", "HUDNavigation_navText_" + getUniqueNumberString() ) );
     336    text->setFontName ( this->fontName_ );
     337    text->setCharHeight ( text->getCharHeight() * yScale );
     338    text->setColour( object->getRadarObjectColour() );
     339
     340    panel->hide();
     341    text->hide();
     342
     343    ObjectInfo tempStruct = {panel, text, false};
     344    activeObjectList_[object] = tempStruct;
     345
     346    this->background_->addChild ( panel );
     347    this->background_->addChild ( text );
     348
     349    sortedObjectList_.push_front ( std::make_pair ( object, ( unsigned int ) 0 ) );
     350
     351
     352}
     353
     354void HUDNavigation::removeObject ( RadarViewable* viewable )
     355{
     356    ObjectMap::iterator it = activeObjectList_.find ( viewable );
     357
     358    if ( activeObjectList_.find ( viewable ) != activeObjectList_.end() )
     359    {
     360        // Detach overlays
     361        this->background_->removeChild ( it->second.panel_->getName() );
     362        this->background_->removeChild ( it->second.text_->getName() );
     363        // Properly destroy the overlay elements (do not use delete!)
     364        Ogre::OverlayManager::getSingleton().destroyOverlayElement ( it->second.panel_ );
     365        Ogre::OverlayManager::getSingleton().destroyOverlayElement ( it->second.text_ );
     366        // Remove from the list
     367        activeObjectList_.erase ( viewable );
     368
     369
     370    }
     371
     372    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++listIt )
     373    {
     374        if ( (listIt->first) == viewable )
     375        {
     376            sortedObjectList_.erase ( listIt );
     377            break;
    256378        }
    257     }
    258 
    259     float HUDNavigation::getDist2Focus() const
    260     {
    261         Radar* radar = this->getOwner()->getScene()->getRadar();
    262         if (radar->getFocus() && HumanController::getLocalControllerEntityAsPawn())
    263             return (radar->getFocus()->getRVWorldPosition() - HumanController::getLocalControllerEntityAsPawn()->getWorldPosition()).length();
    264         else
    265             return 0;
    266     }
    267 
    268     /**
    269     @brief Overridden method of OrxonoxOverlay. Usually the entire overlay
    270            scales with scale(). Here we obviously have to adjust this.
    271     */
    272     void HUDNavigation::sizeChanged()
    273     {
    274         // use size to compensate for aspect ratio if enabled.
    275         float xScale = this->getActualSize().x;
    276         float yScale = this->getActualSize().y;
    277         if (this->navMarker_)
    278             navMarker_->setDimensions(navMarkerSize_ * xScale, navMarkerSize_ * yScale);
    279 /*
    280         if (this->aimMarker_)
    281             aimMarker_->setDimensions(aimMarkerSize_ * xScale, aimMarkerSize_ * yScale);
    282 */
    283         if (this->navText_)
    284             navText_->setCharHeight(navText_->getCharHeight() * yScale);
    285     }
    286 }
     379
     380    }
     381
     382}
     383
     384void HUDNavigation::objectChanged(RadarViewable* viewable)
     385{
     386    // TODO: niceification neccessary ;)
     387    removeObject(viewable);
     388    addObject(viewable);
     389}
     390
     391
     392bool HUDNavigation::showObject(RadarViewable* rv)
     393{
     394    if ( rv == dynamic_cast<RadarViewable*> ( this->getOwner() ) )
     395        return false;
     396    assert( rv->getWorldEntity() );
     397    if ( rv->getWorldEntity()->isVisible()==false || rv->getRadarVisibility()==false )
     398        return false;
     399    return true;
     400}
     401
     402void HUDNavigation::changedOwner()
     403{
     404
     405    const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
     406    for ( std::set<RadarViewable*>::const_iterator it = respawnObjects.begin(); it != respawnObjects.end(); ++it )
     407    {
     408        if ( ! ( *it )->isHumanShip_ )
     409            this->addObject ( *it );
     410    }
     411}
     412}

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

    r6417 r7163  
    3232#include "overlays/OverlaysPrereqs.h"
    3333
     34#include <map>
     35#include <string>
     36
     37
    3438#include "util/OgreForwardRefs.h"
    3539#include "tools/interfaces/Tickable.h"
     40#include "interfaces/RadarListener.h"
    3641#include "overlays/OrxonoxOverlay.h"
    3742
    3843namespace orxonox
    3944{
    40     class _OverlaysExport HUDNavigation : public OrxonoxOverlay, public Tickable
     45class _OverlaysExport HUDNavigation : public OrxonoxOverlay, public Tickable, public RadarListener
     46{
     47public:
     48    HUDNavigation ( BaseObject* creator );
     49    virtual ~HUDNavigation();
     50
     51    void setConfigValues();
     52
     53    virtual void XMLPort ( Element& xmlElement, XMLPort::Mode mode );
     54    virtual void tick ( float dt );
     55
     56    virtual void addObject ( RadarViewable* object );
     57    virtual void removeObject ( RadarViewable* viewable );
     58    virtual void objectChanged ( RadarViewable* viewable );
     59
     60    virtual void changedOwner();
     61    virtual void sizeChanged();
     62    virtual void angleChanged() { }
     63    virtual void positionChanged() { }
     64    virtual void radarTick ( float dt ) {}
     65
     66    inline float getRadarSensitivity() const
     67    { return 1.0f; }
     68
     69private:
     70    struct ObjectInfo
    4171    {
    42     public:
    43         HUDNavigation(BaseObject* creator);
    44         virtual ~HUDNavigation();
     72        Ogre::PanelOverlayElement* panel_;
     73        Ogre::TextAreaOverlayElement* text_;
     74        bool outOfView_;
     75        bool wasOutOfView_;
    4576
    46         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    47         virtual void tick(float dt);
     77    };
    4878
    49     private:
    50         void sizeChanged();
    51         void angleChanged() { }
    52         void positionChanged() { }
     79    bool showObject( RadarViewable* rv );
    5380
    54         // XMLPort accessors
    55         void setNavMarkerSize(float size) { this->navMarkerSize_ = size; this->sizeChanged(); }
    56         float getNavMarkerSize() const    { return this->navMarkerSize_; }
     81    // XMLPort accessors
     82    void setNavMarkerSize ( float size )
     83    { navMarkerSize_ = size; this->sizeChanged(); }
     84    float getNavMarkerSize() const
     85    { return navMarkerSize_; }
    5786
    58 /*
    59         void setAimMarkerSize(float size) { this->aimMarkerSize_ = size; this->sizeChanged(); }
    60         float getAimMarkerSize() const    { return this->aimMarkerSize_; }
    61 */
     87    void setTextSize ( float size );
     88    float getTextSize() const;
    6289
    63         void setTextSize(float size);
    64         float getTextSize() const;
     90    void setFont ( const std::string& font );
     91    const std::string& getFont() const;
    6592
    66         void setFont(const std::string& font);
    67         const std::string& getFont() const;
     93    typedef std::map<RadarViewable*, ObjectInfo > ObjectMap;
     94    ObjectMap activeObjectList_;
    6895
    69         void updateMarker();
    70         void updateFocus();
    71         float getDist2Focus() const;
     96    typedef std::list < std::pair<RadarViewable*, unsigned int > > sortedList;
     97    sortedList sortedObjectList_;
    7298
    73         Ogre::PanelOverlayElement* navMarker_;      //!< the panel used to show the arrow and the target marker
    74         float navMarkerSize_;                       //!< One paramter size of the navigation marker
    75 /*
    76         Ogre::PanelOverlayElement* aimMarker_;      //!< Panel used to show the aim Marker
    77         float aimMarkerSize_;                       //!< One paramter size of the aim marker
    78 */
    79         Ogre::TextAreaOverlayElement* navText_;     //!< Text overlay to display the target distance
    80         bool wasOutOfView_;                         //!< Performance booster variable: setMaterial is not cheap
    81     };
     99
     100    float navMarkerSize_;
     101    std::string fontName_;
     102    float textSize_;
     103
     104    unsigned int markerLimit_;; //TODO: is it possible to set this over the console and/or the IG-Setting
     105
     106
     107};
    82108}
    83109

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

    r6502 r7163  
    4040#include "worldentities/WorldEntity.h"
    4141#include "worldentities/pawns/Pawn.h"
     42#include "Scene.h"
     43#include "Radar.h"
    4244
    4345namespace orxonox
    … …  
    7274        {
    7375            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
    74             for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
    75                 it != this->radarDots_.end(); ++it)
     76            for (std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it = this->radarObjects_.begin();
     77                it != this->radarObjects_.end(); ++it)
    7678            {
    77                 Ogre::OverlayManager::getSingleton().destroyOverlayElement(*it);
     79                Ogre::OverlayManager::getSingleton().destroyOverlayElement(it->second);
    7880            }
    7981        }
    … …  
    8991    }
    9092
    91     void HUDRadar::displayObject(RadarViewable* object, bool bIsMarked)
     93    void HUDRadar::addObject(RadarViewable* object)
    9294    {
    93         if (object == static_cast<RadarViewable*>(this->owner_))
     95        if (object == dynamic_cast<RadarViewable*>(this->owner_))
    9496            return;
    9597
    96         const WorldEntity* wePointer = object->getWorldEntity();
     98        // Make sure the object hasn't been added yet
     99        assert( this->radarObjects_.find(object) == this->radarObjects_.end() );
    97100
    98         // Just to be sure that we actually have a WorldEntity.
    99         // We could do a dynamic_cast, but that would be a lot slower.
    100         if (!wePointer || !this->owner_)
     101        // Create everything needed to display the object on the radar and add it to the map
     102        Ogre::PanelOverlayElement* panel;
     103        panel = static_cast<Ogre::PanelOverlayElement*>(
     104            Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberString()));
     105        this->overlay_->add2D(panel);
     106        // get right material
     107        panel->setMaterialName(TextureGenerator::getMaterialName(
     108            shapeMaterials_[object->getRadarObjectShape()], object->getRadarObjectColour()));
     109        this->radarObjects_[object] = panel;
     110    }
     111
     112    void HUDRadar::removeObject(RadarViewable* object)
     113    {
     114        // If object was added at all then remove it
     115        std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it;
     116        it = this->radarObjects_.find( object );
     117        if( it != this->radarObjects_.end() )
    101118        {
    102             if (!wePointer)
    103                 CCOUT(2) << "Cannot display a non-WorldEntitiy on the radar" << std::endl;
    104             if (!this->owner_)
    105                 CCOUT(2) << "No owner defined" << std::endl;
     119            Ogre::OverlayManager::getSingleton().destroyOverlayElement(it->second);
     120            this->radarObjects_.erase(it);
     121        }
     122    }
     123
     124    void HUDRadar::objectChanged( RadarViewable* rv )
     125    {
     126        if (rv == dynamic_cast<RadarViewable*>(this->owner_))
    106127            return;
    107         }
     128        assert( this->radarObjects_.find(rv) != this->radarObjects_.end() );
     129        Ogre::PanelOverlayElement* panel = this->radarObjects_[rv];
     130        panel->setMaterialName(TextureGenerator::getMaterialName(
     131            shapeMaterials_[rv->getRadarObjectShape()], rv->getRadarObjectColour()));
     132    }
    108133
    109         // try to find a panel already created
    110         Ogre::PanelOverlayElement* panel;
    111         //std::map<RadarViewable*, Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.find(object);
    112         if (itRadarDots_ == this->radarDots_.end())
    113         {
    114             // we have to create a new entry
    115             panel = static_cast<Ogre::PanelOverlayElement*>(
    116                 Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberString()));
    117             radarDots_.push_back(panel);
    118             // get right material
    119             panel->setMaterialName(TextureGenerator::getMaterialName(
    120                 shapeMaterials_[object->getRadarObjectShape()], object->getRadarObjectColour()));
    121             this->overlay_->add2D(panel);
    122             this->itRadarDots_ = this->radarDots_.end();
    123         }
    124         else
    125         {
    126             panel = *itRadarDots_;
    127             ++itRadarDots_;
    128             const std::string& materialName = TextureGenerator::getMaterialName(
    129                 shapeMaterials_[object->getRadarObjectShape()], object->getRadarObjectColour());
    130             if (materialName != panel->getMaterialName())
    131                 panel->setMaterialName(materialName);
    132         }
    133         panel->show();
    134 
    135         // set size to fit distance...
    136         float distance = (wePointer->getWorldPosition() - this->owner_->getPosition()).length();
    137         // calculate the size with 1/distance dependency for simplicity (instead of exp(-distance * lambda)
    138         float size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance);
    139         panel->setDimensions(size, size);
    140 
    141         // calc position on radar...
    142         Vector2 coord = get2DViewcoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
    143         coord *= Ogre::Math::PI / 3.5f; // small adjustment to make it fit the texture
    144         panel->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
    145 
    146         if (bIsMarked)
    147         {
    148             this->marker_->show();
    149             this->marker_->setDimensions(size * 1.5f, size * 1.5f);
    150             this->marker_->setPosition((1.0f + coord.x - size * 1.5f) * 0.5f, (1.0f - coord.y - size * 1.5f) * 0.5f);
    151         }
     134    void HUDRadar::gatherObjects()
     135    {
     136        const std::set<RadarViewable*>& objectSet = this->getCreator()->getScene()->getRadar()->getRadarObjects();
     137        std::set<RadarViewable*>::const_iterator it;
     138        for( it=objectSet.begin(); it!=objectSet.end(); ++it )
     139            this->addObject(*it);
    152140    }
    153141
    154142    void HUDRadar::radarTick(float dt)
    155143    {
    156         for (itRadarDots_ = radarDots_.begin(); itRadarDots_ != radarDots_.end(); ++itRadarDots_)
    157             (*itRadarDots_)->hide();
    158         this->itRadarDots_ = this->radarDots_.begin();
    159         this->marker_->hide();
     144        // Make sure the owner of the radar was defined
     145        if( !this->owner_ )
     146        {
     147            CCOUT(0) << "No owner defined" << std::endl;
     148            assert(0);
     149        }
     150
     151        this->marker_->hide();      // in case that no object is in focus
     152        // get the focus object
     153        Radar* radar = this->getOwner()->getScene()->getRadar();
     154        const RadarViewable* focusObject = radar->getFocus();
     155
     156        // update the distances for all objects
     157        std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it;
     158        for( it = this->radarObjects_.begin(); it != this->radarObjects_.end(); ++it )
     159        {
     160            // Make sure the object really is a WorldEntity
     161            const WorldEntity* wePointer = it->first->getWorldEntity();
     162            if( !wePointer )
     163            {
     164                CCOUT(0) << "Cannot display a non-WorldEntitiy on the radar" << std::endl;
     165                assert(0);
     166            }
     167            bool isFocus = (it->first == focusObject);
     168            // set size to fit distance...
     169            float distance = (wePointer->getWorldPosition() - this->owner_->getPosition()).length();
     170            // calculate the size with 1/distance dependency for simplicity (instead of exp(-distance * lambda)
     171            float size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance);
     172            it->second->setDimensions(size, size);
     173
     174            // calc position on radar...
     175            Vector2 coord = get2DViewcoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
     176            coord *= Ogre::Math::PI / 3.5f; // small adjustment to make it fit the texture
     177            it->second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
     178            it->second->show();
     179
     180            // if this object is in focus, then set the focus marker
     181            if (isFocus)
     182            {
     183                this->marker_->setDimensions(size * 1.5f, size * 1.5f);
     184                this->marker_->setPosition((1.0f + coord.x - size * 1.5f) * 0.5f, (1.0f - coord.y - size * 1.5f) * 0.5f);
     185                this->marker_->show();
     186            }
     187        }
    160188    }
    161189
    162190    void HUDRadar::changedOwner()
    163191    {
    164         SUPER(HUDRadar, changedOwner);
     192    SUPER(HUDRadar, changedOwner);
    165193
    166         this->owner_ = orxonox_cast<Pawn*>(this->getOwner());
    167     }
     194    this->owner_ = orxonox_cast<Pawn*>(this->getOwner());
     195    assert(this->radarObjects_.size()==0);
     196    this->gatherObjects();
    168197}
     198}

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

    r5781 r7163  
    6565
    6666        // RadarListener interface
    67         void displayObject(RadarViewable* viewable, bool bIsMarked);
     67        virtual void addObject(RadarViewable* viewable);
     68        virtual void removeObject(RadarViewable* viewable);
     69        virtual void objectChanged( RadarViewable* rv );
    6870        void radarTick(float dt);
     71
     72        void gatherObjects();
    6973
    7074        std::map<RadarViewable::Shape, std::string> shapeMaterials_;
    7175
    72         std::vector<Ogre::PanelOverlayElement*> radarDots_;
    73         std::vector<Ogre::PanelOverlayElement*>::iterator itRadarDots_;
     76//         std::vector<Ogre::PanelOverlayElement*> radarDots_;
     77//         std::vector<Ogre::PanelOverlayElement*>::iterator itRadarDots_;
     78        std::map<RadarViewable*, Ogre::PanelOverlayElement*> radarObjects_;
    7479        Ogre::PanelOverlayElement* marker_;
    7580

  • code/trunk/src/modules/pickup/CMakeLists.txt

    r6711 r7163  
    11SET_SOURCE_FILES(PICKUP_SRC_FILES
     2  CollectiblePickup.cc
    23  DroppedPickup.cc
    34  Pickup.cc
    … …  
    1718    PickupManager.h
    1819    PickupRepresentation.h
    19   DEFINE_SYMBOL
    20     "PICKUP_SHARED_BUILD"
    2120  PCH_FILE
    2221    PickupPrecompiledHeaders.h

  • code/trunk/src/modules/pickup/DroppedPickup.cc

    r6540 r7163  
    4141namespace orxonox
    4242{
    43    
     43
    4444    CreateFactory(DroppedPickup);
    45    
     45
    4646    /**
    4747    @brief
    … …  
    5151    {
    5252        RegisterObject(DroppedPickup);
    53        
     53
    5454    }
    5555
    … …  
    6767    */
    6868    DroppedPickup::DroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance) : PickupSpawner(creator, pickup, triggerDistance, 5, 1)
    69     {   
     69    {
    7070        RegisterObject(DroppedPickup);
    7171
    7272        this->setPosition(carrier->getCarrierPosition());
    7373        this->setActive(false);
    74        
     74
    7575        //TODO: Do more elegantly.
    7676        this->startRespawnTimer();

  • code/trunk/src/modules/pickup/DroppedPickup.h

    r6540 r7163  
    4141namespace orxonox
    4242{
    43    
     43
    4444    /**
    4545    @brief

  • code/trunk/src/modules/pickup/Pickup.cc

    • Property svn:eol-style set to native
    r6709 r7163  
    4848    /*static*/ const std::string Pickup::durationTypeOnce_s = "once";
    4949    /*static*/ const std::string Pickup::durationTypeContinuous_s = "continuous";
     50
     51    CreateUnloadableFactory(Pickup);
    5052
    5153    Pickup::Pickup(BaseObject* creator) : BaseObject(creator)
    … …  
    146148    void Pickup::setActivationType(const std::string& type)
    147149    {
    148         if(type == activationTypeImmediate_s)
     150        if(Pickup::activationTypeImmediate_s.compare(type) == 0)
    149151        {
    150152            this->activationType_ = pickupActivationType::immediate;
    151153        }
    152         else if(type == activationTypeOnUse_s)
     154        else if(Pickup::activationTypeOnUse_s.compare(type) == 0)
    153155        {
    154156            this->activationType_ = pickupActivationType::onUse;
    … …  
    168170    void Pickup::setDurationType(const std::string& type)
    169171    {
    170         if(type == durationTypeOnce_s)
     172        if(Pickup::durationTypeOnce_s.compare(type) == 0)
    171173        {
    172174            this->durationType_ = pickupDurationType::once;
    173175        }
    174         else if(type == durationTypeContinuous_s)
     176        else if(Pickup::durationTypeContinuous_s.compare(type) == 0)
    175177        {
    176178            this->durationType_ = pickupDurationType::continuous;
    … …  
    192194
    193195        //! Sets the Pickup to used if the Pickup has activation type 'immediate' and gets picked up.
    194         if(this->getCarrier() != NULL && this->isPickedUp() && this->isImmediate())
     196        if(this->isPickedUp() && this->isImmediate())
    195197        {
    196198            this->setUsed(true);

  • code/trunk/src/modules/pickup/Pickup.h

    • Property svn:eol-style set to native
    r6728 r7163  
    4040#include "core/XMLPort.h"
    4141
    42 #include "interfaces/Pickupable.h"
     42#include "CollectiblePickup.h"
    4343
    4444#include "tools/Timer.h"
    … …  
    7474        Damian 'Mozork' Frick
    7575    */
    76     class _PickupExport Pickup : public Pickupable, public BaseObject
     76    class _PickupExport Pickup : public CollectiblePickup, public BaseObject
    7777    {
    7878
    79         protected:
     79        public:
    8080            Pickup(BaseObject* creator); //!< Constructor.
    81 
    82         public:
    8381            virtual ~Pickup(); //!< Destructor.
    8482
    … …  
    167165        private:
    168166            void initialize(void); //!< Initializes the member variables.
    169            
     167
    170168            //TODO: Problems, when there are more Timers needed? Solutions?
    171169            Timer durationTimer_; //!< Timer at the disposal of each Class implementing Pickup.

  • code/trunk/src/modules/pickup/PickupCollection.cc

    r6901 r7163  
    3535#include "core/XMLPort.h"
    3636#include "interfaces/PickupCarrier.h"
     37#include "CollectiblePickup.h"
    3738#include "DroppedPickup.h"
    3839#include "PickupCollectionIdentifier.h"
    … …  
    4243namespace orxonox
    4344{
    44  
     45
    4546    CreateFactory(PickupCollection);
    4647
    … …  
    5253    {
    5354        RegisterObject(PickupCollection);
    54        
     55
    5556        this->pickupCollectionIdentifier_ = new PickupCollectionIdentifier(this);
    56     }
    57    
     57        this->usedCounter_ = 0;
     58        this->pickedUpCounter_ = 0;
     59        this->disabledCounter_ = 0;
     60        this->processingUsed_ = false;
     61        this->processingPickedUp_ = false;
     62    }
     63
    5864    /**
    5965    @brief
    … …  
    6268    PickupCollection::~PickupCollection()
    6369    {
    64         //! Destroy all Pickupables constructing this PickupCollection.
    65         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    66         {
    67             if((*it).get() != NULL)
    68                 (*it).get()->destroy();
    69         }
    70     }
    71    
     70        // Destroy all Pickupables constructing this PickupCollection.
     71        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     72        {
     73            (*it)->removeFromCollection();
     74            (*it)->destroy();
     75        }
     76        this->pickups_.clear();
     77    }
     78
    7279    /**
    7380    @brief
    … …  
    7784    {
    7885        SUPER(PickupCollection, XMLPort, xmlelement, mode);
    79        
    80         XMLPortObject(PickupCollection, Pickupable, "pickupables", addPickupable, getPickupable, xmlelement, mode);
    81        
     86
     87        XMLPortObject(PickupCollection, CollectiblePickup, "pickupables", addPickupable, getPickupable, xmlelement, mode);
     88
    8289        this->initializeIdentifier();
    8390    }
    84    
     91
    8592    /**
    8693    @brief
    … …  
    8996    void PickupCollection::initializeIdentifier(void)
    9097    {
    91         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    92         {
    93             this->pickupCollectionIdentifier_->addPickup((*it).get()->getPickupIdentifier());
    94         }
    95     }
    96    
     98        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     99        {
     100            this->pickupCollectionIdentifier_->addPickup((*it)->getPickupIdentifier());
     101        }
     102    }
     103
    97104    /**
    98105    @brief
    … …  
    103110    {
    104111        SUPER(PickupCollection, changedUsed);
    105        
    106         //! Change used for all Pickupables this PickupCollection consists of.
    107         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    108         {
    109             (*it).get()->setUsed(this->isUsed());
    110         }
    111     }
    112    
     112
     113        this->processingUsed_ = true;
     114        // Change used for all Pickupables this PickupCollection consists of.
     115        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     116        {
     117            (*it)->setUsed(this->isUsed());
     118        }
     119        this->processingUsed_ = false;
     120
     121        this->changedUsedAction();
     122    }
     123
     124    /**
     125    @brief
     126        Helper method.
     127        Checks whether due to changes in the used status of the pickups of this PickupCollection the used status of this PickupCollection has to change as well.
     128    */
     129    void PickupCollection::changedUsedAction(void)
     130    {
     131        if(this->processingUsed_)
     132            return;
     133
     134        // If all the pickups are not in use but the PickupCollection is.
     135        if(this->usedCounter_ == 0 && this->isUsed())
     136            this->setUsed(false);
     137
     138        // If all the enabled pickups are in use but the PickupCollection is not.
     139        if(this->usedCounter_ != 0 && this->usedCounter_ == this->pickups_.size()-this->disabledCounter_ && !this->isUsed())
     140            this->setUsed(true);
     141    }
     142
    113143    /**
    114144    @brief
    … …  
    119149    {
    120150        SUPER(PickupCollection, changedCarrier);
    121        
    122         //! Change the PickupCarrier for all Pickupables this PickupCollection consists of.
    123         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    124         {
    125             (*it).get()->setCarrier(this->getCarrier()->getTarget(*it));
    126         }
    127     }
    128    
     151
     152        // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
     153        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     154        {
     155            if(this->getCarrier() == NULL)
     156                (*it)->setCarrier(NULL);
     157            else
     158                (*it)->setCarrier(this->getCarrier()->getTarget(*it));
     159        }
     160    }
     161
    129162    /**
    130163    @brief
    … …  
    135168    {
    136169        SUPER(PickupCollection, changedPickedUp);
    137        
    138         //! Change the pickedUp status for all Pickupables this PickupCollection consists of.
    139         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    140         {
    141             (*it).get()->setPickedUp(this->isPickedUp());
    142         }
    143     }
    144    
     170
     171        this->processingPickedUp_ = true;
     172        // Change the pickedUp status for all Pickupables this PickupCollection consists of.
     173        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     174        {
     175            (*it)->setPickedUp(this->isPickedUp());
     176        }
     177        this->processingPickedUp_ = false;
     178
     179        this->changedPickedUpAction();
     180    }
     181
     182    /**
     183    @brief
     184        Helper method.
     185        Checks whether due to changes in the picked up status of the pickups of this PickupCollection the picked up status of this PickupCollection has to change as well.
     186    */
     187    void PickupCollection::changedPickedUpAction(void)
     188    {
     189        if(this->processingPickedUp_)
     190            return;
     191
     192        // If at least all the enabled pickups of this PickupCollection are no longer picked up.
     193        if(this->pickedUpCounter_ <= this->disabledCounter_ && this->isPickedUp())
     194            this->Pickupable::destroy();
     195
     196        // If the PickupCollection is no longer picked up.
     197        if(!this->isPickedUp())
     198            this->pickedUpCounter_ = 0;
     199    }
     200
    145201    /**
    146202    @brief
    … …  
    154210        if(item == NULL)
    155211            item = new PickupCollection(this);
    156        
     212
    157213        SUPER(PickupCollection, clone, item);
    158        
     214
    159215        PickupCollection* pickup = dynamic_cast<PickupCollection*>(item);
    160         //! Clone all Pickupables this PickupCollection consist of.
    161         for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    162         {
    163             Pickupable* newPickup = (*it).get()->clone();
    164             pickup->addPickupable(newPickup);
     216        // Clone all Pickupables this PickupCollection consist of.
     217        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     218        {
     219            Pickupable* newPickup = (*it)->clone();
     220            CollectiblePickup* collectible = static_cast<CollectiblePickup*>(newPickup);
     221            pickup->addPickupable(collectible);
    165222        }
    166223
    167224        pickup->initializeIdentifier();
    168225    }
    169    
     226
    170227    /**
    171228    @brief
    … …  
    178235    bool PickupCollection::isTarget(PickupCarrier* carrier) const
    179236    {
    180         for(std::vector<WeakPtr<Pickupable> >::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
    181         {
    182             if(!carrier->isTarget((*it).get()))
     237        for(std::vector<CollectiblePickup*>::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
     238        {
     239            if(!carrier->isTarget(*it))
    183240                return false;
    184241        }
    185        
     242
    186243        return true;
    187244    }
    188    
     245
    189246    /**
    190247    @brief
    … …  
    198255        return this->pickupCollectionIdentifier_;
    199256    }
    200    
     257
    201258    /**
    202259    @brief
    … …  
    207264        Returns true if successful,
    208265    */
    209     bool PickupCollection::addPickupable(Pickupable* pickup)
     266    bool PickupCollection::addPickupable(CollectiblePickup* pickup)
    210267    {
    211268        if(pickup == NULL)
    212269            return false;
    213        
    214         WeakPtr<Pickupable> ptr = pickup; //!< Create a weak pointer to be able to test in the constructor if the Pointer is still valid.
    215         this->pickups_.push_back(ptr);
     270
     271        pickup->addToCollection(this);
     272        this->pickups_.push_back(pickup);
    216273        return true;
    217274    }
    218    
     275
    219276    /**
    220277    @brief
    … …  
    227284    const Pickupable* PickupCollection::getPickupable(unsigned int index)
    228285    {
    229         return this->pickups_[index].get();
    230     }
    231        
     286        return this->pickups_[index];
     287    }
     288
     289    /**
     290    @brief
     291        Informs the PickupCollection, that one of its pickups has changed its used status to the input value.
     292        This is used internally by the CollectiblePickup class.
     293    @param changed
     294        The value the used status has changed to.
     295    */
     296    void PickupCollection::pickupChangedUsed(bool changed)
     297    {
     298        if(changed)
     299            this->usedCounter_++;
     300        else
     301            this->usedCounter_--;
     302
     303        this->changedUsedAction();
     304    }
     305
     306    /**
     307    @brief
     308        Informs the PickupCollection, that one of its pickups has changed its picked up status to the input value.
     309        This is used internally by the CollectiblePickup class.
     310    @param changed
     311        The value the picked up status has changed to.
     312    */
     313    void PickupCollection::pickupChangedPickedUp(bool changed)
     314    {
     315        if(changed)
     316            this->pickedUpCounter_++;
     317        else
     318            this->pickedUpCounter_--;
     319
     320        this->changedPickedUpAction();
     321    }
     322
     323    /**
     324    @brief
     325        Informs the PickupCollection, that one of its pickups has been disabled.
     326        This is used internally by the CollectiblePickup class.
     327    */
     328    void PickupCollection::pickupDisabled(void)
     329    {
     330        this->disabledCounter_++;
     331    }
     332
    232333    /**
    233334    @brief
    … …  
    245346        return true;
    246347    }
    247    
     348
    248349}

  • code/trunk/src/modules/pickup/PickupCollection.h

    r6731 r7163  
    3737#include "PickupPrereqs.h"
    3838
    39 #include "interfaces/Pickupable.h"
    4039#include "core/BaseObject.h"
     40#include "CollectiblePickup.h"
    4141
    4242#include <list>
    … …  
    4747    /**
    4848    @brief
    49         The PickupCollection combines different Pickupables to a coherent, single pickup and makes the seem (from the outside looking in) just as if they were just one Pickupable.
     49        The PickupCollection combines different Pickupables to a coherent, single pickup and makes them seem (from the outside looking in) just as if they were just one Pickupable.
    5050    @author
    5151        Damian 'Mozork' Frick
    5252    */
    53     class _PickupExport PickupCollection : public Pickupable, public BaseObject
     53    class _PickupExport PickupCollection : public CollectiblePickup, public BaseObject
    5454    {
    55        
     55
    5656        public:
    57            
    5857            PickupCollection(BaseObject* creator); //!< Default Constructor.
    5958            virtual ~PickupCollection(); //!< Destructor.
    60            
     59
    6160            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates an instance of this Class through XML.
    6261
    … …  
    6463            virtual void changedCarrier(void); //!< Is called when the pickup has changed its PickupCarrier.
    6564            virtual void changedPickedUp(void); //!< Is called when the pickup has transited from picked up to dropped or the other way around.
    66            
     65
    6766            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
    68            
     67
    6968            virtual bool isTarget(PickupCarrier* carrier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
    70            
     69
    7170            virtual const PickupIdentifier* getPickupIdentifier(void); //!< Get the PickupIdentifier of this PickupCollection.
    72            
    73             bool addPickupable(Pickupable* pickup); //!< Add the input Pickupable to list of Pickupables combined by this PickupCollection.
     71
     72            bool addPickupable(CollectiblePickup* pickup); //!< Add the input Pickupable to list of Pickupables combined by this PickupCollection.
    7473            const Pickupable* getPickupable(unsigned int index); //!< Get the Pickupable at the given index.
    75            
     74
     75            void pickupChangedUsed(bool changed); //!< Informs the PickupCollection, that one of its pickups has changed its used status to the input value.
     76            void pickupChangedPickedUp(bool changed); //!< Informs the PickupCollection, that one of its pickups has changed its picked up status to the input value.
     77            void pickupDisabled(void); //!< Informs the PickupCollection, that one of its pickups has been disabled.
     78
    7679        protected:
    7780            void initializeIdentifier(void); //!< Initializes the PickupIdentifier for this pickup.
     81
     82            virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
     83
     84            PickupCollectionIdentifier* pickupCollectionIdentifier_; //!< The PickupCollectionIdentifier of this PickupCollection. Is used to distinguish different PickupCollections amongst themselves.
     85
     86        private:
     87            void changedUsedAction(void); //!< Helper method.
     88            void changedPickedUpAction(void); //!< Helper method.
    7889           
    79             virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
    80            
    81             PickupCollectionIdentifier* pickupCollectionIdentifier_; //!< The PickupCollectionIdentifier of this PickupCollection. Is used to distinguish different PickupCollections amongst themselves.
    82            
    83         private:
    84            
    85             std::vector<WeakPtr<Pickupable> > pickups_; //!< The list of the pointers of all the Pickupables this PickupCollection consists of. They are weak pointers to facilitate testing, whether the pointers are still valid.
    86        
     90            std::vector<CollectiblePickup*> pickups_; //!< The list of the pointers of all the Pickupables this PickupCollection consists of. They are weak pointers to facilitate testing, whether the pointers are still valid.
     91
     92            unsigned int usedCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are in use.
     93            unsigned int pickedUpCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are picked up.
     94            unsigned int disabledCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are disabled.
     95
     96            bool processingUsed_; //!< Boolean to ensure, that the PickupCollection doesn't update its used status while its internal state is inconsistent.
     97            bool processingPickedUp_; //!< Boolean to ensure, that the PickupCollection doesn't update its picked upp status while its internal state is inconsistent.
     98
    8799    };
    88    
     100
    89101}
    90102

  • code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc

    • Property svn:eol-style set to native
    r6538 r7163  
    3838namespace orxonox
    3939{
    40    
     40
    4141    /**
    4242    @brief
    … …  
    4747        RegisterObject(PickupCollectionIdentifier);
    4848    }
    49    
     49
    5050    /**
    5151    @brief
    … …  
    5454    PickupCollectionIdentifier::~PickupCollectionIdentifier()
    5555    {
    56        
     56
    5757    }
    5858
    … …  
    6767    int PickupCollectionIdentifier::compare(const PickupIdentifier* identifier) const
    6868    {
    69         //! Slight un-niceity to cast the PickupIdentifier to a PickupCollectionIdentifier.
     69        // Slight un-niceity to cast the PickupIdentifier to a PickupCollectionIdentifier.
    7070        PickupIdentifier* temp = const_cast<PickupIdentifier*>(identifier);
    7171        const PickupCollectionIdentifier* collectionIdentifier = dynamic_cast<PickupCollectionIdentifier*>(temp);
    72        
    73         //! If the input PickupIdentifier 'identifier' is no PickupCollectionIdentifier then just the two PickupIdentifiers are compared.
     72
     73        // If the input PickupIdentifier 'identifier' is no PickupCollectionIdentifier then just the two PickupIdentifiers are compared.
    7474        if(collectionIdentifier == NULL)
    7575        {
    7676            return this->PickupIdentifier::compare(identifier);
    7777        }
    78        
    79         //! If the number of Pickupables each of the two PickupCollectionIdentifiers contain differ, the one with less is considered smaller.
     78
     79        // If the number of Pickupables each of the two PickupCollectionIdentifiers contain differ, the one with less is considered smaller.
    8080        if(this->identifiers_.size() != collectionIdentifier->identifiers_.size())
    8181            return this->identifiers_.size()-collectionIdentifier->identifiers_.size();
    82        
    83         //! Compare the Pickupables of the two PickupCollectionIdentifiers one after the other. the one with the first 'smaller' one is considered smaller.
     82
     83        // Compare the Pickupables of the two PickupCollectionIdentifiers one after the other. the one with the first 'smaller' one is considered smaller.
    8484        std::set<const PickupIdentifier*, PickupIdentifierCompare>::const_iterator it2 = collectionIdentifier->identifiers_.begin();
    8585        for(std::set<const PickupIdentifier*, PickupIdentifierCompare>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); it++)
    8686        {
    87            
     87
    8888            if((*it)->compare(*it2) < 0)
    8989                return -1;
    … …  
    9191                return 1;
    9292        }
    93        
     93
    9494        //! Means they are equal.
    9595        return 0;
    9696    }
    97    
     97
    9898    /**
    9999    @brief
    … …  
    106106        this->identifiers_.insert(identifier);
    107107    }
    108    
     108
    109109}
    110110

  • code/trunk/src/modules/pickup/PickupCollectionIdentifier.h

    • Property svn:eol-style set to native
    r6538 r7163  
    5454    class _PickupExport PickupCollectionIdentifier : public PickupIdentifier
    5555    {
    56        
     56
    5757        public:
    5858            PickupCollectionIdentifier(Pickupable* pickup); //!< Constructor.
    5959            ~PickupCollectionIdentifier(); //!< Destructor.
    60            
     60
    6161            virtual int compare(const PickupIdentifier* identifier) const; //!< Compares a PickupCollectionIdentifier with a PickupIdentifier.
    62            
     62
    6363            void addPickup(const PickupIdentifier* identifier); //!< Add a Pickupable to the PickupCollectionIdentifier.
    64            
     64
    6565        private:
    6666            std::set<const PickupIdentifier*, PickupIdentifierCompare> identifiers_; //!< The set of PickupIdentifiers of the Pickupables the PickupCollection with this PickupCollectionIdentifier consists of, ordered by the rule set by PickupIdentifierCompare.
    67            
     67
    6868    };
    69    
     69
    7070}
    7171

  • code/trunk/src/modules/pickup/PickupManager.cc

    • Property svn:eol-style set to native
    r6752 r7163  
    3939#include "core/ScopedSingletonManager.h"
    4040#include "core/Identifier.h"
     41#include "util/Convert.h"
    4142#include "interfaces/PickupCarrier.h"
    4243#include "infos/PlayerInfo.h"
    4344#include "worldentities/pawns/Pawn.h"
     45#include "CollectiblePickup.h"
    4446#include "PickupRepresentation.h"
    4547
    … …  
    5052    // Register tolua_open function when loading the library
    5153    DeclareToluaInterface(Pickup);
    52    
    53     ManageScopedSingleton(PickupManager, ScopeID::Graphics, false);
    54    
     54
     55    ManageScopedSingleton(PickupManager, ScopeID::Root, false);
     56
    5557    /*static*/ const std::string PickupManager::guiName_s = "PickupInventory";
    56    
     58
    5759    /**
    5860    @brief
    … …  
    6264    {
    6365        RegisterRootObject(PickupManager);
    64        
     66
     67        //TODO: This doesn't work, yet.
     68        if( GameMode::showsGraphics() )
     69        {
     70            GUIManager::getInstance().loadGUI(PickupManager::guiName_s);
     71        }
    6572        this->defaultRepresentation_ = new PickupRepresentation();
    66        
     73
    6774        COUT(3) << "PickupManager created." << std::endl;
    6875    }
    69    
     76
    7077    /**
    7178    @brief
    … …  
    7784        if(this->defaultRepresentation_ != NULL)
    7885            this->defaultRepresentation_->destroy();
    79        
     86
    8087        this->representations_.clear();
    81        
     88
    8289        COUT(3) << "PickupManager destroyed." << std::endl;
    8390    }
    84    
     91
    8592    /**
    8693    @brief
    … …  
    95102    */
    96103    bool PickupManager::registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation)
    97     {       
     104    {
    98105        if(identifier == NULL || representation == NULL || this->representations_.find(identifier) != this->representations_.end()) //!< If the Pickupable already has a Representation registered.
    99106            return false;
    100        
     107
    101108        this->representations_[identifier] = representation;
    102        
     109
    103110        COUT(4) << "PickupRepresentation " << representation << " registered with the PickupManager." << std::endl;
    104111        return true;
    105112    }
    106    
     113
    107114    /**
    108115    @brief
    … …  
    116123    */
    117124    bool PickupManager::unregisterRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation)
    118     {       
     125    {
    119126        if(identifier == NULL || representation == NULL)
    120127            return false;
    121        
     128
    122129        std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare>::iterator it = this->representations_.find(identifier);
    123130        if(it == this->representations_.end()) //!< If the Pickupable is not registered in the first place.
    124131            return false;
    125        
     132
    126133        this->representations_.erase(it);
    127        
     134
    128135        COUT(4) << "PickupRepresentation " << representation << " unregistered with the PickupManager." << std::endl;
    129136        return true;
    130137    }
    131    
     138
    132139    /**
    133140    @brief
    … …  
    146153            return this->defaultRepresentation_;
    147154        }
    148        
     155
    149156        return it->second;
    150157    }
    151    
    152     PickupCarrier* PickupManager::getPawn(void)
    153     {
     158
     159    int PickupManager::getNumPickups(void)
     160    {
     161        this->pickupsList_.clear();
     162
    154163        PlayerInfo* player = GUIManager::getInstance().getPlayer(PickupManager::guiName_s);
     164        PickupCarrier* carrier = NULL;
    155165        if (player != NULL)
    156             return dynamic_cast<PickupCarrier*>(player->getControllableEntity());
     166            carrier = dynamic_cast<PickupCarrier*>(player->getControllableEntity());
    157167        else
    158             return NULL;
    159     }
    160    
    161     int PickupManager::getNumCarrierChildren(PickupCarrier* carrier)
    162     {
    163         if(carrier == NULL)
    164168            return 0;
    165         return carrier->getNumCarrierChildren();
    166     }
    167            
    168     PickupCarrier* PickupManager::getCarrierChild(int index, PickupCarrier* carrier)
    169     {
    170         if(carrier == NULL)
    171             return NULL;
    172         return carrier->getCarrierChild(index);
    173     }
    174    
    175     const std::string& PickupManager::getCarrierName(orxonox::PickupCarrier* carrier)
    176     {
    177         if(carrier == NULL)
    178             return BLANKSTRING;
    179         return carrier->getCarrierName();
    180     }
    181    
    182     PickupRepresentation* PickupManager::getPickupRepresentation(int index, PickupCarrier* carrier)
    183     {
    184         Pickupable* pickup = carrier->getPickup(index);
    185         if(pickup == NULL)
    186             return NULL;
    187        
    188         return this->getRepresentation(pickup->getPickupIdentifier());
    189     }
    190    
    191     int PickupManager::getNumPickups(PickupCarrier* carrier)
    192     {
    193         if(carrier == NULL)
    194             return 0;
    195         return carrier->getNumPickups();
    196     }
    197    
    198     void PickupManager::dropPickup(int index, PickupCarrier* carrier)
    199     {
    200         Pickupable* pickup = carrier->getPickup(index);
    201         if(pickup != NULL)
    202             carrier->drop(pickup);
    203     }
    204    
    205     void PickupManager::usePickup(int index, PickupCarrier* carrier, bool use)
    206     {
    207         Pickupable* pickup = carrier->getPickup(index);
    208         if(pickup != NULL)
     169
     170        std::vector<PickupCarrier*>* carriers = this->getAllCarriers(carrier);
     171        for(std::vector<PickupCarrier*>::iterator it = carriers->begin(); it != carriers->end(); it++)
     172        {
     173            std::set<Pickupable*> pickups = (*it)->getPickups();
     174            for(std::set<Pickupable*>::iterator pickup = pickups.begin(); pickup != pickups.end(); pickup++)
     175            {
     176                CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(*pickup);
     177                if(collectible == NULL || !collectible->isInCollection())
     178                    this->pickupsList_.insert(std::pair<Pickupable*, WeakPtr<Pickupable> >(*pickup, WeakPtr<Pickupable>(*pickup)));
     179            }
     180        }
     181        delete carriers;
     182
     183        this->pickupsIterator_ = this->pickupsList_.begin();
     184        return this->pickupsList_.size();
     185    }
     186
     187    std::vector<PickupCarrier*>* PickupManager::getAllCarriers(PickupCarrier* carrier)
     188    {
     189        //TODO: More efficiently.
     190        std::vector<PickupCarrier*>* carriers = new std::vector<PickupCarrier*>();
     191        carriers->insert(carriers->end(), carrier);
     192        std::vector<PickupCarrier*>* children = carrier->getCarrierChildren();
     193        for(std::vector<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
     194        {
     195            std::vector<PickupCarrier*>* childrensChildren = this->getAllCarriers(*it);
     196            for(std::vector<PickupCarrier*>::iterator it2 = childrensChildren->begin(); it2 != childrensChildren->end(); it2++)
     197            {
     198                carriers->insert(carriers->end(), *it2);
     199            }
     200            delete childrensChildren;
     201        }
     202        delete children;
     203        return carriers;
     204    }
     205
     206    void PickupManager::dropPickup(orxonox::Pickupable* pickup)
     207    {
     208        std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup);
     209        if(pickup == NULL || it == this->pickupsList_.end() || it->second.get() == NULL)
     210            return;
     211
     212        if(!pickup->isPickedUp())
     213            return;
     214
     215        PickupCarrier* carrier = pickup->getCarrier();
     216        if(pickup != NULL && carrier != NULL)
     217        {
     218            pickup->drop(carrier);
     219        }
     220    }
     221
     222    void PickupManager::usePickup(orxonox::Pickupable* pickup, bool use)
     223    {
     224        std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup);
     225        if(pickup == NULL || it == this->pickupsList_.end() || it->second.get() == NULL)
     226            return;
     227
     228        if(!pickup->isPickedUp())
     229            return;
     230
     231        PickupCarrier* carrier = pickup->getCarrier();
     232        if(pickup != NULL && carrier != NULL)
    209233            pickup->setUsed(use);
    210234    }
    211    
     235
    212236}

  • code/trunk/src/modules/pickup/PickupManager.h

    • Property svn:eol-style set to native
    r6725 r7163  
    3939#include <map>
    4040#include "util/Singleton.h"
     41#include "core/WeakPtr.h"
    4142#include "pickup/PickupIdentifier.h"
    4243#include "PickupRepresentation.h"
    … …  
    5960    { // tolua_export
    6061        friend class Singleton<PickupManager>;
    61        
     62
    6263        public:
    6364            PickupManager();
    6465            virtual ~PickupManager();
    65            
     66
    6667            static PickupManager& getInstance() { return Singleton<PickupManager>::getInstance(); } // tolua_export
    67            
     68
    6869            bool registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
    6970            bool unregisterRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Unegisters a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
    7071            PickupRepresentation* getRepresentation(const PickupIdentifier* identifier); //!< Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
    71            
     72
    7273            // tolua_begin
    73             orxonox::PickupCarrier* getPawn(void);
    74            
    75             int getNumCarrierChildren(orxonox::PickupCarrier* carrier);
    76             orxonox::PickupCarrier* getCarrierChild(int index, orxonox::PickupCarrier* carrier);
    77            
    78             const std::string& getCarrierName(orxonox::PickupCarrier* carrier);
    79            
    80             int getNumPickups(orxonox::PickupCarrier* carrier);
    81             PickupRepresentation* getPickupRepresentation(int index, orxonox::PickupCarrier* carrier);
    82             void dropPickup(int index, orxonox::PickupCarrier* carrier);
    83             void usePickup(int index, orxonox::PickupCarrier* carrier, bool use);
     74            int getNumPickups(void);
     75            orxonox::Pickupable* popPickup(void) { return (this->pickupsIterator_++)->first; }
     76            orxonox::PickupRepresentation* getPickupRepresentation(orxonox::Pickupable* pickup) { if(pickup != NULL) return this->getRepresentation(pickup->getPickupIdentifier()); return NULL; }
     77
     78            void dropPickup(orxonox::Pickupable* pickup);
     79            void usePickup(orxonox::Pickupable* pickup, bool use);
     80            bool isValidPickup(orxonox::Pickupable* pickup) { std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup); if(it == this->pickupsList_.end()) return false; return it->second.get() != NULL; }
    8481            // tolua_end
    85            
     82
    8683        private:
    8784            static PickupManager* singletonPtr_s;
    8885            static const std::string guiName_s;
    89            
     86
    9087            PickupRepresentation* defaultRepresentation_; //!< The default PickupRepresentation.
    9188            std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare> representations_; //!< Map linking PickupIdentifiers (representing types if Pickupables) and PickupRepresentations.
    92        
     89
     90            std::map<Pickupable*, WeakPtr<Pickupable> > pickupsList_;
     91            std::map<Pickupable*, WeakPtr<Pickupable> >::iterator pickupsIterator_;
     92
     93            std::vector<PickupCarrier*>* getAllCarriers(PickupCarrier* carrier);
     94
    9395    }; // tolua_export
    94    
     96
    9597} // tolua_export
    9698

  • code/trunk/src/modules/pickup/PickupPrereqs.h

    r6711 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(PICKUP_STATIC_BUILD)
    4646#  ifdef PICKUP_SHARED_BUILD
    4747#    define _PickupExport __declspec(dllexport)
    … …  
    6565namespace orxonox
    6666{
    67    
     67
     68    class CollectiblePickup;
    6869    class DroppedPickup;
    6970    class Pickup;
    … …  
    7576
    7677    //items
     78    class DronePickup;
    7779    class HealthPickup;
    7880    class InvisiblePickup;
    7981    class MetaPickup;
    8082    class SpeedPickup;
     83    class ShieldPickup;
    8184
    8285}

  • code/trunk/src/modules/pickup/PickupRepresentation.cc

    • Property svn:eol-style set to native
    r6725 r7163  
    4141namespace orxonox
    4242{
    43    
     43
    4444    CreateFactory(PickupRepresentation);
    45    
     45
    4646    /**
    4747    @brief
    … …  
    5252    {
    5353        RegisterObject(PickupRepresentation);
    54        
     54
    5555        this->initialize();
    5656    }
    57    
     57
    5858    /**
    5959    @brief
    … …  
    6363    {
    6464        RegisterObject(PickupRepresentation);
    65        
     65
    6666        this->initialize();
    6767    }
    68    
     68
    6969    /**
    7070    @brief
    … …  
    7575        if(this->spawnerRepresentation_ != NULL)
    7676            this->spawnerRepresentation_->destroy();
    77        
     77
    7878        if(this->pickup_ != NULL)
    7979            PickupManager::getInstance().unregisterRepresentation(this->pickup_->getPickupIdentifier(), this);
    8080    }
    81    
     81
    8282    /**
    8383    @brief
    … …  
    9191        this->inventoryRepresentation_ = "Default";
    9292    }
    93    
     93
    9494    /**
    9595    @brief
    … …  
    9999    {
    100100        SUPER(PickupRepresentation, XMLPort, xmlelement, mode);
    101        
     101
    102102        XMLPortParam(PickupRepresentation, "pickupName", setPickupName, getPickupName, xmlelement, mode);
    103103        XMLPortParam(PickupRepresentation, "pickupDescription", setPickupDescription, getPickupDescription, xmlelement, mode);
    … …  
    106106        XMLPortObject(PickupRepresentation, Pickupable, "pickup", setPickup, getPickup, xmlelement, mode);
    107107        XMLPortObject(PickupRepresentation, StaticEntity, "spawner-representation", setSpawnerRepresentation, getSpawnerRepresentationIndex, xmlelement, mode);
    108        
     108
    109109        PickupManager::getInstance().registerRepresentation(this->pickup_->getPickupIdentifier(), this); //!< Registers the PickupRepresentation with the PickupManager through the PickupIdentifier of the Pickupable it represents.
    110        
     110
    111111        if(this->spawnerRepresentation_ != NULL)
    112112            this->spawnerRepresentation_->setVisible(false);
    113        
     113
    114114        COUT(4) << "PickupRepresentation created: name: '" << this->name_ << "', description: '" << this->description_ << "', spawnerTemplate: '" << this->spawnerTemplate_ << "'." << std::endl;
    115115    }
    116    
     116
    117117    /**
    118118    @brief
    … …  
    136136            this->addTemplate(this->spawnerTemplate_);
    137137        }
    138        
     138
    139139        StaticEntity* representation = this->spawnerRepresentation_;
    140140        representation->setVisible(true);
    141        
     141
    142142        this->addTemplate(this->spawnerTemplate_);
    143143        this->spawnerRepresentation_->setVisible(false);
    144        
     144
    145145        return representation;
    146146    }
    147    
     147
    148148    /**
    149149    @brief
    … …  
    171171        return representation;
    172172    }
    173    
     173
    174174}

  • code/trunk/src/modules/pickup/PickupRepresentation.h

    • Property svn:eol-style set to native
    r6711 r7163  
    5656        : public BaseObject
    5757    { // tolua_export
    58        
     58
    5959        public:
    6060            PickupRepresentation(); //!< Constructor
    6161            PickupRepresentation(BaseObject* creator); //!< Default constructor.
    6262            virtual ~PickupRepresentation(); //!< Destructor.
    63            
     63
    6464            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    65            
     65
    6666            /**
    6767            @brief Set the name of the Pickupable represented by this PickupRepresentation.
    … …  
    102102            inline void setPickup(Pickupable* pickup)
    103103                { this->pickup_ = pickup; }
    104                
     104
    105105            /**
    106106            @brief Get the name of the Pickupable represented by this PickupRepresentation.
    … …  
    138138            inline const Pickupable* getPickup(unsigned int index)
    139139                { if(index == 0) return this->pickup_; return NULL; }
    140                
     140
    141141            StaticEntity* getSpawnerRepresentation(PickupSpawner* spawner); //!< Get a spawnerRepresentation for a specific PickupSpawner.
    142        
     142
    143143        private:
    144144            void initialize(void); //!< Initializes the member variables of this PickupRepresentation.
    145145            StaticEntity* getDefaultSpawnerRepresentation(PickupSpawner* spawner); //!< Get the default spawnerRepresentation for a specific PickupSpawner.
    146            
     146
    147147            std::string name_; //!< The name of the Pickupable represented by this PickupRepresentation.
    148148            std::string description_; //!< The description of the Pickupable represented by this PickupRepresentation.
    149149            std::string spawnerTemplate_; //!<  The name of the template of this PickupRepresentation.
    150150            StaticEntity* spawnerRepresentation_; //!< The spawnerRepresentation of this PickupRepresentation.
    151             std::string inventoryRepresentation_; //!< The name of an image representing the pickup in the PickupInventory. TODO: Exact format and placement of image?
    152            
     151            std::string inventoryRepresentation_; //!< The name of an image representing the pickup in the PickupInventory.
     152
    153153            Pickupable* pickup_; //!< The Pickupable that is represented by this PickupRepresentation.
    154            
     154
    155155    }; // tolua_export
    156156
    157157} // tolua_export
    158    
     158
    159159#endif // _PickupRepresentation_H__

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

    r6711 r7163  
    5555    {
    5656        RegisterObject(PickupSpawner);
    57        
     57
    5858        this->initialize();
    5959    }
    … …  
    7676    {
    7777        RegisterObject(PickupSpawner);
    78        
     78
    7979        this->initialize();
    80  
     80
    8181        this->pickup_ = pickup;
    8282
    … …  
    8484        this->respawnTime_ = respawnTime;
    8585        this->setMaxSpawnedItems(maxSpawnedItems);
    86        
     86
    8787        if(this->pickup_ == NULL)
    8888        {
    … …  
    107107        this->maxSpawnedItems_ = INF;
    108108        this->spawnsRemaining_ = INF;
     109        this->selfDestruct_ = false;
    109110    }
    110111
    … …  
    115116    PickupSpawner::~PickupSpawner()
    116117    {
    117         if(this->pickup_ != NULL)
     118        if(this->selfDestruct_ && this->pickup_ != NULL)
    118119            this->pickup_->destroy();
    119120    }
    … …  
    132133
    133134        XMLPortObject(PickupSpawner, Pickupable, "pickup", setPickupable, getPickupable, xmlelement, mode);
    134        
     135
    135136        XMLPortParam(PickupSpawner, "triggerDistance", setTriggerDistance, getTriggerDistance, xmlelement, mode);
    136137        XMLPortParam(PickupSpawner, "respawnTime", setRespawnTime, getRespawnTime, xmlelement, mode);
    137138        XMLPortParam(PickupSpawner, "maxSpawnedItems", setMaxSpawnedItems, getMaxSpawnedItems, xmlelement, mode);
    138        
     139
    139140        if(this->pickup_ == NULL)
    140141        {
    … …  
    150151        }
    151152    }
    152    
     153
    153154    /**
    154155    @brief
    … …  
    161162        this->setVisible(this->isActive());
    162163    }
    163      
     164
    164165    /**
    165166    @brief
    … …  
    172173    {
    173174        SUPER(PickupSpawner, tick, dt);
    174        
     175
    175176        //! If the PickupSpawner is active.
    176177        if (this->isActive())
    177178        {
     179            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)
     180
    178181            //! Iterate trough all Pawns.
    179182            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
    … …  
    189192        }
    190193    }
    191    
     194
    192195    /**
    193196    @brief
    … …  
    201204        this->spawnsRemaining_ = items;
    202205    }
    203    
     206
    204207    /**
    205208    @brief
    … …  
    223226        else
    224227        {
    225             COUT(3) << "PickupSpawner empty, selfdestruct initialized." << std::endl;
     228            COUT(4) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << std::endl;
    226229            this->setActive(false);
    227230            this->destroy();
    228231        }
    229232    }
    230    
     233
    231234    /**
    232235    @brief
    … …  
    237240        this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
    238241    }
    239    
     242
    240243    /**
    241244    @brief
    … …  
    248251        if(this->pickup_ != NULL)
    249252        {
    250             COUT(1) << "In PickupSpawner: setPickupable called, with this->pickup_ already set." << std::endl;
     253            COUT(1) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << std::endl;
    251254            return;
    252255        }
    253256        if(pickup == NULL)
    254257        {
    255             COUT(1) << "In PickupSpawner: Argument of setPickupable is NULL." << std::endl;
     258            COUT(1) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << std::endl;
    256259            return;
    257260        }
    258        
     261
    259262        this->pickup_ = pickup;
    260263    }
    261    
     264
    262265    /**
    263266    @brief
    … …  
    282285        if (this->isActive()) //!< Checks whether PickupSpawner is active.
    283286        {
    284             COUT(3) << "PickupSpawner triggered and active." << std::endl;
    285            
     287            COUT(4) << "PickupSpawner (&" << this << ") triggered and active." << std::endl;
     288
    286289            PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
    287290            if(carrier == NULL)
    … …  
    290293                return;
    291294            }
    292            
     295
    293296            if(!carrier->isTarget(this->pickup_))
    294297            {
    295                 COUT(4) << "PickupSpawner triggered but Pawn wasn't a target of the Pickupable." << std::endl;
     298                COUT(4) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << std::endl;
    296299                return;
    297300            }
    298            
     301
    299302            PickupCarrier* target = carrier->getTarget(this->pickup_);
    300303            Pickupable* pickup = this->getPickup();
    301            
     304
    302305            if(target != NULL && pickup != NULL)
    303306            {
    304                 if(target->pickup(pickup))
    305                 {
     307                if(pickup->pickup(target))
    306308                    this->decrementSpawnsRemaining();
    307                 }
    308309                else
    309310                {
     311                    this->selfDestruct_ = true;
    310312                    pickup->destroy();
    311313                }
    … …  
    314316            {
    315317                if(target == NULL)
    316                     COUT(1) << "PickupSpawner: Pickupable has no target." << std::endl;
    317                
     318                    COUT(1) << "PickupSpawner (&" << this << "): Pickupable has no target." << std::endl;
     319
    318320                if(pickup == NULL)
    319                 {
    320                     COUT(1) << "PickupSpawner: getPickup produced an error, no Pickupable created." << std::endl;
    321                 }
     321                    COUT(1) << "PickupSpawner (&" << this << "): getPickup produced an error, no Pickupable created." << std::endl;
    322322                else
    323323                {
     324                    this->selfDestruct_ = true;
    324325                    pickup->destroy();
    325326                }
    … …  
    333334    @return
    334335        The Pickupable created.
    335     */   
     336    */
    336337    Pickupable* PickupSpawner::getPickup(void)
    337338    {
    … …  
    341342            return NULL;
    342343        }
    343        
     344
    344345        Pickupable* pickup = this->pickup_->clone();
    345346        return pickup;
    … …  
    352353    void PickupSpawner::respawnTimerCallback()
    353354    {
    354         COUT(3) << "PickupSpawner reactivated." << std::endl;
     355        COUT(4) << "PickupSpawner (&" << this << ") reactivated." << std::endl;
    355356
    356357        this->setActive(true);

  • code/trunk/src/modules/pickup/PickupSpawner.h

    r6540 r7163  
    101101        protected:
    102102            void decrementSpawnsRemaining(void); //!< Decrements the number of remaining spawns.
    103                        
     103
    104104            void startRespawnTimer(void);
    105            
     105
    106106            virtual Pickupable* getPickup(void); //!< Creates a new Pickupable.
    107            
     107
    108108            void setPickupable(Pickupable* pickup); //!< Sets a Pickupable for the PickupSpawner to spawn.
    109109            const Pickupable* getPickupable(void); //!< Get the Pickupable that is spawned by this PickupSpawner.
    110            
     110
    111111            Pickupable* pickup_; //!< The pickup to be spawned.
    112112
    113113        private:
    114114            void initialize(void);
    115            
     115
    116116            void trigger(Pawn* pawn); //!< Method called when a Pawn is close enough.
    117117            void respawnTimerCallback(); //!< Method called when the timer runs out.
    … …  
    125125            Timer respawnTimer_; //!< Timer used for re-activating.
    126126
     127            bool selfDestruct_; //!< True if the PickupSpawner is selfdestructing.
     128
    127129            static const int INF = -1; //!< Constant for infinity.
    128130    };

  • code/trunk/src/modules/pickup/items/CMakeLists.txt

    • Property svn:eol-style set to native
    r6710 r7163  
    33  InvisiblePickup.cc
    44  MetaPickup.cc
     5  DronePickup.cc
    56  SpeedPickup.cc
     7  ShieldPickup.cc
    68)

  • code/trunk/src/modules/pickup/items/HealthPickup.cc

    r6709 r7163  
    4545namespace orxonox
    4646{
    47    
     47
    4848    /*static*/ const std::string HealthPickup::healthTypeLimited_s = "limited";
    4949    /*static*/ const std::string HealthPickup::healthTypeTemporary_s = "temporary";
    5050    /*static*/ const std::string HealthPickup::healthTypePermanent_s = "permanent";
    51    
     51
    5252    CreateFactory(HealthPickup);
    53    
     53
    5454    /**
    5555    @brief
    … …  
    5959    {
    6060        RegisterObject(HealthPickup);
    61        
     61
    6262        this->initialize();
    6363    }
    64    
     64
    6565    /**
    6666    @brief
    … …  
    6969    HealthPickup::~HealthPickup()
    7070    {
    71        
    72     }
    73    
    74     /**
    75     @brief 
     71
     72    }
     73
     74    /**
     75    @brief
    7676        Initializes the member variables.
    7777    */
    7878    void HealthPickup::initialize(void)
    79     {       
     79    {
    8080        this->health_ = 0;
    8181        this->healthRate_ = 0;
    … …  
    8383        this->maxHealthSave_ = 0;
    8484        this->maxHealthOverwrite_ = 0;
    85        
     85
    8686        this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
    8787    }
    88    
     88
    8989    /**
    9090    @brief
    … …  
    9898        std::string val1 = stream.str();
    9999        this->pickupIdentifier_->addParameter(type1, val1);
    100        
     100
    101101        std::string val2 = this->getHealthType();
    102102        std::string type2 = "healthType";
    103103        this->pickupIdentifier_->addParameter(type2, val2);
    104        
     104
    105105        stream.clear();
    106106        stream << this->getHealthRate();
    … …  
    109109        this->pickupIdentifier_->addParameter(type3, val3);
    110110    }
    111    
     111
    112112    /**
    113113    @brief
    … …  
    117117    {
    118118        SUPER(HealthPickup, XMLPort, xmlelement, mode);
    119        
     119
    120120        XMLPortParam(HealthPickup, "health", setHealth, getHealth, xmlelement, mode);
    121121        XMLPortParam(HealthPickup, "healthRate", setHealthRate, getHealthRate, xmlelement, mode);
    122122        XMLPortParam(HealthPickup, "healthType", setHealthType, getHealthType, xmlelement, mode);
    123        
     123
    124124        if(!this->isContinuous())
    125125            this->healthRate_ = 0.0;
    126        
     126
    127127        this->initializeIdentifier();
    128128    }
    129    
     129
    130130    /**
    131131    @brief
    … …  
    138138    {
    139139        SUPER(HealthPickup, tick, dt);
    140        
     140
    141141        if(this->isContinuous() && this->isUsed())
    142142        {
    143143            Pawn* pawn = this->carrierToPawnHelper();
    144144            if(pawn == NULL) //!< If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    145                 this->destroy();
    146            
     145                this->Pickupable::destroy();
     146
    147147            //! Calculate the health that is added this tick.
    148148            float health = dt*this->getHealthRate();
    … …  
    152152            float fullHealth = pawn->getHealth() + health;
    153153            this->setHealth(this->getHealth()-health);
    154                    
     154
    155155            switch(this->getHealthTypeDirect())
    156156            {
    … …  
    173173                    COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
    174174            }
    175            
     175
    176176            //! If all health has been transfered.
    177177            if(this->getHealth() == 0)
    … …  
    181181        }
    182182    }
    183    
     183
    184184    /**
    185185    @brief
    … …  
    189189    {
    190190        SUPER(HealthPickup, changedUsed);
    191        
     191
    192192        //! If the pickup is not picked up nothing must be done.
    193         if(!this->isPickedUp())
     193        if(!this->isPickedUp()) //TODO: Needed?
    194194            return;
    195        
     195
    196196        //! If the pickup has transited to used.
    197197        if(this->isUsed())
    … …  
    201201                Pawn* pawn = this->carrierToPawnHelper();
    202202                if(pawn == NULL) //!< If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    203                     this->destroy();
    204                
     203                    this->Pickupable::destroy();
     204
    205205                float health = 0;
    206206                switch(this->getHealthTypeDirect())
    … …  
    226226                        COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
    227227                }
    228                
     228
    229229                //! The pickup has been used up.
    230230                this->setUsed(false);
    … …  
    237237                PickupCarrier* carrier = this->getCarrier();
    238238                Pawn* pawn = dynamic_cast<Pawn*>(carrier);
    239                
     239
    240240                if(pawn == NULL)
    241241                {
    242242                    COUT(1) << "Something went horribly wrong in Health Pickup. PickupCarrier is no Pawn." << std::endl;
    243                     this->destroy();
     243                    this->Pickupable::destroy();
    244244                    return;
    245245                }
    246                
     246
    247247                if(pawn->getMaxHealth() == this->maxHealthOverwrite_)
    248248                {
    … …  
    252252                }
    253253            }
    254            
     254
    255255            //! If either the pickup can only be used once or it is continuous and used up, it is destroyed upon setting it to unused.
    256256            if(this->isOnce() || (this->isContinuous() && this->getHealth() == 0))
    257257            {
    258                 this->destroy();
    259             }
    260         }
    261     }
    262    
     258                this->Pickupable::destroy();
     259            }
     260        }
     261    }
     262
    263263    /**
    264264    @brief
    … …  
    271271        PickupCarrier* carrier = this->getCarrier();
    272272        Pawn* pawn = dynamic_cast<Pawn*>(carrier);
    273        
     273
    274274        if(pawn == NULL)
    275275        {
    276276            COUT(1) << "Invalid PickupCarrier in HealthPickup." << std::endl;
    277277        }
    278        
     278
    279279        return pawn;
    280280    }
    281    
     281
    282282    /**
    283283    @brief
    … …  
    290290        if(item == NULL)
    291291            item = new HealthPickup(this);
    292        
     292
    293293        SUPER(HealthPickup, clone, item);
    294        
     294
    295295        HealthPickup* pickup = dynamic_cast<HealthPickup*>(item);
    296296        pickup->setHealth(this->getHealth());
    297297        pickup->setHealthRate(this->getHealthRate());
    298298        pickup->setHealthTypeDirect(this->getHealthTypeDirect());
    299        
     299
    300300        pickup->initializeIdentifier();
    301301    }
    302    
     302
    303303    /**
    304304    @brief
    … …  
    322322        }
    323323    }
    324    
     324
    325325    /**
    326326    @brief
    … …  
    341341        }
    342342    }
    343    
     343
    344344    /**
    345345    @brief
    … …  
    356356        else
    357357        {
    358             COUT(1) << "Invalid healthSpeed in HealthPickup." << std::endl; 
    359         }
    360     }
    361    
     358            COUT(1) << "Invalid healthSpeed in HealthPickup." << std::endl;
     359        }
     360    }
     361
    362362    /**
    363363    @brief

  • code/trunk/src/modules/pickup/items/HealthPickup.h

    r6709 r7163  
    4545
    4646namespace orxonox {
    47    
     47
    4848    //! Enum for the type of the HealthPickup
    4949    namespace pickupHealthType
    … …  
    5656        };
    5757    }
    58    
     58
    5959    /**
    6060    @brief
    … …  
    7171    {
    7272        public:
    73        
     73
    7474            HealthPickup(BaseObject* creator); //!< Constructor.
    7575            virtual ~HealthPickup(); //!< Destructor.
    76            
     76
    7777            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup object through XML.
    7878            virtual void tick(float dt); //!< Is called every tick.
    79            
     79
    8080            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
    8181            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
    82            
     82
    8383            /**
    8484            @brief Get the health that is transfered to the Pawn upon usage of this pickup.
    … …  
    9393            inline float getHealthRate(void)
    9494                { return this->healthRate_; }
    95                
     95
    9696            /**
    9797            @brief Get the type of HealthPickup, this pickup is.
    98             @return Returns the health type as an enum. 
     98            @return Returns the health type as an enum.
    9999            */
    100100            inline pickupHealthType::Value getHealthTypeDirect(void)
    101101                { return this->healthType_; }
    102102            const std::string& getHealthType(void); //!< Get the health type of this pickup.
    103            
     103
    104104        protected:
    105105            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
    … …  
    107107            void setHealth(float health); //!< Sets the health.
    108108            void setHealthRate(float speed); //!< Set the rate at which health is transferred if the pickup is continuous.
    109            
     109
    110110            /**
    111111            @brief Set the health type of this pickup.
    … …  
    115115                { this->healthType_ = type; }
    116116            void setHealthType(std::string type); //!< Set the type of the HealthPickup.
    117        
     117
    118118        private:
    119119            void initialize(void); //!< Initializes the member variables.
    120120            Pawn* carrierToPawnHelper(void); //!< Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    121            
     121
    122122            float health_; //!< The health that is transferred to the Pawn.
    123123            float healthRate_; //!< The rate at which the health is transferred.
    … …  
    125125            float maxHealthOverwrite_; //!< Helper to remember with which value we overwrote the maxHealh, to detect if someone else changed it as well.
    126126            pickupHealthType::Value healthType_; //!< The type of the HealthPickup.
    127            
     127
    128128            //! Strings for the health types.
    129129            static const std::string healthTypeLimited_s;
    130130            static const std::string healthTypeTemporary_s;
    131131            static const std::string healthTypePermanent_s;
    132        
     132
    133133    };
    134134}

  • code/trunk/src/modules/pickup/items/InvisiblePickup.cc

    • Property svn:eol-style set to native
    r6755 r7163  
    3434#include "InvisiblePickup.h"
    3535
     36#include <sstream>
     37#include <OgreEntity.h>
     38#include <OgreAnimationState.h>
     39
     40#include "util/StringUtils.h"
    3641#include "core/CoreIncludes.h"
    3742#include "core/XMLPort.h"
    38 #include "util/StringUtils.h"
    3943
    4044#include "worldentities/pawns/Pawn.h"
    4145#include "pickup/PickupIdentifier.h"
    4246
    43 #include <sstream>
    44 
    4547namespace orxonox
    4648{
    4749
    4850    CreateFactory(InvisiblePickup);
    49    
     51
    5052    /**
    5153    @brief
    … …  
    5658        RegisterObject(InvisiblePickup);
    5759        //! Defines who is allowed to pick up the pickup.
    58         this->initialize(); 
    59     }
    60    
     60        this->initialize();
     61    }
     62
    6163    /**
    6264    @brief
    … …  
    6466    */
    6567    InvisiblePickup::~InvisiblePickup()
    66     {       
    67     }
    68    
    69    
     68    {
     69    }
     70
     71
    7072    void InvisiblePickup::initializeIdentifier(void)
    7173    {
    … …  
    7678        this->pickupIdentifier_->addParameter(type1, val1);
    7779    }
    78    
     80
    7981    /**
    8082    @brief
    … …  
    9395    void InvisiblePickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
    9496    {
    95         SUPER(InvisiblePickup, XMLPort, xmlelement, mode);   
     97        SUPER(InvisiblePickup, XMLPort, xmlelement, mode);
    9698        XMLPortParam(InvisiblePickup, "duration", setDuration, getDuration, xmlelement, mode);
    97        
     99
    98100        this->initializeIdentifier();
    99101    }
    100    
     102
    101103    /**
    102104    @brief
    … …  
    106108    {
    107109        SUPER(InvisiblePickup, changedUsed);
    108        
     110
    109111        //! If the pickup is not picked up nothing must be done.
    110112        if(!this->isPickedUp())
    111113            return;
    112        
     114
    113115        if (this->isUsed())
    114116        {
    … …  
    121123                this->startPickupTimer(this->getDuration());
    122124            }
     125
    123126            this->setInvisible(true);
     127
    124128        }
    125129        else
    126130        {
    127131            this->setInvisible(false);
    128        
     132
    129133            if(!this->getTimer()->isActive() && this->getTimer()->getRemainingTime() == this->getDuration())
    130134            {
    131                 this->destroy();
     135                this->Pickupable::destroy();
    132136            }
    133137            else
    … …  
    136140            }
    137141        }
    138        
    139     }
    140    
     142
     143    }
     144
    141145    /**
    142146    @brief
    … …  
    149153        PickupCarrier* carrier = this->getCarrier();
    150154        Pawn* pawn = dynamic_cast<Pawn*>(carrier);
    151        
     155
    152156        if(pawn == NULL)
    153157        {
    … …  
    156160        return pawn;
    157161    }
    158    
     162
    159163    /**
    160164    @brief
    … …  
    167171        if(item == NULL)
    168172            item = new InvisiblePickup(this);
    169        
     173
    170174        SUPER(InvisiblePickup, clone, item);
    171        
     175
    172176        InvisiblePickup* pickup = dynamic_cast<InvisiblePickup*>(item);
    173177        pickup->setDuration(this->getDuration());
    174178        pickup->initializeIdentifier();
    175179    }
    176    
     180
    177181    /**
    178182    @brief
    … …  
    186190        if(pawn == NULL)
    187191            return false;
    188        
     192
    189193        pawn->setVisible(!invisibility);
     194        pawn->setRadarVisibility(!invisibility);
     195
     196// Test to change Material at runtime!
     197
     198//      Ogre::MaterialPtr mat = this->mesh_.getEntity()->getSubEntity(0)->getMaterial();
     199//      mat->setDiffuse(0.4, 0.3, 0.1, 0.1);
     200//      mat->setAmbient(0.3, 0.7, 0.8);
     201//      mat->setSpecular(0.5, 0.5, 0.5, 0.1);
     202//      Ogre::SceneBlendType sbt = Ogre::SBT_ADD;
     203//
     204//      mat->setSceneBlending(sbt);
     205
    190206        return true;
    191207    }
    192    
     208
    193209    /**
    194210    @brief
    … …  
    209225        }
    210226    }
    211    
     227
    212228    void InvisiblePickup::pickupTimerCallback(void)
    213229    {

  • code/trunk/src/modules/pickup/items/InvisiblePickup.h

    • Property svn:eol-style set to native
    r6710 r7163  
    3838
    3939#include <string>
     40
    4041#include <worldentities/pawns/Pawn.h>
    4142#include "worldentities/StaticEntity.h"
    42 
    4343#include "pickup/Pickup.h"
    4444
    4545namespace orxonox {
    46        
     46
    4747    /**
    4848    @brief
    … …  
    5757    {
    5858        public:
    59        
     59
    6060            InvisiblePickup(BaseObject* creator); //!< Constructor.
    6161            virtual ~InvisiblePickup(); //!< Destructor.
    … …  
    6363            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
    6464            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
    65            
     65
    6666            /**
    6767            @brief Checks whether the Pawn is invisible.
    … …  
    7272            inline float getDuration()
    7373                { return this->duration_; }
    74  
     74
    7575        protected:
    7676            bool setInvisible(bool invisibility); //!< Set the Pawn to be invisible or visible again.
    … …  
    7878            void initializeIdentifier(void);
    7979            virtual void pickupTimerCallback(void); //!< Function that gets called when the timer ends.
    80        
     80
    8181        private:
    8282            void initialize(void); //!< Initializes the member variables.

  • code/trunk/src/modules/pickup/items/MetaPickup.cc

    r6709 r7163  
    3434#include "core/CoreIncludes.h"
    3535#include "core/XMLPort.h"
     36#include "worldentities/pawns/Pawn.h"
    3637#include "interfaces/PickupCarrier.h"
    3738#include "pickup/PickupIdentifier.h"
    … …  
    4041
    4142namespace orxonox {
    42  
     43
    4344    CreateFactory(MetaPickup);
    44    
     45
    4546    //! Setting the static variables to their values.
    4647    /*static*/ const std::string MetaPickup::metaTypeNone_s = "none";
    4748    /*static*/ const std::string MetaPickup::metaTypeUse_s = "use";
    4849    /*static*/ const std::string MetaPickup::metaTypeDrop_s = "drop";
    49    
     50    /*static*/ const std::string MetaPickup::metaTypeDestroy_s = "destroy";
     51    /*static*/ const std::string MetaPickup::metaTypeDestroyCarrier_s = "destroyCarrier";
     52
    5053    /**
    5154    @brief
    … …  
    5558    {
    5659        RegisterObject(MetaPickup);
    57        
     60
    5861        this->initialize();
    5962    }
    60    
     63
    6164    /**
    6265    @brief
    … …  
    6568    MetaPickup::~MetaPickup()
    6669    {
    67        
    68     }
    69    
     70
     71    }
     72
    7073    /**
    7174    @brief
    … …  
    7578    {
    7679        this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
    77        
     80
    7881        this->setActivationTypeDirect(pickupActivationType::immediate);
    7982        this->setDurationTypeDirect(pickupDurationType::once);
    8083        this->metaType_ = pickupMetaType::none;
    8184    }
    82    
     85
    8386    /**
    8487    @brief
    … …  
    9194        this->pickupIdentifier_->addParameter(type, val);
    9295    }
    93    
     96
    9497    /**
    9598    @brief
    … …  
    99102    {
    100103        SUPER(MetaPickup, XMLPort, xmlelement, mode);
    101        
     104
    102105        XMLPortParam(MetaPickup, "metaType", setMetaType, getMetaType, xmlelement, mode);
    103        
     106
    104107        this->initializeIdentifier();
    105108    }
    106    
     109
    107110    /**
    108111    @brief
    … …  
    113116    {
    114117        SUPER(MetaPickup, changedUsed);
    115        
     118
    116119        //! If the MetaPickup transited to used.
    117120        if(this->isUsed())
    … …  
    120123            if(this->getMetaTypeDirect() != pickupMetaType::none && carrier != NULL)
    121124            {
     125                if(this->getMetaTypeDirect() == pickupMetaType::destroyCarrier)
     126                {
     127                    Pawn* pawn = orxonox_cast<Pawn*>(carrier);
     128                    pawn->kill();
     129                    return;
     130                }
    122131                std::set<Pickupable*> pickups = carrier->getPickups();
    123                 //! Set all Pickupables carried by the PickupCarrier either to used or drop them, depending o the meta type.
     132                //! Set all Pickupables carried by the PickupCarrier either to used or drop them, depending on the meta type.
    124133                for(std::set<Pickupable*>::iterator it = pickups.begin(); it != pickups.end(); it++)
    125134                {
    … …  
    136145                        if(pickup != NULL && pickup != this)
    137146                        {
    138                             carrier->drop(pickup);
     147                            pickup->drop();
     148                        }
     149                    }
     150                    if(this->getMetaTypeDirect() == pickupMetaType::destroy)
     151                    {
     152                        if(pickup != NULL && pickup != this)
     153                        {
     154                            pickup->Pickupable::destroy();
    139155                        }
    140156                    }
    141157                }
    142158            }
    143             this->destroy();
    144         }
    145     }
    146        
     159            this->Pickupable::destroy();
     160        }
     161    }
     162
    147163    /**
    148164    @brief
    … …  
    155171        if(item == NULL)
    156172            item = new MetaPickup(this);
    157        
     173
    158174        SUPER(MetaPickup, clone, item);
    159        
     175
    160176        MetaPickup* pickup = dynamic_cast<MetaPickup*>(item);
    161177        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
    162        
     178
    163179        pickup->initializeIdentifier();
    164180    }
    165    
     181
    166182    /**
    167183    @brief
    … …  
    180196            case pickupMetaType::drop:
    181197                return MetaPickup::metaTypeDrop_s;
     198            case pickupMetaType::destroy:
     199                return MetaPickup::metaTypeDestroy_s;
     200            case pickupMetaType::destroyCarrier:
     201                return MetaPickup::metaTypeDestroyCarrier_s;
    182202            default:
    183203                return BLANKSTRING;
    184204        }
    185205    }
    186    
     206
    187207    /**
    188208    @brief
    … …  
    205225            this->setMetaTypeDirect(pickupMetaType::drop);
    206226        }
    207     }
    208    
     227        else if(type == MetaPickup::metaTypeDestroy_s)
     228        {
     229            this->setMetaTypeDirect(pickupMetaType::destroy);
     230        }
     231        else if(type == MetaPickup::metaTypeDestroyCarrier_s)
     232        {
     233            this->setMetaTypeDirect(pickupMetaType::destroyCarrier);
     234        }
     235        else
     236            COUT(2) << "Invalid metaType '" << type << "' in MetaPickup." << std::endl;
     237    }
     238
    209239}

  • code/trunk/src/modules/pickup/items/MetaPickup.h

    r6709 r7163  
    4848            none,
    4949            use,
    50             drop
     50            drop,
     51            destroy,
     52            destroyCarrier
    5153        };
    5254    }
    53    
     55
    5456    /**
    5557    @brief
    56         The MetaPickup is a pickup that can, depending on the parameters, either drop all pickups of the PickupCarrier that picks it up, or use all the unused pickups of the PickupCarrier, that picks it up. The parameter to set for this is the metaType and it can be used with the values 'none', 'drop' and 'use'.
     58        The MetaPickup is a pickup that can, depending on the parameter 'metaType', do different things. If the 'metaType' is set to
     59        1) 'use', all the pickups, the PickupCarrier has, are immediately set to used upon pickup of the MetaPickup.
     60        2) 'drop', all the pickups, the PickupCarrier has, are immediately dropped upon pickup of the MetaPickup.
     61        3) 'destroy', all the pickups, the PickupCarrier has, are immediately destroyed upon pickup of the MetaPickup.
     62        4) 'destroyCarrier', the PickupCarrier is immediately destroyed upon pickup of the MetaPickup.
    5763    @author
    5864        Damian 'Mozork' Frick
    … …  
    6066    class _PickupExport MetaPickup : public Pickup
    6167    {
    62        
     68
    6369        public:
    6470            MetaPickup(BaseObject* creator); //!< Constructor. Registers and initializes the object.
    6571            virtual ~MetaPickup(); //!< Destructor.
    66            
     72
    6773            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a MetaPickup object through XML.
    68            
     74
    6975            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
    7076            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
    71            
     77
    7278            /**
    7379            @brief Returns the meta type of the MetaPickup.
    … …  
    7783                { return this->metaType_; }
    7884            const std::string& getMetaType(void); //!< Get the meta type of this MetaPickup.
    79            
     85
    8086        protected:
    8187            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
    82            
     88
    8389            /**
    8490            @brief Set the meta type of the MetaPickup.
    … …  
    8894                { this->metaType_ =  type; }
    8995            void setMetaType(const std::string& type); //!< Set the meta type of this MetaPickup.
    90            
     96
    9197        private:
    9298            void initialize(void); //!< Initializes the member variables.
    93            
     99
    94100            pickupMetaType::Value metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
    95            
     101
    96102            //! Static strings for the meta types.
    97103            static const std::string metaTypeNone_s;
    98104            static const std::string metaTypeUse_s;
    99105            static const std::string metaTypeDrop_s;
    100            
    101        
     106            static const std::string metaTypeDestroy_s;
     107            static const std::string metaTypeDestroyCarrier_s;
     108
     109
    102110    };
    103111

  • code/trunk/src/modules/pickup/items/SpeedPickup.cc

    r6755 r7163  
    136136        Engine* engine = this->carrierToEngineHelper();
    137137        if(engine == NULL) //!< If the PickupCarrier is no Engine, then this pickup is useless and therefore is destroyed.
    138             this->destroy();
    139        
     138            this->Pickupable::destroy();
     139
    140140        //! If the pickup has transited to used.
    141141        if(this->isUsed())
    … …  
    156156            engine->setSpeedAdd(0.0f);
    157157            engine->setSpeedMultiply(1.0f);
    158            
     158
    159159            if(this->isOnce())
    160160            {
    161161                if(!this->getTimer()->isActive() && this->getTimer()->getRemainingTime() == this->getDuration())
    162162                {
    163                     this->destroy();
     163                    this->Pickupable::destroy();
    164164                }
    165165                else
    … …  
    186186            COUT(1) << "Invalid PickupCarrier in SpeedPickup." << std::endl;
    187187        }
    188        
     188
    189189        return engine;
    190190    }
    … …  
    269269
    270270    void SpeedPickup::pickupTimerCallback(void)
    271     {       
     271    {
    272272        this->setUsed(false);
    273273    }

  • code/trunk/src/modules/pickup/items/SpeedPickup.h

    r6709 r7163  
    7878        protected:
    7979            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
    80            
     80
    8181            virtual void pickupTimerCallback(void); //!< Function that gets called when timer ends.
    8282

  • code/trunk/src/modules/pong/CMakeLists.txt

    r5929 r7163  
    1414  MODULE
    1515  FIND_HEADER_FILES
    16   DEFINE_SYMBOL
    17     "PONG_SHARED_BUILD"
    1816  LINK_LIBRARIES
    1917    orxonox

  • code/trunk/src/modules/pong/PongBall.h

    r5929 r7163  
    4545            virtual void tick(float dt);
    4646
    47             void registerVariables();
    48 
    4947            void setFieldDimension(float width, float height)
    5048                { this->fieldWidth_ = width; this->fieldHeight_ = height; }
    … …  
    7472
    7573        private:
     74            void registerVariables();
     75
    7676            float fieldWidth_;
    7777            float fieldHeight_;

  • code/trunk/src/modules/pong/PongBat.h

    r5781 r7163  
    4141            virtual ~PongBat() {}
    4242
    43             void registerVariables();
    4443            virtual void tick(float dt);
    4544
    … …  
    6564
    6665        private:
     66            void registerVariables();
     67
    6768            float movement_;
    6869            bool bMoveLocal_;

  • code/trunk/src/modules/pong/PongPrereqs.h

    r5929 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(PONG_STATIC_BUILD)
    4646#  ifdef PONG_SHARED_BUILD
    4747#    define _PongExport __declspec(dllexport)

  • code/trunk/src/modules/questsystem/AddQuest.cc

    r5781 r7163  
    6868        SUPER(AddQuest, XMLPort, xmlelement, mode);
    6969
    70         COUT(3) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
     70        COUT(4) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
    7171    }
    7272
    … …  
    8787        }
    8888
    89         COUT(3) << "AddQuest on player: " << player << " ." << std::endl;
     89        COUT(5) << "AddQuest on player: " << player << " ." << std::endl;
    9090
    9191        try
    … …  
    103103        }
    104104
    105         COUT(3) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << std::endl;
     105        COUT(4) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << std::endl;
    106106        return true;
    107107    }

  • code/trunk/src/modules/questsystem/AddQuestHint.cc

    r6417 r7163  
    7272        XMLPortParam(AddQuestHint, "hintId", setHintId, getHintId, xmlelement, mode);
    7373
    74         COUT(3) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << std::endl;
     74        COUT(4) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << std::endl;
    7575    }
    7676
    … …  
    8585    bool AddQuestHint::setHintId(const std::string & id)
    8686    {
    87         if(!QuestItem::isId(id))
     87        if(id.compare(BLANKSTRING) == 0)
    8888        {
    8989            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
    … …  
    111111        }
    112112
    113         COUT(3) << "AddQuestHint on player: " << player << " ." << std::endl;
     113        COUT(5) << "AddQuestHint on player: " << player << " ." << std::endl;
    114114
    115115        try
    … …  
    127127        }
    128128
    129         COUT(3) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << std::endl;
     129        COUT(4) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << std::endl;
    130130        return true;
    131131

  • code/trunk/src/modules/questsystem/AddReward.cc

    r6417 r7163  
    6868        XMLPortObject(AddReward, Rewardable, "", addRewardable, getRewardables, xmlelement, mode);
    6969
    70         COUT(3) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << std::endl;
     70        COUT(4) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << std::endl;
    7171    }
    7272
    … …  
    103103    bool AddReward::invoke(PlayerInfo* player)
    104104    {
    105         COUT(3) << "AddReward on player: " << player << " ." << std::endl;
     105        COUT(5) << "AddReward on player: " << player << " ." << std::endl;
    106106
    107107        bool check = true;
    … …  
    111111        }
    112112
    113         COUT(3) << "Rewardable successfully added to player." << player << " ." << std::endl;
     113        COUT(4) << "Rewardable successfully added to player." << player << " ." << std::endl;
    114114
    115115        return check;

  • code/trunk/src/modules/questsystem/CMakeLists.txt

    r6800 r7163  
    1212  QuestEffect.cc
    1313  QuestEffectBeacon.cc
    14   QuestGUINode.cc
    15   QuestGUI.cc
    1614  QuestHint.cc
    1715  QuestItem.cc
    … …  
    2826  TOLUA_FILES
    2927    QuestManager.h
    30   DEFINE_SYMBOL
    31     "QUESTSYSTEM_SHARED_BUILD"
     28    QuestDescription.h
     29    Quest.h
     30    QuestHint.h
    3231  PCH_FILE
    3332    QuestsystemPrecompiledHeaders.h

  • code/trunk/src/modules/questsystem/ChangeQuestStatus.cc

    r6417 r7163  
    7878    bool ChangeQuestStatus::setQuestId(const std::string & id)
    7979    {
    80         if(!QuestItem::isId(id))
     80        if(id.compare(BLANKSTRING) == 0)
    8181        {
    8282            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;

  • code/trunk/src/modules/questsystem/CompleteQuest.cc

    r6417 r7163  
    6868        SUPER(CompleteQuest, XMLPort, xmlelement, mode);
    6969
    70         COUT(3) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
     70        COUT(4) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
    7171    }
    7272
    … …  
    8787        }
    8888
    89         COUT(3) << "CompleteQuest on player: " << player << " ." << std::endl;
     89        COUT(5) << "CompleteQuest on player: " << player << " ." << std::endl;
    9090
    9191        Quest* quest;
    … …  
    105105        }
    106106
    107         COUT(3) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << std::endl;
     107        COUT(4) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << std::endl;
    108108        return true;
    109109    }

  • code/trunk/src/modules/questsystem/FailQuest.cc

    r6417 r7163  
    6868        SUPER(FailQuest, XMLPort, xmlelement, mode);
    6969
    70         COUT(3) << "New FailQUest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
     70        COUT(4) << "New FailQUest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
    7171    }
    7272
    … …  
    8787        }
    8888
    89         COUT(3) << "FailQuest on player: " << player << " ." << std::endl;
     89        COUT(4) << "FailQuest on player: " << player << " ." << std::endl;
    9090
    9191        Quest* quest;
    … …  
    104104        }
    105105
    106         COUT(3) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << std::endl;
     106        COUT(4) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << std::endl;
    107107        return true;
    108108    }

  • code/trunk/src/modules/questsystem/GlobalQuest.cc

    r6417 r7163  
    7070        XMLPortObject(GlobalQuest, QuestEffect, "reward-effects", addRewardEffect, getRewardEffects, xmlelement, mode);
    7171
    72         COUT(3) << "New GlobalQuest {" << this->getId() << "} created." << std::endl;
     72        COUT(4) << "New GlobalQuest {" << this->getId() << "} created." << std::endl;
    7373    }
    7474
    … …  
    253253        this->rewards_.push_back(effect); //!< Add the QuestEffect to the list.
    254254
    255         COUT(3) << "Reward effect was added to Quest {" << this->getId() << "}." << std::endl;
     255        COUT(4) << "Reward effect was added to Quest {" << this->getId() << "}." << std::endl;
    256256        return true;
    257257    }

  • code/trunk/src/modules/questsystem/LocalQuest.cc

    r6417 r7163  
    6868        SUPER(LocalQuest, XMLPort, xmlelement, mode);
    6969
    70         COUT(3) << "New LocalQuest {" << this->getId() << "} created." << std::endl;
     70        COUT(4) << "New LocalQuest {" << this->getId() << "} created." << std::endl;
    7171    }
    7272

  • code/trunk/src/modules/questsystem/Quest.cc

    r6417 r7163  
    6161    Quest::~Quest()
    6262    {
    63 
     63        if(this->isRegistered())
     64            QuestManager::getInstance().unregisterQuest(this);
    6465    }
    6566
    … …  
    9899        this->parentQuest_ = quest;
    99100
    100         COUT(3) << "Parent Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
     101        COUT(4) << "Parent Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
    101102        return true;
    102103    }
    … …  
    121122        this->subQuests_.push_back(quest); //!< Adds the Quest to the end of the list of subquests.
    122123
    123         COUT(3) << "Sub Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
     124        COUT(4) << "Sub Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
    124125        return true;
    125126    }
    … …  
    145146        this->hints_.push_back(hint); //!< Adds the QuestHint to the end of the list of QuestHints.
    146147
    147         COUT(3) << "QuestHint {" << hint->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
     148        COUT(4) << "QuestHint {" << hint->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
    148149        return true;
    149150    }
    … …  
    167168        this->failEffects_.push_back(effect); //!< Adds the QuestEffect to the end of the list of fail QuestEffects.
    168169
    169         COUT(3) << "A FailEffect was added to Quest {" << this->getId() << "}." << std::endl;
     170        COUT(4) << "A FailEffect was added to Quest {" << this->getId() << "}." << std::endl;
    170171        return true;
    171172    }
    … …  
    189190        this->completeEffects_.push_back(effect); //!< Adds the QuestEffect to the end of the list of complete QuestEffects.
    190191
    191         COUT(3) << "A CompleteEffect was added to Quest {" << this->getId() << "}." << std::endl;
     192        COUT(4) << "A CompleteEffect was added to Quest {" << this->getId() << "}." << std::endl;
    192193        return true;
    193194    }

  • code/trunk/src/modules/questsystem/Quest.h

    r5781 r7163  
    4141#include "QuestItem.h"
    4242
    43 namespace orxonox
    44 {
     43namespace orxonox // tolua_export
     44{ // tolua_export
    4545    namespace QuestStatus
    4646    {
    … …  
    6767        Damian 'Mozork' Frick
    6868    */
    69     class _QuestsystemExport Quest : public QuestItem
    70     {
     69    class _QuestsystemExport Quest // tolua_export
     70        : public QuestItem
     71    { // tolua_export
    7172        public:
    7273            Quest(BaseObject* creator);
    … …  
    9798
    9899            bool isInactive(const PlayerInfo* player) const; //!< Returns true if the quest status for the specific player is 'inactive'.
    99             bool isActive(const PlayerInfo* player) const; //!< Returns true if the quest status for the specific player is 'active'.
    100             bool isFailed(const PlayerInfo* player) const; //!< Returns true if the quest status for the specific player is 'failed'.
    101             bool isCompleted(const PlayerInfo* player) const; //!< Returns true if the quest status for the specific player is 'completed'.
     100            bool isActive(const orxonox::PlayerInfo* player) const; // tolua_export //!< Returns true if the quest status for the specific player is 'active'.
     101            bool isFailed(const orxonox::PlayerInfo* player) const; // tolua_export //!< Returns true if the quest status for the specific player is 'failed'.
     102            bool isCompleted(const orxonox::PlayerInfo* player) const; // tolua_export //!< Returns true if the quest status for the specific player is 'completed'.
    102103
    103104            bool start(PlayerInfo* player); //!< Sets a Quest to active.
    … …  
    151152            bool addCompleteEffect(QuestEffect* effect); //!< Adds an QuestEffect to the list of complete QuestEffects.
    152153
    153     };
     154    }; // tolua_export
    154155
    155 }
     156} // tolua_export
    156157
    157158#endif /* _Quest_H__ */

  • code/trunk/src/modules/questsystem/QuestDescription.cc

    r6417 r7163  
    7474        XMLPortParam(QuestDescription, "completeMessage", setCompleteMessage, getCompleteMessage, xmlelement, mode);
    7575
    76         COUT(3) << "New QuestDescription with title '" << this->getTitle() << "' created." << std::endl;
     76        COUT(4) << "New QuestDescription with title '" << this->getTitle() << "' created." << std::endl;
    7777    }
    7878
    … …  
    8989        Make sure the messages meet the conditions.
    9090    */
    91     bool QuestDescription::notificationHelper(const std::string & item, const std::string & status) const
     91    bool QuestDescription::notificationHelper(const std::string & item, const std::string & status)
    9292    {
    9393        std::string message;
    … …  
    122122        }
    123123
    124         QuestNotification* notification = new QuestNotification(message);
     124        QuestNotification* notification = new QuestNotification(this, message);
    125125        notification->send();
    126126        return true;

  • code/trunk/src/modules/questsystem/QuestDescription.h

    r5781 r7163  
    8383            @return Returns a string containing the fail message of the QuestDescription.
    8484            */
    85             inline const std::string & getFailMessage(void) const
     85            inline const std::string & getFailMessage(void)
    8686                { return this->failMessage_; }
    8787
    … …  
    9090            @return Returns a string containing the complete message of the QuestDescription.
    9191            */
    92             inline const std::string & getCompleteMessage(void) const
     92            inline const std::string & getCompleteMessage(void)
    9393                { return this->completeMessage_; }
    9494
    … …  
    9797            @return Returns true if successful.
    9898            */
    99             inline bool sendAddHintNotification(void) const
     99            inline bool sendAddHintNotification(void)
    100100                { return notificationHelper("hint", ""); }
    101101
    … …  
    104104            @return Returns true if successful.
    105105            */
    106             inline bool sendAddQuestNotification(void) const
     106            inline bool sendAddQuestNotification(void)
    107107                { return notificationHelper("quest", "start"); }
    108108
    … …  
    111111            @return Returns true if successful.
    112112            */
    113             inline bool sendFailQuestNotification(void) const
     113            inline bool sendFailQuestNotification(void)
    114114                { return notificationHelper("quest", "fail"); }
    115115
    … …  
    118118            @return Returns true if successful.
    119119            */
    120             inline bool sendCompleteQuestNotification(void) const
     120            inline bool sendCompleteQuestNotification(void)
    121121                { return notificationHelper("quest", "complete"); }
    122122
    … …  
    127127            std::string completeMessage_; //!< The message displayed when the Quest is completed.
    128128
    129             bool notificationHelper(const std::string & item, const std::string & status) const; //!< Helper for sending QuestDescriptions as Notifications.
     129            bool notificationHelper(const std::string & item, const std::string & status); //!< Helper for sending QuestDescriptions as Notifications.
    130130
    131131            /**

  • code/trunk/src/modules/questsystem/QuestEffectBeacon.cc

    r6906 r7163  
    7878        XMLPortEventSink(QuestEffectBeacon, BaseObject, "execute", execute, xmlelement, mode); //TODO: Change BaseObject to MultiTrigger as soon as MultiTrigger is the base of all triggers.
    7979
    80         COUT(3) << "New QuestEffectBeacon created." << std::endl;
     80        COUT(4) << "New QuestEffectBeacon created." << std::endl;
    8181    }
    8282
    … …  
    112112        MultiTriggerContainer* mTrigger = orxonox_cast<MultiTriggerContainer*>(trigger);
    113113        Pawn* pawn = NULL;
    114        
     114
    115115        //! If the trigger is neither a Playertrigger nor a MultiTrigger (i.e. a MultitriggerContainer) we can do anything with it.
    116116        if(pTrigger == NULL && mTrigger == NULL)
    117117            return false;
    118        
    119         // If the trigger is a PlayerTrigger.       
     118
     119        // If the trigger is a PlayerTrigger.
    120120        if(pTrigger != NULL)
    121121        {
    … …  
    125125                pawn = pTrigger->getTriggeringPlayer();
    126126        }
    127        
     127
    128128        // If the trigger is a MultiTrigger (i.e. a MultiTriggerContainer)
    129129        if(mTrigger != NULL)
    … …  
    134134        if(pawn == NULL)
    135135        {
    136             COUT(2) << "The QuestEffectBeacon was triggered by an entity other than a Pawn." << std::endl;
     136            COUT(4) << "The QuestEffectBeacon was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
    137137            return false;
    138138        }
    … …  
    147147        }
    148148
    149         COUT(3) << "QuestEffectBeacon executed on player: " << player << " ." << std::endl;
     149        COUT(4) << "QuestEffectBeacon executed on player: " << player << " ." << std::endl;
    150150
    151151        bool check = QuestEffect::invokeEffects(player, this->effects_); //!< Invoke the QuestEffects on the PlayerInfo.
    … …  
    249249        this->effects_.push_back(effect);
    250250
    251         COUT(3) << "A QuestEffect was added to a QuestEffectBeacon." << std::endl;
     251        COUT(4) << "A QuestEffect was added to a QuestEffectBeacon." << std::endl;
    252252        return true;
    253253    }

  • code/trunk/src/modules/questsystem/QuestHint.cc

    r6417 r7163  
    5959    QuestHint::~QuestHint()
    6060    {
    61 
     61        if(this->isRegistered())
     62            QuestManager::getInstance().unregisterHint(this);
    6263    }
    6364
    … …  
    7273        QuestManager::getInstance().registerHint(this); //!< Registers the QuestHint with the QuestManager.
    7374
    74         COUT(3) << "New QuestHint {" << this->getId() << "} created." << std::endl;
     75        COUT(4) << "New QuestHint {" << this->getId() << "} created." << std::endl;
    7576    }
    7677
    … …  
    125126            else
    126127            {
    127                 COUT(2) << "An already active questHint was trying to get activated." << std::endl;
     128                COUT(4) << "An already active questHint was trying to get activated." << std::endl;
    128129                return false;
    129130            }
    130131        }
    131132
    132         COUT(2) << "A hint of a non-active quest was trying to get activated." << std::endl;
     133        COUT(4) << "A hint of a non-active quest was trying to get activated." << std::endl;
    133134        return false;
    134135    }

  • code/trunk/src/modules/questsystem/QuestHint.h

    r5781 r7163  
    4040#include "QuestItem.h"
    4141
    42 namespace orxonox
    43 {
     42namespace orxonox // tolua_export
     43{ // tolua_export
    4444    namespace QuestHintStatus
    4545    {
    … …  
    6666        Damian 'Mozork' Frick
    6767    */
    68     class _QuestsystemExport QuestHint : public QuestItem
    69     {
     68    class _QuestsystemExport QuestHint // tolua_export
     69        : public QuestItem
     70    { // tolua_export
    7071
    7172        public:
    … …  
    9192            std::map<const PlayerInfo*, QuestHintStatus::Value> playerStatus_; //!< List of the states for each player, with the Player-pointer as key.
    9293
    93     };
     94    }; // tolua_export
    9495
    95 }
     96} // tolua_export
    9697
    9798#endif /* _QuestHint_H__ */

  • code/trunk/src/modules/questsystem/QuestItem.cc

    r6417 r7163  
    4040namespace orxonox
    4141{
     42
     43    CreateUnloadableFactory(QuestItem);
     44
    4245    /**
    4346    @brief
    … …  
    4649    QuestItem::QuestItem(BaseObject* creator) : BaseObject(creator)
    4750    {
     51        this->registered_ = false;
     52
    4853        RegisterObject(QuestItem);
    4954    }
    … …  
    7984    void QuestItem::setId(const std::string & id)
    8085    {
    81         if(!isId(id)) //!< Checks whether the id is a valid id.
     86        if(id.compare(BLANKSTRING) == 0) //!< Checks whether the id is a valid id.
    8287        {
    8388            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
    … …  
    8893    }
    8994
    90     /**
    91     @brief
    92         Checks whether an input id is of the required form.
    93     @param id
    94         The id to be checked.
    95     @return
    96         Returns true if the string is likely to be of the required form.
    97     */
    98     /*static*/ bool QuestItem::isId(const std::string & id)
    99     {
    100         return id.size() >= 32;
    101     }
    102 
    10395}

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

    r5781 r7163  
    4141#include <string>
    4242#include "core/BaseObject.h"
     43#include "QuestManager.h"
    4344
    4445namespace orxonox
    … …  
    7172            @return Returns a pointer to the QuestDescription object of the QuestItem.
    7273            */
    73             inline const QuestDescription* getDescription(void) const
     74            inline QuestDescription* getDescription(void) const
    7475                { return this->description_; }
    7576
    76             static bool isId(const std::string & id); //!< Checks whether a given id is valid.
     77            /**
     78            @brief Check whether the QuestItem is registered with the QuestManager.
     79            @return Returns true if the QuestItem is registered with the QuestManager.
     80            */
     81            inline bool isRegistered(void)
     82                { return this->registered_; }
     83            /**
     84            @brief Set the QuestItem as being registered with the QuestManager.
     85            */
     86            inline void setRegistered(void)
     87                { this->registered_ = true; }
    7788
    7889        protected:
    … …  
    90101            QuestDescription* description_; //!< The QuestDescription of the QuestItem.
    91102
     103            bool registered_;
     104
    92105    };
    93106

  • code/trunk/src/modules/questsystem/QuestListener.cc

    r6417 r7163  
    7474        XMLPortParam(QuestListener, "mode", setMode, getMode, xmlelement, mode);
    7575
    76         this->quest_->addListener(this); //!< Adds the QuestListener to the Quests list of listeners.
    77 
    78         COUT(3) << "QuestListener created for quest: {" << this->quest_->getId() << "} with mode '" << this->getMode() << "'." << std::endl;
     76        if(this->quest_ != NULL)
     77            this->quest_->addListener(this); //!< Adds the QuestListener to the Quests list of listeners.
     78
     79        COUT(4) << "QuestListener created for quest: {" << this->quest_->getId() << "} with mode '" << this->getMode() << "'." << std::endl;
    7980    }
    8081

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

    r6536 r7163  
    7474    QuestManager::~QuestManager()
    7575    {
    76         for(std::map<PlayerInfo*, QuestGUI*>::iterator it = this->questGUIs_.begin(); it != this->questGUIs_.end(); it++)
    77         {
    78             it->second->destroy();
    79         }
    80         this->questGUIs_.clear();
     76
    8177    }
    8278
    … …  
    114110        if(result.second) //!< If inserting was a success.
    115111        {
    116             COUT(3) << "Quest with questId {" << quest->getId() << "} successfully inserted." << std::endl;
     112            quest->setRegistered();
     113            COUT(4) << "Quest with questId {" << quest->getId() << "} successfully inserted." << std::endl;
    117114            return true;
    118115        }
    … …  
    122119           return false;
    123120        }
     121    }
     122
     123    /**
     124    @brief
     125        Unregisters a Quest in the QuestManager.
     126    */
     127    bool QuestManager::unregisterQuest(Quest* quest)
     128    {
     129        return this->questMap_.erase(quest->getId()) == 1;
    124130    }
    125131
    … …  
    146152        if(result.second) //!< If inserting was a success.
    147153        {
    148             COUT(3) << "QuestHint with hintId {" << hint->getId() << "} successfully inserted." << std::endl;
     154            hint->setRegistered();
     155            COUT(4) << "QuestHint with hintId {" << hint->getId() << "} successfully inserted." << std::endl;
    149156            return true;
    150157        }
    … …  
    154161           return false;
    155162        }
     163    }
     164
     165    /**
     166    @brief
     167        Unregisters a QuestHint in the QuestManager.
     168    */
     169    bool QuestManager::unregisterHint(QuestHint* hint)
     170    {
     171        return this->hintMap_.erase(hint->getId()) == 1;
    156172    }
    157173
    … …  
    169185    Quest* QuestManager::findQuest(const std::string & questId)
    170186    {
    171         if(!QuestItem::isId(questId)) //!< Check vor validity of the given id.
     187        if(questId.compare(BLANKSTRING) == 1) //!< Check vor validity of the given id.
    172188        {
    173189            ThrowException(Argument, "Invalid questId.");
    … …  
    203219    QuestHint* QuestManager::findHint(const std::string & hintId)
    204220    {
    205         if(!QuestItem::isId(hintId)) //!< Check vor validity of the given id.
     221        if(hintId.compare(BLANKSTRING) == 1) //!< Check vor validity of the given id.
    206222        {
    207223            ThrowException(Argument, "Invalid hintId.");
    … …  
    224240    }
    225241
    226     /**
    227     @brief
    228         Retreive the main window for the GUI.
    229         This is for the use in the lua script tu start the QuestGUI.
    230     @param guiName
    231         The name of the GUI.
    232     @return
    233         Returns a CEGUI Window.
    234     */
    235     CEGUI::Window* QuestManager::getQuestGUI(const std::string & guiName)
    236     {
    237         PlayerInfo* player = this->retrievePlayer(guiName);
    238 
    239         if(this->questGUIs_.find(player) == this->questGUIs_.end()) //!< Create a new GUI, if there is none, yet.
    240             this->questGUIs_[player] = new QuestGUI(player);
    241 
    242         return this->questGUIs_[player]->getGUI();
     242    int QuestManager::getNumParentQuests(PlayerInfo* player)
     243    {
     244        int numQuests = 0;
     245        for(std::map<std::string, Quest*>::iterator it = this->questMap_.begin(); it != this->questMap_.end(); it++)
     246        {
     247            if(it->second->getParentQuest() == NULL && !it->second->isInactive(player))
     248                numQuests++;
     249        }
     250        return numQuests;
     251    }
     252
     253    Quest* QuestManager::getParentQuest(PlayerInfo* player, int index)
     254    {
     255        for(std::map<std::string, Quest*>::iterator it = this->questMap_.begin(); it != this->questMap_.end(); it++)
     256        {
     257            if(it->second->getParentQuest() == NULL && !it->second->isInactive(player) && index-- == 0)
     258                return it->second;
     259        }
     260        return NULL;
     261    }
     262
     263    int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
     264    {
     265        std::list<Quest*> quests = quest->getSubQuestList();
     266        int numQuests = 0;
     267        for(std::list<Quest*>::iterator it = quests.begin(); it != quests.end(); it++)
     268        {
     269            if(!(*it)->isInactive(player))
     270                numQuests++;
     271        }
     272        return numQuests;
     273    }
     274
     275    Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
     276    {
     277        std::list<Quest*> quests = quest->getSubQuestList();
     278        for(std::list<Quest*>::iterator it = quests.begin(); it != quests.end(); it++)
     279        {
     280            if(!(*it)->isInactive(player) && index-- == 0)
     281                return *it;
     282        }
     283        return NULL;
     284    }
     285
     286    int QuestManager::getNumHints(Quest* quest, PlayerInfo* player)
     287    {
     288        std::list<QuestHint*> hints = quest->getHintsList();
     289        int numHints = 0;
     290        for(std::list<QuestHint*>::iterator it = hints.begin(); it != hints.end(); it++)
     291        {
     292            if((*it)->isActive(player))
     293                numHints++;
     294        }
     295        return numHints;
     296    }
     297
     298    QuestHint* QuestManager::getHints(Quest* quest, PlayerInfo* player, int index)
     299    {
     300        std::list<QuestHint*> hints = quest->getHintsList();
     301        for(std::list<QuestHint*>::iterator it = hints.begin(); it != hints.end(); it++)
     302        {
     303            if((*it)->isActive(player) && index-- == 0)
     304                return *it;
     305        }
     306        return NULL;
     307    }
     308
     309    QuestDescription* QuestManager::getDescription(Quest* item)
     310    {
     311        return item->getDescription();
     312    }
     313
     314    QuestDescription* QuestManager::getDescription(QuestHint* item)
     315    {
     316        return item->getDescription();
    243317    }
    244318

  • code/trunk/src/modules/questsystem/QuestManager.h

    r6536 r7163  
    3636
    3737#include "questsystem/QuestsystemPrereqs.h"
    38 #include <CEGUIForwardRefs.h>
    3938
    4039#include <list>
    … …  
    4443#include "util/Singleton.h"
    4544#include "core/OrxonoxClass.h"
    46 
    47 #include "QuestGUI.h"
    4845
    4946// tolua_begin
    … …  
    6360
    6461            friend class Singleton<QuestManager>;
    65             friend class QuestGUI;
    6662
    6763        public:
    … …  
    7268            static QuestManager& getInstance() { return Singleton<QuestManager>::getInstance(); } // tolua_export
    7369
    74             //! Retrieve the main window for the GUI.
    75             CEGUI::Window* getQuestGUI(const std::string & guiName); // tolua_export
     70            // tolua_begin
     71            int getNumParentQuests(orxonox::PlayerInfo* player);
     72            Quest* getParentQuest(orxonox::PlayerInfo* player, int index);
     73
     74            int getNumSubQuests(Quest* quest, orxonox::PlayerInfo* player);
     75            Quest* getSubQuest(Quest* quest, orxonox::PlayerInfo* player, int index);
     76
     77            int getNumHints(Quest* quest, orxonox::PlayerInfo* player);
     78            QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index);
     79
     80            QuestDescription* getDescription(Quest* item);
     81            QuestDescription* getDescription(QuestHint* item);
     82            // tolua_end
    7683
    7784            bool registerQuest(Quest* quest); //!< Registers a Quest in the QuestManager.
    78             bool registerHint(QuestHint* quest); //!< Registers a QuestHint in the QuestManager.
     85            bool unregisterQuest(Quest* quest); //!< Unregisters a Quest in the QuestManager.
     86            bool registerHint(QuestHint* hint); //!< Registers a QuestHint in the QuestManager.
     87            bool unregisterHint(QuestHint* hint); //!< Unregisters a QuestHint in the QuestManager.
    7988
    8089            Quest* findQuest(const std::string & questId); //!< Returns the Quest with the input id.
    … …  
    91100            std::map<std::string, QuestHint*> hintMap_; //!< All QuestHints registered by their id's.
    92101
    93             std::map<PlayerInfo*, QuestGUI*> questGUIs_; //!< All GUI's registered by the players.
    94 
    95102    }; // tolua_export
    96103

  • code/trunk/src/modules/questsystem/QuestNotification.cc

    r6417 r7163  
    3232namespace orxonox {
    3333
    34     const std::string QuestNotification::SENDER("questsystem");
     34    /*static*/ const std::string QuestNotification::SENDER("questsystem");
    3535
     36    CreateUnloadableFactory(QuestNotification);
     37
     38    /**
     39    @brief
     40        Default Constructor. Creates a useless QuestNotification.
     41    */
    3642    QuestNotification::QuestNotification(BaseObject* creator) : Notification(creator)
    3743    {
    38         this->initialize();
     44        RegisterObject(QuestNotification);
    3945    }
    4046
    41     QuestNotification::QuestNotification(const std::string & message) : Notification(message)
     47    /**
     48    @brief
     49        Creates a QuestNotification with the input message.
     50    @param message
     51        The message to be sent.
     52    */
     53    QuestNotification::QuestNotification(BaseObject* creator, const std::string & message) : Notification(creator, message)
    4254    {
    43         this->initialize();
     55        RegisterObject(QuestNotification);
    4456    }
    4557
     58    /**
     59    @brief
     60        Destructor.
     61    */
    4662    QuestNotification::~QuestNotification()
    4763    {
    … …  
    4965    }
    5066
     67    /**
     68    @brief
     69        Send the QuestNotification.
     70    @return
     71        Returns true if successful.
     72    */
    5173    bool QuestNotification::send(void)
    5274    {
    … …  
    5476    }
    5577
    56     void QuestNotification::initialize(void)
    57     {
    58         RegisterObject(QuestNotification);
    59     }
    60 
    6178
    6279}

  • code/trunk/src/modules/questsystem/QuestNotification.h

    • Property svn:executable deleted
    r5781 r7163  
    3939    /**
    4040    @brief
    41 
     41        The QuestNotification is a special Notification that has the single property that it is only sent by the questsystem.
    4242    @author
    4343        Damian 'Mozork' Frick
    … …  
    4646    {
    4747        public:
    48             QuestNotification(BaseObject* creator);
    49             QuestNotification(const std::string & message);
    50             virtual ~QuestNotification();
     48            QuestNotification(BaseObject* creator); //!< Default Constructor.
     49            QuestNotification(BaseObject* creator, const std::string & message); //!< Constructor.
     50            virtual ~QuestNotification(); //!< Destructor.
    5151
    52             bool send(void);
     52            bool send(void); //!< Send the QuestNotification.
    5353
    5454        private:
    55             static const std::string SENDER;
    56 
    57             void initialize(void);
     55            static const std::string SENDER; //!< A string identifying the questsystem as the sender.
    5856
    5957    };

  • code/trunk/src/modules/questsystem/QuestsystemPrereqs.h

    r5929 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(QUESTSYSTEM_STATIC_BUILD)
    4646#  ifdef QUESTSYSTEM_SHARED_BUILD
    4747#    define _QuestsystemExport __declspec(dllexport)
    … …  
    7777    class QuestEffect;
    7878    class QuestEffectBeacon;
    79     class QuestGUI;
    80     class QuestGUINode;
    8179    class QuestHint;
    8280    class QuestItem;

  • code/trunk/src/modules/questsystem/notifications/Notification.cc

    r6417 r7163  
    4040{
    4141
     42    CreateUnloadableFactory(Notification);
     43
    4244    /**
    4345    @brief
    … …  
    5658        The message of the Notification.
    5759    */
    58     Notification::Notification(const std::string & message) : BaseObject(NULL)
     60    Notification::Notification(BaseObject* creator, const std::string & message) : BaseObject(creator)
    5961    {
    6062        this->message_ = message;
    … …  
    6769    Notification::~Notification()
    6870    {
     71
    6972    }
    7073

  • code/trunk/src/modules/questsystem/notifications/Notification.h

    r5781 r7163  
    5353        public:
    5454            Notification(BaseObject* creator);
    55             Notification(const std::string & message);
     55            Notification(BaseObject* creator, const std::string & message);
    5656            virtual ~Notification();
    5757

  • code/trunk/src/modules/questsystem/notifications/NotificationManager.cc

    r6417 r7163  
    6666    NotificationManager::~NotificationManager()
    6767    {
     68
    6869    }
    6970
    … …  
    101102                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationListener.
    102103                it->first->update(notification, time); //!< Update the listener.
     104                std::map<Notification*, unsigned int>::iterator counterIt = this->listenerCounter_.find(notification);
     105                if(counterIt == this->listenerCounter_.end())
     106                    this->listenerCounter_[notification] = 1;
     107                else
     108                    this->listenerCounter_[notification] = counterIt->second + 1;
    103109            }
    104110        }
    105111
    106         COUT(3) << "Notification registered with the NotificationManager." << std::endl;
     112        COUT(4) << "Notification registered with the NotificationManager." << std::endl;
    107113
    108114        return true;
     115    }
     116
     117    /**
     118    @brief
     119        Unregisters a Notification within the NotificationManager.
     120    @param notification
     121        A pointer to the Notification to be unregistered.
     122    @param listener
     123        A pointer to the NotificationListener the Notification is unregistered for.
     124    */
     125    void NotificationManager::unregisterNotification(Notification* notification, NotificationListener* listener)
     126    {
     127        assert(notification);
     128        assert(listener);
     129
     130        // If the Notification was removed from the list of Notifications of the input NotificationListener, the counter for the Notification of the number of NotificationListeners it is present in is decremented.
     131        if(this->removeNotification(notification, *(this->notificationLists_.find(this->listenerList_.find(listener)->second)->second)))
     132            this->listenerCounter_[notification] = this->listenerCounter_[notification] - 1;
     133
     134        // If the Notification is no longer present in any of the NotificationListeners it can be removed from the map of all Notifications and be destroyed.
     135        if(this->listenerCounter_[notification] == (unsigned int) 0)
     136        {
     137            this->removeNotification(notification, this->allNotificationsList_);
     138            this->listenerCounter_.erase(notification);
     139            notification->destroy();
     140        }
     141
     142        COUT(4) << "Notification unregistered with the NotificationManager." << std::endl;
     143    }
     144
     145    /**
     146    @brief
     147        Helper method that removes an input notification form an input map.
     148    @param notification
     149        A pointer to the notification to be removed.
     150    @param map
     151        The map the notification should be removed from.
     152    @return
     153        Returns true if successful.
     154    */
     155    bool NotificationManager::removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map)
     156    {
     157        // Iterates through all items in the map until the Notification is found.
     158        //TODO: Do more efficiently?
     159        for(std::multimap<std::time_t, Notification*>::iterator it = map.begin(); it != map.end(); it++)
     160        {
     161            if(it->second == notification)
     162            {
     163                map.erase(it);
     164                return true;
     165            }
     166        }
     167        return false;
    109168    }
    110169
    … …  
    130189        {
    131190            this->notificationLists_[index] = &this->allNotificationsList_;
    132             COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
     191            COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl;
    133192            return true;
    134193        }
    … …  
    142201            if(set.find(it->second->getSender()) != set.end()) //!< Checks whether the overlay has the sender of the current notification as target.
    143202            {
    144                 map.insert(std::pair<std::time_t,Notification*>(it->first, it->second));
     203                map.insert(std::pair<std::time_t, Notification*>(it->first, it->second));
     204                std::map<Notification*, unsigned int>::iterator counterIt = this->listenerCounter_.find(it->second);
     205                if(counterIt == this->listenerCounter_.end())
     206                    this->listenerCounter_[it->second] = 1;
     207                else
     208                    this->listenerCounter_[it->second] = counterIt->second + 1;
    145209            }
    146210        }
    … …  
    148212        listener->update(); //!< Update the listener.
    149213
    150         COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
     214        COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl;
    151215
    152216        return true;
     217    }
     218
     219    /**
     220    @brief
     221        Unregisters a NotificationListener withing the NotificationManager.
     222    */
     223    void NotificationManager::unregisterListener(NotificationListener* listener)
     224    {
     225        assert(listener);
     226
     227        int identifier = this->listenerList_.find(listener)->second;
     228        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(identifier)->second;
     229
     230        // Make sure all Notifications are removed.
     231        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
     232        while(it != map->end())
     233        {
     234            this->unregisterNotification(it->second, listener);
     235            it = map->begin();
     236        }
     237
     238        this->listenerList_.erase(listener);
     239        this->notificationLists_.erase(identifier);
     240
     241        // If the map is not the map of all notifications, delete it.
     242        if(map != &this->allNotificationsList_)
     243            delete map;
     244
     245        COUT(4) << "NotificationListener unregistered with the NotificationManager." << std::endl;
    153246    }
    154247

  • code/trunk/src/modules/questsystem/notifications/NotificationManager.h

    r5929 r7163  
    6060            virtual ~NotificationManager();
    6161
    62             static const std::string ALL;
    63             static const std::string NONE;
     62            static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationListeners.
     63            static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.
    6464
    6565            bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
     66            void unregisterNotification(Notification* notification, NotificationListener* listener); //!< Unregisters a Notification within the NotificationManager.
    6667            bool registerListener(NotificationListener* listener); //!< Registers a NotificationListener within the NotificationManager.
     68            void unregisterListener(NotificationListener* listener); //!< Unregisters a NotificationListener withing the NotificationManager.
    6769
    6870            bool getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Returns the Notifications for a specific NotificationListener in a specified timeframe.
    … …  
    9092            static NotificationManager* singletonPtr_s;
    9193
    92             int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that  no key appears twice.
     94            int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that no key appears twice.
    9395
    94             std::multimap<std::time_t,Notification*> allNotificationsList_; //!< Container where all notifications are stored (together with their respecive timestamps).
     96            std::multimap<std::time_t,Notification*> allNotificationsList_; //!< Container where all notifications are stored.
    9597            std::map<NotificationListener*,int> listenerList_; //!< Container where all NotificationListeners are stored with a number as identifier.
    9698            std::map<int,std::multimap<std::time_t,Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationListener), are stored.
     99            std::map<Notification*, unsigned int> listenerCounter_; //!< A container to store the number of NotificationListeners a Notification is registered with.
    97100
     101            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); //!< Helper method that removes an input notification form an input map.
    98102
    99103    };

  • code/trunk/src/modules/questsystem/notifications/NotificationOverlay.cc

    • Property svn:executable deleted

  • code/trunk/src/modules/questsystem/notifications/NotificationOverlay.h

    • Property svn:executable deleted

  • code/trunk/src/modules/questsystem/notifications/NotificationQueue.cc

    r6502 r7163  
    3434#include "NotificationQueue.h"
    3535
    36 #include <sstream>
    37 
     36#include "util/Convert.h"
    3837#include "core/CoreIncludes.h"
    3938#include "core/XMLPort.h"
    … …  
    5655    NotificationQueue::NotificationQueue(BaseObject* creator) : OverlayGroup(creator)
    5756    {
     57        this->registered_ = false;
     58
    5859        RegisterObject(NotificationQueue);
    5960        this->initialize();
    … …  
    6869        this->targets_.clear();
    6970        this->clear();
     71
     72        if(this->registered_)
     73            NotificationManager::getInstance().unregisterListener(this);
    7074    }
    7175
    … …  
    8185
    8286        NotificationManager::getInstance().registerListener(this);
     87        this->registered_ = true;
    8388    }
    8489
    … …  
    118123        XMLPortParam(NotificationQueue, "position", setPosition, getPosition, xmlElement, mode);
    119124
    120         COUT(3) << "NotificationQueue created." << std::endl;
     125        COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
    121126    }
    122127
    … …  
    173178        delete notifications;
    174179
    175         COUT(3) << "NotificationQueue updated." << std::endl;
     180        COUT(4) << "NotificationQueue '" << this->getName() << "' updated." << std::endl;
    176181    }
    177182
    … …  
    196201        }
    197202
    198         COUT(3) << "NotificationQueue updated. A new Notifications has been added." << std::endl;
     203        COUT(4) << "NotificationQueue '" << this->getName() << "' updated. A new Notifications has been added." << std::endl;
    199204    }
    200205
    … …  
    397402        std::string timeString = std::ctime(&time);
    398403        timeString.erase(timeString.length()-1);
    399         std::ostringstream stream;
    400         stream << reinterpret_cast<unsigned long>(notification);
    401         const std::string& addressString = stream.str();
     404        const std::string& addressString = multi_cast<std::string>(reinterpret_cast<unsigned long>(notification));
    402405        container->name = "NotificationOverlay(" + timeString + ")&" + addressString;
    403406
    … …  
    422425        if(this->size_ == 0) //!< You cannot remove anything if the queue is empty.
    423426            return false;
     427
     428        // Unregister the NotificationQueue with the NotificationManager.
     429        NotificationManager::getInstance().unregisterNotification(container->notification, this);
    424430
    425431        this->removeElement(container->overlay);
    … …  
    443449        {
    444450            this->removeContainer(*it);
    445             it = this->containers_.begin(); //TODO: Needed?
     451            it = this->containers_.begin();
    446452        }
    447453    }

  • code/trunk/src/modules/questsystem/notifications/NotificationQueue.h

    r5781 r7163  
    7171
    7272        Creating a NotificationQueue through XML goes as follows:
     73        Be aware that the NotificationQueue must be inside the <Level></Level> tags or bad things will happen.
    7374        <NotificationQueue
    7475            name = "SuperQueue" //Name of your OverlayQueue.
    … …  
    185186            NotificationOverlayContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
    186187
     188            bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already.
     189
    187190            void initialize(void); //!< Initializes the object.
    188191            void setDefaults(void); //!< Helper method to set the default values.

  • code/trunk/src/modules/weapons/CMakeLists.txt

    r5781 r7163  
    11SET_SOURCE_FILES(WEAPONS_SRC_FILES
    22  MuzzleFlash.cc
     3  RocketController.cc
    34)
    45
    … …  
    1213  PCH_FILE
    1314    WeaponsPrecompiledHeaders.h
    14   DEFINE_SYMBOL
    15     "WEAPONS_SHARED_BUILD"
    1615  LINK_LIBRARIES
    1716    orxonox

  • code/trunk/src/modules/weapons/WeaponsPrereqs.h

    r5929 r7163  
    4343//-----------------------------------------------------------------------
    4444
    45 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
     45#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(WEAPONS_STATIC_BUILD)
    4646#  ifdef WEAPONS_SHARED_BUILD
    4747#    define _WeaponsExport __declspec(dllexport)

  • code/trunk/src/modules/weapons/projectiles/CMakeLists.txt

    r6417 r7163  
    55  LightningGunProjectile.cc
    66  Rocket.cc
     7  SimpleRocket.cc
    78)

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

    r6540 r7163  
    4141#include "controllers/Controller.h"
    4242#include "sound/WorldSound.h"
     43#include "Scene.h"
    4344
    4445namespace orxonox
    … …  
    8788            this->defSndWpnEngine_->setLooping(true);
    8889            this->defSndWpnEngine_->setSource("sounds/Rocket_engine.ogg");
     90            this->defSndWpnEngine_->setVolume(100);
    8991            this->attach(defSndWpnEngine_);
    9092
    … …  
    9294            this->defSndWpnLaunch_->setLooping(false);
    9395            this->defSndWpnLaunch_->setSource("sounds/Rocket_launch.ogg");
     96            this->defSndWpnLaunch_->setVolume(100);
    9497            this->attach(defSndWpnLaunch_);
    9598        }
    … …  
    114117        if(this->isInitialized())
    115118        {
    116             if (GameMode::isMaster() && this->player_)
    117                 this->player_->stopTemporaryControl();
     119            if (GameMode::isMaster())
     120            {
     121                this->destructionEffect();
     122
     123                if (this->getPlayer() && this->getController())
     124                    this->player_->stopTemporaryControl();
     125            }
    118126
    119127            if ( this->defSndWpnEngine_ )
    … …  
    138146    {
    139147        this->owner_ = owner;
    140         this->originalControllableEntity_ = this->owner_->getPlayer()->getControllableEntity();
    141148        this->player_ = this->owner_->getPlayer();
    142149        this->owner_->getPlayer()->startTemporaryControl(this);
    … …  
    164171            this->setVelocity( this->getOrientation()*WorldEntity::FRONT*this->getVelocity().length() );
    165172            this->localAngularVelocity_ = 0;
    166 
     173        }
     174
     175        if( GameMode::isMaster() )
     176        {
    167177            if( this->bDestroy_ )
    168178                this->destroy();
     179
    169180        }
    170181    }
    … …  
    222233    void Rocket::fired(unsigned int firemode)
    223234    {
    224         if (this->owner_)
    225         {
    226             {
    227                 ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    228                 effect->setPosition(this->getPosition());
    229                 effect->setOrientation(this->getOrientation());
    230                 effect->setDestroyAfterLife(true);
    231                 effect->setSource("Orxonox/explosion4");
    232                 effect->setLifetime(2.0f);
    233             }
    234 
    235             {
    236                 ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    237                 effect->setPosition(this->getPosition());
    238                 effect->setOrientation(this->getOrientation());
    239                 effect->setDestroyAfterLife(true);
    240                 effect->setSource("Orxonox/smoke4");
    241                 effect->setLifetime(3.0f);
    242             }
     235//         if (this->owner_)
     236//         {
    243237            this->destroy();
    244         }
     238//         }
     239    }
     240   
     241    void Rocket::destructionEffect()
     242    {
     243        ParticleSpawner *effect1, *effect2;
     244        if( this->owner_ )
     245        {
     246            effect1 = new ParticleSpawner(this->owner_->getCreator());
     247            effect2 = new ParticleSpawner(this->owner_->getCreator());
     248        }
     249        else
     250        {
     251            effect1 = new ParticleSpawner(static_cast<BaseObject*>(this->getScene().get()));
     252            effect2 = new ParticleSpawner(static_cast<BaseObject*>(this->getScene().get()));
     253        }
     254       
     255        effect1->setPosition(this->getPosition());
     256        effect1->setOrientation(this->getOrientation());
     257        effect1->setDestroyAfterLife(true);
     258        effect1->setSource("Orxonox/explosion4");
     259        effect1->setLifetime(2.0f);
     260       
     261        effect2->setPosition(this->getPosition());
     262        effect2->setOrientation(this->getOrientation());
     263        effect2->setDestroyAfterLife(true);
     264        effect2->setSource("Orxonox/smoke4");
     265        effect2->setLifetime(3.0f);
    245266    }
    246267

  • code/trunk/src/modules/weapons/projectiles/Rocket.h

    r6417 r7163  
    5757            virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
    5858            void destroyObject();
     59            void destructionEffect();
    5960
    6061            virtual void moveFrontBack(const Vector2& value){}
    … …  
    119120            float damage_;
    120121            bool bDestroy_;
    121             ControllableEntity* originalControllableEntity_;
    122122
    123123            WeakPtr<PlayerInfo> player_;

  • code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt

    r6417 r7163  
    66  LightningGun.cc
    77  RocketFire.cc
     8  SimpleRocketFire.cc
    89)
Note: See TracChangeset for help on using the changeset viewer.