LevelInfo.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 _LevelInfo_H__
#define _LevelInfo_H__

#include "OrxonoxPrereqs.h"

#include <set>
#include <string>
#include "util/StringUtils.h"

#include "core/BaseObject.h"
#include <iostream>
#include <fstream>
#include "core/class/OrxonoxInterface.h"

namespace orxonox // tolua_export
{ // tolua_export

    class _OrxonoxExport LevelInfoItem // tolua_export
        : virtual public OrxonoxInterface
    { // tolua_export
        public:
            LevelInfoItem(); 
            LevelInfoItem(const std::string& name, const std::string filename); 
            virtual ~LevelInfoItem(); 

            inline void setName(const std::string& name)
                { this->name_ = std::string(name); }
            inline const std::string& getName(void) const { return this->name_; } // tolua_export

            inline void setScreenshot(const std::string& screenshot) { this->screenshot_ = std::string(screenshot); }
            inline const std::string& getScreenshot() const { return this->screenshot_; } // tolua_export

            inline void setDescription(const std::string& description)
                { this->description_ = std::string(description); }
            inline const std::string& getDescription() const { return this->description_; } // tolua_export

            void setTags(const std::string& tags); 
            bool addTag(const std::string& tag, bool update = true); 

            inline const std::string& getTags(void) const
                { return this->tagsString_; }
            inline bool hasTag(const std::string& tag) const { return this->tags_.find(tag) != this->tags_.end(); } // tolua_export

            void setStartingShips(const std::string& ships); 
            bool addStartingShip(const std::string& ship, bool update = true); 

            inline const std::string& getStartingShips(void) const
                { return this->startingShipsString_; }
            inline bool hasStartingShip(const std::string& ship) const { return this->startingShips_.find(ship) != this->startingShips_.end(); } // tolua_export
            inline void selectStartingShip(const std::string& ship) { this->changeStartingShip(ship); } // tolua_export
            inline const std::string& getXMLFilename(void) const { return this->xmlfilename_; } // tolua_export


        protected:
            inline void setXMLFilename(const std::string& filename)
                { this->xmlfilename_ = std::string(filename); }

            std::string xmlfilename_; 

        private:
            void changeStartingShip (const std::string& model);
            void startingshipsUpdated(void); 
            void tagsUpdated(void); 
            static void initializeTags(void); 

            static bool validateTag(const std::string& tag)
                { LevelInfoItem::initializeTags(); return LevelInfoItem::possibleTags_s.find(tag) != LevelInfoItem::possibleTags_s.end(); }

            static std::set<std::string> possibleTags_s; 
            static const bool initialized_s = false; 

            std::string name_; 
            std::string description_; 
            std::string screenshot_; 
            std::set<std::string> tags_; 
            std::string tagsString_; 
            std::set<std::string> startingShips_; 
            std::string startingShipsString_; 
    }; // tolua_export

    class _OrxonoxExport LevelInfo : public BaseObject, public LevelInfoItem
    {
        public:
            LevelInfo(Context* context);
            virtual ~LevelInfo();

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

            inline void setScreenshot(const std::string& screenshot) { this->LevelInfoItem::setScreenshot(screenshot); }
            inline const std::string& getScreenshot() const { return this->LevelInfoItem::getScreenshot(); }

            inline void setDescription(const std::string& description)
                { this->LevelInfoItem::setDescription(description); }
            inline const std::string& getDescription() const
                { return this->LevelInfoItem::getDescription(); }

            inline void setTags(const std::string& tags)
                { this->LevelInfoItem::setTags(tags); }
            inline const std::string& getTags(void) const
                { return this->LevelInfoItem::getTags(); }
            inline void setStartingShips(const std::string& ships)
                { this->LevelInfoItem::setStartingShips(ships); }
            inline const std::string& getStartingShips(void) const
                { return this->LevelInfoItem::getStartingShips(); }

            LevelInfoItem* copy(void); 
    };

    struct LevelInfoCompare
    {
        bool operator() (const LevelInfoItem* lhs, const LevelInfoItem* rhs) const
            {
                if(getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) == 0)
                    return getLowercase(lhs->getXMLFilename()).compare(getLowercase(rhs->getXMLFilename())) < 0;
                return getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) < 0;
            }
    };

} // tolua_export

#endif /* _LevelInfo_H__ */