src/level.cpp

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