trigger.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_TRIGGER_H
#define FIFE_TRIGGER_H

// Standard C++ library includes
#include <vector>
#include <string>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/base/fifeclass.h"

namespace FIFE {
    class Cell;
    class Layer;
    class Instance;
    class TriggerChangeListener;

    class ITriggerListener {
    public:
        virtual ~ITriggerListener() {};

        virtual void onTriggered() = 0;
    };

    enum TriggerCondition {
        // cell conditions
        CELL_TRIGGER_ENTER = 0,
        CELL_TRIGGER_EXIT,
        CELL_TRIGGER_BLOCKING_CHANGE,
        // instance conditions
        INSTANCE_TRIGGER_LOCATION,
        INSTANCE_TRIGGER_ROTATION,
        INSTANCE_TRIGGER_SPEED,
        INSTANCE_TRIGGER_ACTION,
        INSTANCE_TRIGGER_TIME_MULTIPLIER,
        INSTANCE_TRIGGER_SAYTEXT,
        INSTANCE_TRIGGER_BLOCK,
        INSTANCE_TRIGGER_CELL,
        INSTANCE_TRIGGER_TRANSPARENCY,
        INSTANCE_TRIGGER_VISIBLE,
        INSTANCE_TRIGGER_STACKPOS,
        INSTANCE_TRIGGER_VISUAL,
        INSTANCE_TRIGGER_DELETE
    };

    // FORWARD REFERENCES

    class Trigger : public FifeClass {
    public:

    // LIFECYCLE

        Trigger();

        Trigger(const std::string& name);

        virtual ~Trigger();

        void addTriggerListener(ITriggerListener* listener);

        void removeTriggerListener(ITriggerListener* listener);

        void reset();

        const std::string& getName() const { return m_name; };

        bool isTriggered() { return m_triggered; };

        void setTriggered();

        void addTriggerCondition(TriggerCondition type);

        const std::vector<TriggerCondition>& getTriggerConditions();

        void removeTriggerCondition(TriggerCondition type);

        void enableForInstance(Instance* instance);

        const std::vector<Instance*>& getEnabledInstances();

        void disableForInstance(Instance* instance);

        void enableForAllInstances();

        bool isEnabledForAllInstances();

        void disableForAllInstances();

        void assign(Layer* layer, const ModelCoordinate& pt);

        void remove(Layer* layer, const ModelCoordinate& pt);

        void assign(Cell* cell);

        void remove(Cell* cell);

        const std::vector<Cell*>& getAssignedCells();

        void attach(Instance* instance);

        void detach();

        Instance* getAttached() { return m_attached; }

        void move();

        void moveTo(const ModelCoordinate& newPos, const ModelCoordinate& oldPos);

    private:
        std::string m_name;

        bool m_triggered;

        bool m_enabledAll;

        std::vector<ITriggerListener*> m_triggerListeners;

        TriggerChangeListener* m_changeListener;
        
        std::vector<Cell*> m_assigned;

        std::vector<TriggerCondition> m_triggerConditions;

        std::vector<Instance*> m_enabledInstances;

        Instance* m_attached;
    };
} //FIFE

#endif