TriggerBase.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 _TriggerBase_H__
#define _TriggerBase_H__

#include "objects/ObjectsPrereqs.h"

#include <set>
#include <string>

#include "tools/interfaces/Tickable.h"
#include "worldentities/StaticEntity.h"

namespace orxonox {

    enum class TriggerMode
    {
        EventTriggerAND, 
        EventTriggerOR, 
        EventTriggerXOR, 
    };

    class _ObjectsExport TriggerBase : public StaticEntity, public Tickable
    {
        public:
            TriggerBase(Context* context);
            virtual ~TriggerBase();

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

            virtual bool isActive(void) const
                { return false; }

            inline void setDelay(float delay)
                { if(delay > 0.0f) this->delay_= delay; this->delayChanged(); }
            inline float getDelay(void) const
                { return this->delay_; }
            virtual void delayChanged(void) {}

            inline void setSwitch(bool bSwitch)
                { this->bSwitch_ = bSwitch; }
            inline bool getSwitch(void) const
                { return this->bSwitch_; }

            inline void setStayActive(bool bStayActive)
                { this->bStayActive_ = bStayActive; }
            inline bool getStayActive(void) const
                { return this->bStayActive_; }

            inline int getActivations(void) const
                { return this->remainingActivations_; }
            inline bool hasRemainingActivations(void) const
                { return this->remainingActivations_ > 0 || this->remainingActivations_ == INF_s; }

            inline void setInvert(bool bInvert)
                { this->bInvertMode_ = bInvert; }
            inline bool getInvert(void) const
                { return this->bInvertMode_; }

            void setMode(const std::string& modeName); 

            inline void setMode(TriggerMode mode) 
                { this->mode_ = mode; }
            const std::string& getModeString(void) const;
            inline TriggerMode getMode(void) const
                { return mode_; }

            void addTrigger(TriggerBase* trigger);
            const TriggerBase* getTrigger(unsigned int index) const;

            inline bool isMultiTrigger(void)
                { return this->bMultiTrigger_; }

        protected:
            static const int INF_s; 
            static const std::string and_s;
            static const std::string or_s;
            static const std::string xor_s;

            inline void setActivations(int activations)
                { if(activations >= 0 || activations == INF_s) this->remainingActivations_ = activations; }
                
            inline bool hasRemainingActivations(void)
                { return this->remainingActivations_ == INF_s || this->remainingActivations_  > 0; }

            inline void addParentTrigger(TriggerBase* parent)
                { this->parent_ = parent; }

            bool bFirstTick_; 

            float delay_; 
            bool bSwitch_; 
            bool bStayActive_; 

            int remainingActivations_; 

            bool bInvertMode_; 
            TriggerMode mode_; 

            TriggerBase* parent_; 
            std::set<TriggerBase*> children_; 

            bool bMultiTrigger_; 

    };
}

#endif /* _Trigger_H__ */