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