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 using namespace std;
  29
  30 Level::Level() :
  31   name("noname"),
  32   author("Mr. X"),
  33   contact(),
  34   license(),
  35   filename(),
  36   on_menukey_script(),
  37   sectors(),
  38   stats(),
  39   tileset(NULL),
  40   free_tileset(false)
  41 {
  42 }
  43
  44 Level::~Level()
  45 {
  46   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
  47     delete *i;
  48   if(free_tileset)
  49     delete tileset;
  50 }
  51
  52 void
  53 Level::load(const std::string& filepath)
  54 {
  55   try {
  56     filename = filepath;
  57     lisp::Parser parser;
  58     const lisp::Lisp* root = parser.parse(filepath);
  59
  60     const lisp::Lisp* level = root->get_lisp("supertux-level");
  61     if(!level)
  62       throw std::runtime_error("file is not a supertux-level file.");
  63
  64     int version = 1;
  65     level->get("version", version);
  66     if(version == 1) {
  67       log_info << "level uses old format: version 1" << std::endl;
  68       tileset = tile_manager->get_tileset("images/tiles.strf");
  69       load_old_format(*level);
  70       return;
  71     }
  72
  73     const lisp::Lisp* tilesets_lisp = level->get_lisp("tilesets");
  74     if(tilesets_lisp != NULL) {
  75       tileset      = tile_manager->parse_tileset_definition(*tilesets_lisp);
  76       free_tileset = true;
  77     }
  78     std::string tileset_name;
  79     if(level->get("tileset", tileset_name)) {
  80       if(tileset != NULL) {
  81         log_warning << "multiple tilesets specified in level" << std::endl;
  82       } else {
  83         tileset = tile_manager->get_tileset(tileset_name);
  84       }
  85     }
  86     /* load default tileset */
  87     if(tileset == NULL) {
  88       tileset = tile_manager->get_tileset("images/tiles.strf");
  89     }
  90     current_tileset = tileset;
  91
  92     contact = "";
  93     license = "";
  94
  95     lisp::ListIterator iter(level);
  96     while(iter.next()) {
  97       const std::string& token = iter.item();
  98       if(token == "version") {
  99         iter.value()->get(version);
 100         if(version > 2) {
 101           log_warning << "level format newer than application" << std::endl;
 102         }
 103       } else if(token == "tileset" || token == "tilesets") {
 104         continue;
 105       } else if(token == "name") {
 106         iter.value()->get(name);
 107       } else if(token == "author") {
 108         iter.value()->get(author);
 109       } else if(token == "contact") {
 110         iter.value()->get(contact);
 111       } else if(token == "license") {
 112         iter.value()->get(license);
 113       } else if(token == "on-menukey-script") {
 114         iter.value()->get(on_menukey_script);
 115       } else if(token == "sector") {
 116         Sector* sector = new Sector(this);
 117         sector->parse(*(iter.lisp()));
 118         add_sector(sector);
 119       } else {
 120         log_warning << "Unknown token '" << token << "' in level file" << std::endl;
 121       }
 122     }
 123
 124     if (license == "") {
 125       log_warning << "The level author did not specify a license for this level. You might not be allowed to share it." << std::endl;
 126
 127     }
 128   } catch(std::exception& e) {
 129     std::stringstream msg;
 130     msg << "Problem when reading level '" << filepath << "': " << e.what();
 131     throw std::runtime_error(msg.str());
 132   }
 133
 134   current_tileset = NULL;
 135 }
 136
 137 void
 138 Level::load_old_format(const Reader& reader)
 139 {
 140   reader.get("name", name);
 141   reader.get("author", author);
 142
 143   Sector* sector = new Sector(this);
 144   sector->parse_old_format(reader);
 145   add_sector(sector);
 146 }
 147
 148 void
 149 Level::add_sector(Sector* sector)
 150 {
 151   Sector* test = get_sector(sector->get_name());
 152   if(test != 0) {
 153     throw std::runtime_error("Trying to add 2 sectors with same name");
 154   }
 155   sectors.push_back(sector);
 156 }
 157
 158 Sector*
 159 Level::get_sector(const std::string& name)
 160 {
 161   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i) {
 162     Sector* sector = *i;
 163     if(sector->get_name() == name)
 164       return sector;
 165   }
 166
 167   return 0;
 168 }
 169
 170 size_t
 171 Level::get_sector_count()
 172 {
 173   return sectors.size();
 174 }
 175
 176 Sector*
 177 Level::get_sector(size_t num)
 178 {
 179   return sectors.at(num);
 180 }
 181
 182 int
 183 Level::get_total_coins()
 184 {
 185   int total_coins = 0;
 186   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i) {
 187     Sector* sector = *i;
 188     for(Sector::GameObjects::iterator o = sector->gameobjects.begin();
 189         o != sector->gameobjects.end(); ++o) {
 190       Coin* coin = dynamic_cast<Coin*> (*o);
 191       if(coin)
 192       {
 193         total_coins++;
 194         continue;
 195       }
 196       BonusBlock *block = dynamic_cast<BonusBlock*> (*o);
 197       if(block)
 198       {
 199         if (block->contents == BonusBlock::CONTENT_COIN)
 200         {
 201           total_coins++;
 202           continue;
 203         }
 204 #if 0
 205         // FIXME: do we want this? q.v. src/object/oneup.cpp
 206         else if (block->contents == BonusBlock::CONTENT_1UP)
 207         {
 208           total_coins += 100;
 209           continue;
 210         }
 211 #endif
 212       }
 213     }
 214   }
 215   return total_coins;
 216 }
 217
 218 int
 219 Level::get_total_badguys()
 220 {
 221   int total_badguys = 0;
 222   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
 223     total_badguys += (*i)->get_total_badguys();
 224   return total_badguys;
 225 }
 226
 227 int
 228 Level::get_total_secrets()
 229 {
 230   int total_secrets = 0;
 231   for(Sectors::iterator i = sectors.begin(); i != sectors.end(); ++i)
 232     total_secrets += (*i)->get_total_count<SecretAreaTrigger>();
 233   return total_secrets;
 234 }
 235
 236 /* EOF */