Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/ScriptableController_HS17/src/orxonox/LevelInfo.cc @ 12227

Last change on this file since 12227 was 11356, checked in by patricwi, 8 years ago

merged space race with trunk

  • Property svn:eol-style set to native
File size: 9.9 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Damian 'Mozork' Frick
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "LevelInfo.h"
30
31#include <sstream>
32#include <vector>
33
34#include "util/SubString.h"
35#include "core/CoreIncludes.h"
36#include "core/XMLPort.h"
37
38#include "LevelManager.h"
39
40namespace orxonox
41{
42
43    // LevelInfoItem
44
45    //! The list of allowed tags.
46    /*static*/ std::set<std::string> LevelInfoItem::possibleTags_s = std::set<std::string>();
47
48    /**
49    @brief
50        Default constructor.
51    */
52    LevelInfoItem::LevelInfoItem()
53    {
54
55    }
56
57    /**
58    @brief
59        Constructor. Initializes the object.
60    @param name
61        The name of the Level.
62    @param filename
63        The XML-filename of the Level.
64    */
65    LevelInfoItem::LevelInfoItem(const std::string& name, const std::string filename)
66    {
67        this->setName(name);
68        this->setXMLFilename(filename);
69    }
70
71    /**
72    @brief
73        Destructor.
74    */
75    LevelInfoItem::~LevelInfoItem()
76    {
77
78    }
79
80    /**
81    @brief
82        Initialize the set of allowed tags.
83    */
84    /*static*/ void LevelInfoItem::initializeTags(void)
85    {
86        if(!LevelInfoItem::initialized_s)
87        {
88            LevelInfoItem::possibleTags_s.insert("test");
89            LevelInfoItem::possibleTags_s.insert("showcase");
90            LevelInfoItem::possibleTags_s.insert("tutorial");
91            LevelInfoItem::possibleTags_s.insert("presentation");
92            LevelInfoItem::possibleTags_s.insert("mission");
93            LevelInfoItem::possibleTags_s.insert("gametype");
94            LevelInfoItem::possibleTags_s.insert("minigame");
95            LevelInfoItem::possibleTags_s.insert("shipselection");
96        }
97    }
98
99    /**
100    @brief
101        Set the tags the Level is tagged with.
102    @param tags
103        A comma-seperated string of all the tags to be set.
104    */
105    void LevelInfoItem::setTags(const std::string& tags)
106    {
107        SubString substr = SubString(tags, ",", " "); // Split the string into tags.
108        const std::vector<std::string>& tokens = substr.getAllStrings();
109        for (const std::string& token : tokens)
110            this->addTag(token, false);
111
112        this->tagsUpdated();
113    }
114    /**
115    @brief
116        Set the starting ship models of the level
117    @param ships
118        A comma-seperated string of all the allowed ship models for the shipselection.
119    */
120    void LevelInfoItem::setStartingShips(const std::string& ships)
121    {
122        SubString substr = SubString(ships, ",", " "); // Split the string into tags.
123        const std::vector<std::string>& tokens = substr.getAllStrings();
124        for(const std::string& token : tokens)
125            this->addStartingShip(token, false);
126
127        this->startingshipsUpdated();
128    }
129
130    /**
131    @brief
132        Add a tag to the set of tags the Level is tagged with.
133    @param tag
134        The tag to be added.
135    @param update
136        Whether the comma-seperated string of all tags should be updated. Default is true.
137    @return
138        Returns true if the tag was successfully added, if the tag was already present it returns false.
139    */
140    bool LevelInfoItem::addTag(const std::string& tag, bool update)
141    {
142        if(!this->validateTag(tag))
143        {
144            orxout(internal_warning) << "Bad LevelInfo tag '" << tag << "' in " << this->getXMLFilename() << ". Ignoring..." << endl;
145            return false;
146        }
147        bool success = this->tags_.insert(*LevelInfoItem::possibleTags_s.find(tag)).second;
148        if(update && success)
149            this->tagsUpdated();
150        return success;
151    }
152
153    bool LevelInfoItem::addHighscore(const std::string& name, const int score)
154    {
155        std::stringstream stream;
156        stream << name << "/:/" << score;
157        bool success = this->highscores_.insert(stream.str()).second;
158        if(success)
159            this->highscoresUpdated();
160        return success;
161    }
162
163    /**
164    @brief
165        Add a ship model to allowed models for the shipselection
166    @param ship
167        The ship model to be added.
168    @param update
169        Whether the comma-seperated string of all ship models should be updated. Default is true.
170    @return
171        Returns true if the ship was successfully added, if the ship was already present it returns false.
172    */
173    bool LevelInfoItem::addStartingShip(const std::string& ship, bool update)
174    {
175        bool success = this->startingShips_.insert(ship).second;
176        if(update && success)
177            this->startingshipsUpdated();
178
179        return success;
180    }
181
182
183    /**
184    @brief
185        Updates the comma-seperated string of all tags, if the set of tags has changed.
186    */
187    void LevelInfoItem::tagsUpdated(void)
188    {
189        std::stringstream stream;
190        std::set<std::string>::iterator temp;
191        for(std::set<std::string>::iterator it = this->tags_.begin(); it != this->tags_.end(); )
192        {
193            temp = it;
194            if(++it == this->tags_.end()) // If this is the last tag we don't add a comma.
195                stream << *temp;
196            else
197                stream << *temp << ", ";
198        }
199
200        this->tagsString_ = std::string(stream.str());
201    }
202
203    void LevelInfoItem::highscoresUpdated(void)
204    {
205        std::stringstream stream;
206        std::set<std::string>::iterator temp;
207        for(std::set<std::string>::iterator it = this->highscores_.begin(); it != this->highscores_.end(); )
208        {
209            temp = it;
210            if(++it == this->highscores_.end()) // If this is the last tag we don't add a comma.
211                stream << *temp;
212            else
213                stream << *temp << ", ";
214        }
215
216        this->highscoresString_ = std::string(stream.str());
217    }
218    /**
219    @brief
220        Updates the comma-seperated string of all ships, if the set of tags has changed.
221    */
222    void LevelInfoItem::startingshipsUpdated(void)
223    {
224        std::stringstream stream;
225        std::set<std::string>::iterator temp;
226        for(std::set<std::string>::iterator it = this->startingShips_.begin(); it != this->startingShips_.end(); )
227        {
228            temp = it;
229            if(++it == this->startingShips_.end()) // If this is the last ship we don't add a comma.
230                stream << *temp;
231            else
232                stream << *temp << ", ";
233        }
234
235        this->startingShipsString_ = std::string(stream.str());
236    }
237
238    void LevelInfoItem::changeStartingShip(const std::string& model)
239    {
240        static std::string shipSelectionTag = "shipselection";
241        //HACK: Read Level XML File, find "shipselection", replace with ship model
242        std::string levelPath = "../levels/";
243        levelPath.append(this->getXMLFilename());
244        std::string tempPath = "../levels/";
245        tempPath.append("_temp.oxw");
246        orxout(user_status) << levelPath << endl;
247        orxout(user_status) << tempPath << endl;
248        std::ifstream myLevel (levelPath.c_str());
249        std::ofstream tempLevel (tempPath.c_str());
250        while(!myLevel.eof())
251        {
252            std::string buff;
253            std::getline(myLevel, buff);
254            std::string pawndesignString = "pawndesign=";
255            size_t found = buff.find(pawndesignString.append(shipSelectionTag));
256            if (found!= std::string::npos)
257                buff = buff.substr(0, found + 11) + model + buff.substr(found+11+shipSelectionTag.length(), std::string::npos);
258            tempLevel.write(buff.c_str(), buff.length());
259            tempLevel << std::endl;
260        }
261        myLevel.close();
262        tempLevel.close();
263        orxout(user_status) << "done" << endl;
264    }
265
266
267    // LevelInfo
268
269    RegisterClass(LevelInfo);
270
271    LevelInfo::LevelInfo(Context* context) : BaseObject(context)
272    {
273        RegisterObject(LevelInfo);
274
275        this->xmlfilename_ = this->getFilename();
276    }
277
278    /**
279    @brief
280        Destructor.
281    */
282    LevelInfo::~LevelInfo()
283    {
284
285    }
286
287    /**
288    @brief
289        Creates a LevelInfo object through XML.
290    */
291    void LevelInfo::XMLPort(Element& xmlelement, XMLPort::Mode mode)
292    {
293        SUPER(LevelInfo, XMLPort, xmlelement, mode);
294
295        XMLPortParam(LevelInfo, "description", setDescription, getDescription, xmlelement, mode);
296        XMLPortParam(LevelInfo, "screenshot", setScreenshot, getScreenshot, xmlelement, mode);
297        XMLPortParam(LevelInfo, "tags", setTags, getTags, xmlelement, mode);
298        XMLPortParam(LevelInfo, "startingships", setStartingShips, getStartingShips, xmlelement, mode);
299    }
300
301    /**
302    @brief
303        Copies the contents of this LevelInfo object to a new LevelInfoItem object.
304        This is needed, because a LeveInfo object is only created within the scope of the XML-file it is loaded with and is destroyed once that is unloaded.
305    @return
306        Returns a new LevelInfoItem with the same contents as the LevelInfo object.
307    */
308    LevelInfoItem* LevelInfo::copy(void)
309    {
310        LevelInfoItem* info = new LevelInfoItem(this->BaseObject::getName(), this->getXMLFilename());
311        info->setDescription(this->getDescription());
312        info->setScreenshot(this->getScreenshot());
313        info->setTags(this->getTags());
314        info->setStartingShips(this->getStartingShips());
315        return info;
316    }
317
318}
319
Note: See TracBrowser for help on using the repository browser.