cell.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 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_CELL_H
#define FIFE_CELL_H

// Standard C++ library includes
#include <vector>
#include <set>
#include <list>
#include <map>

// 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"
#include "model/metamodel/modelcoords.h"


namespace FIFE {

    class Instance;
    class Layer;
    class Cell;
    class Zone;

    static const double MIN_CELL_Z = -9999999;

    enum CellType {
        CTYPE_NO_BLOCKER = 0,
        CTYPE_CELL_NO_BLOCKER = 1,
        CTYPE_DYNAMIC_BLOCKER = 2,
        CTYPE_STATIC_BLOCKER = 3,
        CTYPE_CELL_BLOCKER = 4
    };
    typedef uint8_t CellTypeInfo;

    class TransitionInfo {
        public:
            TransitionInfo(Layer* layer) { m_layer = layer; m_difflayer = false; m_immediate = true;}
            ~TransitionInfo() {};
            Layer* m_layer;
            ModelCoordinate m_mc;
            bool m_difflayer;
            bool m_immediate;
    };

    class CellDeleteListener {
    public:
        virtual ~CellDeleteListener() {};
        
        virtual void onCellDeleted(Cell* cell) = 0;
    };
    
    class CellChangeListener {
    public:
        virtual ~CellChangeListener() {};
        
        virtual void onInstanceEnteredCell(Cell* cell, Instance* instance) = 0;

        virtual void onInstanceExitedCell(Cell* cell, Instance* instance) = 0;

        virtual void onBlockingChangedCell(Cell* cell, CellTypeInfo type, bool blocks) = 0;
    };

    class Cell: public FifeClass, public CellDeleteListener {
        public:
            Cell(int32_t coordint, ModelCoordinate coordinate, Layer* layer);
            
            ~Cell();

            void addInstances(const std::list<Instance*>& instances);
            
            void addInstance(Instance* instance);

            void changeInstance(Instance* instance);

            void removeInstance(Instance* instance);

            bool isNeighbor(Cell* cell);

            void updateCellInfo();

            bool defaultCost();

            void setCostMultiplier(double multi);

            double getCostMultiplier();

            void resetCostMultiplier();

            bool defaultSpeed();

            void setSpeedMultiplier(double multi);

            double getSpeedMultiplier();

            void resetSpeedMultiplier();

            Zone* getZone();

            void setZone(Zone* zone);

            void resetZone();

            bool isInserted();

            void setInserted(bool inserted);

            bool isZoneProtected();

            void setZoneProtected(bool protect);

            CellTypeInfo getCellType();

            void setCellType(CellTypeInfo type);

            const std::set<Instance*>& getInstances();

            void setCellId(int32_t id);

            int32_t getCellId();

            const ModelCoordinate getLayerCoordinates() const;

            void addNeighbor(Cell* cell);

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

            void resetNeighbors();

            Layer* getLayer();

            void createTransition(Layer* layer, const ModelCoordinate& mc, bool immediate = false);

            void deleteTransition();

            TransitionInfo* getTransition();

            void addDeleteListener(CellDeleteListener* listener);

            void removeDeleteListener(CellDeleteListener* listener);

            void onCellDeleted(Cell* cell);

            void addChangeListener(CellChangeListener* listener);

            void removeChangeListener(CellChangeListener* listener);

            void callOnInstanceEntered(Instance* instance);

            void callOnInstanceExited(Instance* instance);

            void callOnBlockingChanged(bool blocks);

        private:

            void updateCellBlockingInfo();

            int32_t m_coordId;
            
            ModelCoordinate m_coordinate;

            Layer* m_layer;

            Zone* m_zone;

            TransitionInfo* m_transition;

            bool m_inserted;

            bool m_protect;

            CellTypeInfo m_type;

            // contained Instances
            std::set<Instance*> m_instances;

            std::vector<Cell*> m_neighbors;

            std::vector<CellDeleteListener*> m_deleteListeners;

            std::vector<CellChangeListener*> m_changeListeners;
    };

} // FIFE

#endif