laPropertyList.h

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/
#ifndef M_PROPERTY_LIST
#define M_PROPERTY_LIST



class laPropertyList: public laLoadableObj
{
protected:

    // Name of the TS element
    char    _strName[32];

    M_BOOL _bReadName;      // nested list tweak
    friend class laTypedObject;

    laPropertyList* _pParent;

    // Map of components
    //
    // Implementation NOTE:
    // Sotred in separate maps for each type, in order
    // to improve retreival speed
    //
    // Implementation NOTE:
    // Instead of locating components in run-time,
    // dynamic objects should store a pointer to the components they need
    // ( e.g. in the load() or create() functions )
    //
    std::map<std::string, M_BOOL>       _mapBool;
    std::map<std::string, int>          _mapInt;
    std::map<std::string, double>       _mapDouble;
    std::map<std::string, laColor>      _mapColor;
    std::map<std::string, laPoint3> _mapPoint;

    std::map<std::string, rpgAttack>    _mapAttack;
    //std::map<std::string, rpgTrap>    _mapTrap;

    std::map<std::string, char*>                        _mapText;
    std::map<std::string, class laAnimatedModel*>   _mapModel;
    std::map<std::string, class fxParticleSystem*>          _mapFx;

    std::vector<class laAnimatedModel*> _vModel;
    std::vector<class fxParticleSystem*>        _vFx;

    std::map<std::string, class laPropertyList*>            _mapChildren;

    void _read_components(laFileParser* fp, char* strEndTag);

public:
    laPropertyList(void);
    virtual ~laPropertyList(void);

    void discard();

    // This method is part of the laLoadableObj interface
    virtual void load(class laFileParser *fp);

    // Get TS element name
    char*   name()  { return _strName; }

    // Components
    //
    M_BOOL getBool(std::string name);
    int getInt(std::string name);
    double getDouble(std::string name);
    char* getText(std::string name);
    laColor getColor(std::string name);
    laPoint3 getPoint(std::string name);
    rpgAttack attack(std::string name);
    /*rpgTrap trap(std::string name);*/
    laAnimatedModel* getModel(std::string name);
    fxParticleSystem* getFx(std::string name);

    // Hierarchy tree
    //
    laPropertyList* getChild(std::string name);

    laPropertyList* getParent() { return _pParent; }

    laPropertyList* getTopmost();/* {
        if(_pParent)
            return _pParent->getTopmost();
        return this;
    }*/

    // Models and Fx components
    //
    laAnimatedModel*   getModel(unsigned i);
    unsigned              getModelCnt() {return _vModel.size(); }

    fxParticleSystem*         getFx(unsigned i);
    unsigned              getFxCnt() {return _vFx.size(); }
};
#endif