MultiTrigger.h

Go to the documentation of this file.

/*
 *   ORXONOX - the hottest 3D action shooter ever to exist
 *                    > www.orxonox.net <
 *
 *
 *   License notice:
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *   Author:
 *      Damian 'Mozork' Frick
 *   Co-authors:
 *      ...
 *
*/

#ifndef _MultiTrigger_H__
#define _MultiTrigger_H__

#include "objects/ObjectsPrereqs.h"

#include "core/BaseObject.h"
#include "core/ClassTreeMask.h"

#include <set>
#include <deque>

#include "TriggerBase.h"

namespace orxonox
{

    struct MultiTriggerState
    {
        BaseObject* originator;
        bool bTriggered;
    };

    class _ObjectsExport MultiTrigger : public TriggerBase
    {
        public:
            MultiTrigger(Context* context); 
            virtual ~MultiTrigger(); 

            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); 
            virtual void tick(float dt); 

            inline bool isActive(void) const
                { return this->isActive(nullptr); }
            bool isActive(BaseObject* triggerer = nullptr) const; 

            inline void setSimultaneousTriggerers(int triggerers)
                { if(triggerers >= 0 || triggerers == TriggerBase::INF_s) this->maxNumSimultaneousTriggerers_ = triggerers; }
            inline int getSimultaneousTriggerers(void)
                { return this->maxNumSimultaneousTriggerers_; }

            inline void setBroadcast(bool bBroadcast)
                { this->bBroadcast_ = bBroadcast; }
            inline bool getBroadcast(void)
                { return this->bBroadcast_; }

            inline bool isTarget(BaseObject* target)
                { if(target == nullptr) return true; else return targetMask_.isIncluded(target->getIdentifier()); }
                
            void addTarget(const std::string& targets); 

        protected:
            virtual std::queue<MultiTriggerState*>* letTrigger(void); 

            void changeTriggered(BaseObject* originator = nullptr); 

            bool isModeTriggered(BaseObject* triggerer = nullptr); 
            bool isTriggered(BaseObject* triggerer = nullptr); 

            virtual void fire(bool status, BaseObject* originator = nullptr);  
            void broadcast(bool status); 

            void removeTarget(const std::string& target); 

            inline ClassTreeMask& getTargetMask(void)
                { return this->targetMask_; }

        private:
            void childActivityChanged(BaseObject* originator); 

            bool addState(MultiTriggerState* state); 

            bool checkAnd(BaseObject* triggerer); 
            bool checkOr(BaseObject* triggerer); 
            bool checkXor(BaseObject* triggerer); 

            std::set<BaseObject*>& getActive(void)
                { return this->active_; }

            int maxNumSimultaneousTriggerers_; 

            bool bBroadcast_; 

            std::set<BaseObject*> active_; 
            std::set<BaseObject*> triggered_; 

            std::deque<std::pair<float, MultiTriggerState*>> stateQueue_; 

            ClassTreeMask targetMask_; 

    };

}

#endif // _MultiTrigger_H__