src/supertux/level.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "supertux/level.hpp"
  18
  19 #include "lisp/list_iterator.hpp"
  20 #include "lisp/parser.hpp"
  21 #include "object/bonus_block.hpp"
  22 #include "object/coin.hpp"
  23 #include "supertux/sector.hpp"
  24 #include "supertux/tile_manager.hpp"
  25 #include "supertux/tile_set.hpp"
  26 #include "trigger/secretarea_trigger.hpp"
  27
  28 #include <sstream>
  29 #include <stdexcept>
  30
  31 using namespace std;
  32
  33 Level::Level() :
  34   name("noname"),
  35   author("Mr. X"),
  36   contact(),
  37   license(),
  38   filename(),
  39   on_menukey_script(),
  40   sectors(),
  41   stats(),
  42   tileset(NULL),
  43   free_tileset(false)
  44 {
  45 }
  46
  47 Level::~Level()
  48 {
  49   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
  50     delete *i;
  51   if(free_tileset)
  52     delete tileset;
  53 }
  54
  55 void
  56 Level::load(const std::string& filepath)
  57 {
  58   try {
  59     filename = filepath;
  60     lisp::Parser parser;
  61     const lisp::Lisp* root = parser.parse(filepath);
  62
  63     const lisp::Lisp* level = root->get_lisp("supertux-level");
  64     if(!level)
  65       throw std::runtime_error("file is not a supertux-level file.");
  66
  67     int version = 1;
  68     level->get("version", version);
  69     if(version == 1) {
  70       log_info << "level uses old format: version 1" << std::endl;
  71       tileset = tile_manager->get_tileset("images/tiles.strf");
  72       load_old_format(*level);
  73       return;
  74     }
  75
  76     const lisp::Lisp* tilesets_lisp = level->get_lisp("tilesets");
  77     if(tilesets_lisp != NULL) {
  78       tileset      = tile_manager->parse_tileset_definition(*tilesets_lisp);
  79       free_tileset = true;
  80     }
  81     std::string tileset_name;
  82     if(level->get("tileset", tileset_name)) {
  83       if(tileset != NULL) {
  84         log_warning << "multiple tilesets specified in level" << std::endl;
  85       } else {
  86         tileset = tile_manager->get_tileset(tileset_name);
  87       }
  88     }
  89     /* load default tileset */
  90     if(tileset == NULL) {
  91       tileset = tile_manager->get_tileset("images/tiles.strf");
  92     }
  93     current_tileset = tileset;
  94
  95     contact = "";
  96     license = "";
  97
  98     lisp::ListIterator iter(level);
  99     while(iter.next()) {
 100       const std::string& token = iter.item();
 101       if(token == "version") {
 102         iter.value()->get(version);
 103         if(version > 2) {
 104           log_warning << "level format newer than application" << std::endl;
 105         }
 106       } else if(token == "tileset" || token == "tilesets") {
 107         continue;
 108       } else if(token == "name") {
 109         iter.value()->get(name);
 110       } else if(token == "author") {
 111         iter.value()->get(author);
 112       } else if(token == "contact") {
 113         iter.value()->get(contact);
 114       } else if(token == "license") {
 115         iter.value()->get(license);
 116       } else if(token == "on-menukey-script") {
 117         iter.value()->get(on_menukey_script);
 118       } else if(token == "sector") {
 119         Sector* sector = new Sector(this);
 120         sector->parse(*(iter.lisp()));
 121         add_sector(sector);
 122       } else {
 123         log_warning << "Unknown token '" << token << "' in level file" << std::endl;
 124       }
 125     }
 126
 127     if (license == "") {
 128       log_warning << "The level author did not specify a license for this level. You might not be allowed to share it." << std::endl;
 129
 130     }
 131   } catch(std::exception& e) {
 132     std::stringstream msg;
 133     msg << "Problem when reading level '" << filepath << "': " << e.what();
 134     throw std::runtime_error(msg.str());
 135   }
 136
 137   current_tileset = NULL;
 138 }
 139
 140 void
 141 Level::load_old_format(const Reader& reader)
 142 {
 143   reader.get("name", name);
 144   reader.get("author", author);
 145
 146   Sector* sector = new Sector(this);
 147   sector->parse_old_format(reader);
 148   add_sector(sector);
 149 }
 150
 151 void
 152 Level::add_sector(Sector* sector)
 153 {
 154   Sector* test = get_sector(sector->get_name());
 155   if(test != 0) {
 156     throw std::runtime_error("Trying to add 2 sectors with same name");
 157   }
 158   sectors.push_back(sector);
 159 }
 160
 161 Sector*
 162 Level::get_sector(const std::string& name)
 163 {
 164   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i) {
 165     Sector* sector = *i;
 166     if(sector->get_name() == name)
 167       return sector;
 168   }
 169
 170   return 0;
 171 }
 172
 173 size_t
 174 Level::get_sector_count()
 175 {
 176   return sectors.size();
 177 }
 178
 179 Sector*
 180 Level::get_sector(size_t num)
 181 {
 182   return sectors.at(num);
 183 }
 184
 185 int
 186 Level::get_total_coins()
 187 {
 188   int total_coins = 0;
 189   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i) {
 190     Sector* sector = *i;
 191     for(Sector::GameObjects::iterator o = sector->gameobjects.begin();
 192         o != sector->gameobjects.end(); ++o) {
 193       Coin* coin = dynamic_cast<Coin*> (*o);
 194       if(coin)
 195       {
 196         total_coins++;
 197         continue;
 198       }
 199       BonusBlock *block = dynamic_cast<BonusBlock*> (*o);
 200       if(block)
 201       {
 202         if (block->contents == BonusBlock::CONTENT_COIN)
 203         {
 204           total_coins += block->hit_counter;
 205           continue;
 206         } else if (block->contents == BonusBlock::CONTENT_RAIN) {
 207           total_coins += 10;
 208           continue;
 209         } else if (block->contents == BonusBlock::CONTENT_EXPLODE) {
 210           total_coins += 10;
 211           continue;
 212         }
 213 #if 0
 214         // FIXME: do we want this? q.v. src/object/oneup.cpp
 215         else if (block->contents == BonusBlock::CONTENT_1UP)
 216         {
 217           total_coins += 100;
 218           continue;
 219         }
 220 #endif
 221       }
 222     }
 223   }
 224   return total_coins;
 225 }
 226
 227 int
 228 Level::get_total_badguys()
 229 {
 230   int total_badguys = 0;
 231   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
 232     total_badguys += (*i)->get_total_badguys();
 233   return total_badguys;
 234 }
 235
 236 int
 237 Level::get_total_secrets()
 238 {
 239   int total_secrets = 0;
 240   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
 241     total_secrets += (*i)->get_total_count<SecretAreaTrigger>();
 242   return total_secrets;
 243 }
 244
 245 /* EOF */