X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fworldmap.cpp;h=36e04441b06f1990eb6a40e693ab88d2240cffae;hb=a15b670f9fb343da5a2398880cfacf2655aefdec;hp=a2f8d3b9dd6a17571505085f6d994b28baa2cc87;hpb=c0093d25093395cb62fc2526ab42be65a9f015b8;p=supertux.git

diff --git a/src/worldmap.cpp b/src/worldmap.cpp
index a2f8d3b9d..36e04441b 100644
--- a/src/worldmap.cpp
+++ b/src/worldmap.cpp
@@ -26,28 +26,32 @@
 #include <sstream>
 #include <unistd.h>
 
-#include "app/globals.h"
-#include "app/gettext.h"
-#include "app/setup.h"
-#include "video/surface.h"
-#include "video/screen.h"
-#include "video/drawing_context.h"
-#include "special/frame_rate.h"
-#include "sprite/sprite_manager.h"
-#include "audio/sound_manager.h"
-#include "lisp/parser.h"
-#include "lisp/lisp.h"
-#include "lisp/list_iterator.h"
-#include "lisp/writer.h"
-#include "game_session.h"
-#include "sector.h"
-#include "worldmap.h"
-#include "resources.h"
-#include "misc.h"
-#include "player_status.h"
-#include "textscroller.h"
-#include "main.h"
-#include "control/joystickkeyboardcontroller.h"
+#include "gettext.hpp"
+#include "video/surface.hpp"
+#include "video/screen.hpp"
+#include "video/drawing_context.hpp"
+#include "sprite/sprite_manager.hpp"
+#include "audio/sound_manager.hpp"
+#include "lisp/parser.hpp"
+#include "lisp/lisp.hpp"
+#include "lisp/list_iterator.hpp"
+#include "lisp/writer.hpp"
+#include "game_session.hpp"
+#include "sector.hpp"
+#include "worldmap.hpp"
+#include "resources.hpp"
+#include "misc.hpp"
+#include "player_status.hpp"
+#include "textscroller.hpp"
+#include "main.hpp"
+#include "spawn_point.hpp"
+#include "file_system.hpp"
+#include "gui/menu.hpp"
+#include "gui/mousecursor.hpp"
+#include "control/joystickkeyboardcontroller.hpp"
+#include "object/background.hpp"
+#include "object/tilemap.hpp"
+#include "scripting/script_interpreter.hpp"
 
 Menu* worldmap_menu  = 0;
 
@@ -116,8 +120,6 @@ Tux::Tux(WorldMap* worldmap_)
   
   offset = 0;
   moving = false;
-  tile_pos.x = worldmap->get_start_x();
-  tile_pos.y = worldmap->get_start_y();
   direction = D_NONE;
   input_direction = D_NONE;
 }
@@ -176,7 +178,7 @@ Tux::get_pos()
       break;
     }
   
-  return Vector((int)x, (int)y); 
+  return Vector(x, y);
 }
 
 void
@@ -195,7 +197,7 @@ Tux::set_direction(Direction dir)
 }
 
 void
-Tux::action(float delta)
+Tux::update(float delta)
 {
   // check controller
   if(main_controller->pressed(Controller::UP))
@@ -343,24 +345,20 @@ Tux::action(float delta)
 //---------------------------------------------------------------------------
 
 WorldMap::WorldMap()
+  : tux(0), solids(0)
 {
-  tile_manager = new TileManager("images/worldmap/antarctica.stwt");
+  tile_manager = new TileManager("images/worldmap.strf");
   
-  width  = 20;
-  height = 15;
-  
-  start_x = 4;
-  start_y = 5;
-
   tux = new Tux(this);
-  
-  leveldot_green = new Surface(datadir +  "/images/worldmap/leveldot_green.png", true);
-  leveldot_red = new Surface(datadir +  "/images/worldmap/leveldot_red.png", true);
-  messagedot   = new Surface(datadir +  "/images/worldmap/messagedot.png", true);
-  teleporterdot   = new Surface(datadir +  "/images/worldmap/teleporterdot.png", true);
+  add_object(tux);
+    
+  leveldot_green= new Surface("images/tiles/worldmap/leveldot_green.png", true);
+  leveldot_red = new Surface("images/tiles/worldmap/leveldot_red.png", true);
+  messagedot = new Surface("images/tiles/worldmap/messagedot.png", true);
+  teleporterdot = new Surface("images/tiles/worldmap/teleporterdot.png", true);
 
   name = "<no title>";
-  music = "salcon.mod";
+  music = "salcon.ogg";
   intro_displayed = false;
 
   total_stats.reset();
@@ -368,7 +366,12 @@ WorldMap::WorldMap()
 
 WorldMap::~WorldMap()
 {
-  delete tux;
+  clear_objects();
+  for(SpawnPoints::iterator i = spawn_points.begin();
+      i != spawn_points.end(); ++i) {
+    delete *i;
+  }
+    
   delete tile_manager;
 
   delete leveldot_green;
@@ -377,6 +380,29 @@ WorldMap::~WorldMap()
   delete teleporterdot;
 }
 
+void
+WorldMap::add_object(GameObject* object)
+{
+  TileMap* tilemap = dynamic_cast<TileMap*> (object);
+  if(tilemap != 0 && tilemap->is_solid()) {
+    solids = tilemap;
+  }
+
+  game_objects.push_back(object);
+}
+
+void
+WorldMap::clear_objects()
+{
+  for(GameObjects::iterator i = game_objects.begin();
+      i != game_objects.end(); ++i)
+    delete *i;
+  game_objects.clear();
+  solids = 0;
+  tux = new Tux(this);
+  add_object(tux);
+}
+
 // Don't forget to set map_filename before calling this
 void
 WorldMap::load_map()
@@ -385,39 +411,50 @@ WorldMap::load_map()
 
   try {
     lisp::Parser parser;
-    std::string filename = get_resource_filename(map_filename);
-    std::auto_ptr<lisp::Lisp> root (parser.parse(filename));
+    std::auto_ptr<lisp::Lisp> root (parser.parse(map_filename));
 
     const lisp::Lisp* lisp = root->get_lisp("supertux-worldmap");
     if(!lisp)
-      throw new std::runtime_error("file isn't a supertux-worldmap file.");
+      throw std::runtime_error("file isn't a supertux-worldmap file.");
 
+    clear_objects();
     lisp::ListIterator iter(lisp);
     while(iter.next()) {
       if(iter.item() == "tilemap") {
-        if(tilemap.size() > 0)
-          throw new std::runtime_error("multiple tilemaps specified");
-        
-        const lisp::Lisp* tilemap_lisp = iter.lisp();
-        tilemap_lisp->get("width",  width);
-        tilemap_lisp->get("height", height);
-        tilemap_lisp->get_vector("data", tilemap);
+        add_object(new TileMap(*(iter.lisp()), tile_manager));
+      } else if(iter.item() == "background") {
+        add_object(new Background(*(iter.lisp())));
       } else if(iter.item() == "properties") {
         const lisp::Lisp* props = iter.lisp();
         props->get("name", name);
         props->get("music", music);
-        props->get("intro-filename", intro_filename);
-        props->get("start_pos_x", start_x);
-        props->get("start_pos_y", start_y);
-      } else if(iter.item() == "special-tiles") {
-        parse_special_tiles(iter.lisp());
+      } else if(iter.item() == "intro-script") {
+        iter.value()->get(intro_script);
+      } else if(iter.item() == "spawnpoint") {
+        SpawnPoint* sp = new SpawnPoint(iter.lisp());
+        spawn_points.push_back(sp);
+      } else if(iter.item() == "level") {
+        parse_level_tile(iter.lisp());
+      } else if(iter.item() == "special-tile") {
+        parse_special_tile(iter.lisp());
       } else {
         std::cerr << "Unknown token '" << iter.item() << "' in worldmap.\n";
       }
     }
+    if(solids == 0)
+      throw std::runtime_error("No solid tilemap specified");
+
+    // search for main spawnpoint
+    for(SpawnPoints::iterator i = spawn_points.begin();
+        i != spawn_points.end(); ++i) {
+      SpawnPoint* sp = *i;
+      if(sp->name == "main") {
+        Vector p = sp->pos;
+        tux->set_tile_pos(p);
+        break;
+      }
+    }
 
-    delete tux;
-    tux = new Tux(this);
   } catch(std::exception& e) {
     std::stringstream msg;
     msg << "Problem when parsing worldmap '" << map_filename << "': " <<
@@ -427,81 +464,75 @@ WorldMap::load_map()
 }
 
 void
-WorldMap::parse_special_tiles(const lisp::Lisp* lisp)
+WorldMap::parse_special_tile(const lisp::Lisp* lisp)
 {
-  lisp::ListIterator iter(lisp);
-  while(iter.next()) {
-    if(iter.item() == "special-tile") {
-      SpecialTile special_tile;
-
-      const lisp::Lisp* lisp = iter.lisp();
-      lisp->get("x", special_tile.pos.x);
-      lisp->get("y", special_tile.pos.y);
-      lisp->get("map-message", special_tile.map_message);
-      special_tile.passive_message = false;
-      lisp->get("passive-message", special_tile.passive_message);
-      special_tile.teleport_dest = Vector(-1,-1);
-      lisp->get("teleport-to-x", special_tile.teleport_dest.x);
-      lisp->get("teleport-to-y", special_tile.teleport_dest.y);
-      special_tile.invisible = false;
-      lisp->get("invisible-tile", special_tile.invisible);
-
+  SpecialTile special_tile;
+  
+  lisp->get("x", special_tile.pos.x);
+  lisp->get("y", special_tile.pos.y);
+  lisp->get("map-message", special_tile.map_message);
+  special_tile.passive_message = false;
+  lisp->get("passive-message", special_tile.passive_message);
+  special_tile.teleport_dest = Vector(-1,-1);
+  lisp->get("teleport-to-x", special_tile.teleport_dest.x);
+  lisp->get("teleport-to-y", special_tile.teleport_dest.y);
+  special_tile.invisible = false;
+  lisp->get("invisible-tile", special_tile.invisible);
+
+  special_tile.apply_action_north = true;
+  special_tile.apply_action_south = true;
+  special_tile.apply_action_east = true;
+  special_tile.apply_action_west = true;
+
+  std::string apply_direction;
+  lisp->get("apply-to-direction", apply_direction);
+  if(!apply_direction.empty()) {
+    special_tile.apply_action_north = false;
+    special_tile.apply_action_south = false;
+    special_tile.apply_action_east = false;
+    special_tile.apply_action_west = false;
+    if(apply_direction.find("north") != std::string::npos)
       special_tile.apply_action_north = true;
+    if(apply_direction.find("south") != std::string::npos)
       special_tile.apply_action_south = true;
+    if(apply_direction.find("east") != std::string::npos)
       special_tile.apply_action_east = true;
+    if(apply_direction.find("west") != std::string::npos)
       special_tile.apply_action_west = true;
+  }
+  
+  special_tiles.push_back(special_tile);
+}
 
-      std::string apply_direction;
-      lisp->get("apply-to-direction", apply_direction);
-      if(!apply_direction.empty()) {
-        special_tile.apply_action_north = false;
-        special_tile.apply_action_south = false;
-        special_tile.apply_action_east = false;
-        special_tile.apply_action_west = false;
-        if(apply_direction.find("north") != std::string::npos)
-          special_tile.apply_action_north = true;
-        if(apply_direction.find("south") != std::string::npos)
-          special_tile.apply_action_south = true;
-        if(apply_direction.find("east") != std::string::npos)
-          special_tile.apply_action_east = true;
-        if(apply_direction.find("west") != std::string::npos)
-          special_tile.apply_action_west = true;
-      }
-      
-      special_tiles.push_back(special_tile);
-    } else if(iter.item() == "level") {
-      Level level;
+void
+WorldMap::parse_level_tile(const lisp::Lisp* level_lisp)
+{
+  Level level;
 
-      lisp::Lisp* level_lisp = iter.lisp();
-      level.solved = false;
-                      
-      level.north = true;
-      level.east  = true;
-      level.south = true;
-      level.west  = true;
+  level.solved = false;
+                  
+  level.north = true;
+  level.east  = true;
+  level.south = true;
+  level.west  = true;
 
-      level_lisp->get("extro-filename", level.extro_filename);
-      level_lisp->get("next-worldmap", level.next_worldmap);
+  level_lisp->get("extro-script", level.extro_script);
+  level_lisp->get("next-worldmap", level.next_worldmap);
 
-      level.quit_worldmap = false;
-      level_lisp->get("quit-worldmap", level.quit_worldmap);
+  level.quit_worldmap = false;
+  level_lisp->get("quit-worldmap", level.quit_worldmap);
 
-      level_lisp->get("name", level.name);
-      level_lisp->get("x", level.pos.x);
-      level_lisp->get("y", level.pos.y);
+  level_lisp->get("name", level.name);
+  level_lisp->get("x", level.pos.x);
+  level_lisp->get("y", level.pos.y);
 
-      level.auto_path = true;
-      level_lisp->get("auto-path", level.auto_path);
+  level.auto_path = true;
+  level_lisp->get("auto-path", level.auto_path);
 
-      level.vertical_flip = false;
-      level_lisp->get("vertical-flip", level.vertical_flip);
+  level.vertical_flip = false;
+  level_lisp->get("vertical-flip", level.vertical_flip);
 
-      levels.push_back(level);
-    } else {
-      std::cerr << "Unknown token '" << iter.item() <<
-        "' in worldmap special-tiles list.";
-    }
-  }
+  levels.push_back(level);
 }
 
 void
@@ -512,8 +543,7 @@ WorldMap::get_level_title(Level& level)
 
   try {
     lisp::Parser parser;
-    std::auto_ptr<lisp::Lisp> root (
-        parser.parse(get_resource_filename(levels_path + level.name)));
+    std::auto_ptr<lisp::Lisp> root (parser.parse(levels_path + level.name));
 
     const lisp::Lisp* level_lisp = root->get_lisp("supertux-level");
     if(!level_lisp)
@@ -592,8 +622,8 @@ WorldMap::path_ok(Direction direction, Vector old_pos, Vector* new_pos)
 {
   *new_pos = get_next_tile(old_pos, direction);
 
-  if (!(new_pos->x >= 0 && new_pos->x < width
-        && new_pos->y >= 0 && new_pos->y < height))
+  if (!(new_pos->x >= 0 && new_pos->x < solids->get_width()
+        && new_pos->y >= 0 && new_pos->y < solids->get_height()))
     { // New position is outsite the tilemap
       return false;
     }
@@ -629,7 +659,7 @@ WorldMap::update(float delta)
 {
   Menu* menu = Menu::current();
   if(menu) {
-    menu->action();
+    menu->update();
 
     if(menu == worldmap_menu) {
       switch (worldmap_menu->check())
@@ -648,6 +678,24 @@ WorldMap::update(float delta)
     return;
   }
 
+  // update GameObjects
+  for(GameObjects::iterator i = game_objects.begin();
+      i != game_objects.end(); ++i) {
+    GameObject* object = *i;
+    object->update(delta);
+  }
+  // remove old GameObjects
+  for(GameObjects::iterator i = game_objects.begin();
+      i != game_objects.end(); ) {
+    GameObject* object = *i;
+    if(!object->is_valid()) {
+      delete object;
+      i = game_objects.erase(i);
+    } else {
+      ++i;
+    }
+  }
+  
   bool enter_level = false;
   if(main_controller->pressed(Controller::ACTION)
       || main_controller->pressed(Controller::JUMP)
@@ -665,7 +713,7 @@ WorldMap::update(float delta)
         if (special_tile->teleport_dest != Vector(-1,-1))
           {
           // TODO: an animation, camera scrolling or a fading would be a nice touch
-          sound_manager->play_sound("warp");
+          sound_manager->play("sounds/warp.ogg");
           tux->back_direction = D_NONE;
           tux->set_tile_pos(special_tile->teleport_dest);
           SDL_Delay(1000);
@@ -686,13 +734,13 @@ WorldMap::update(float delta)
 
       if (level->pos == tux->get_tile_pos())
         {
+          sound_manager->stop_music();
           PlayerStatus old_player_status = player_status;
 
-          std::cout << "Enter the current level: " << level->name << std::endl;
           // do a shriking fade to the level
           shrink_fade(Vector((level->pos.x*32 + 16 + offset.x),
                              (level->pos.y*32 + 16 + offset.y)), 500);
-          GameSession session(get_resource_filename(levels_path + level->name),
+          GameSession session(levels_path + level->name,
                               ST_GL_LOAD_LEVEL_FILE, &level->statistics);
 
           switch (session.run())
@@ -730,10 +778,7 @@ WorldMap::update(float delta)
                     if (dir != D_NONE)
                       {
                         tux->set_direction(dir);
-                        //tux->update(delta);
                       }
-
-                    std::cout << "Walk to dir: " << dir << std::endl;
                   }
               }
 
@@ -772,8 +817,7 @@ WorldMap::update(float delta)
 
               context.do_drawing();
 
-              SDL_Event event;
-              wait_for_event(event,2000,6000,true);
+              wait_for_event(2.0, 6.0);
 
               quit = true;
               player_status.reset();
@@ -785,7 +829,7 @@ WorldMap::update(float delta)
               break;
             }
 
-          sound_manager->play_music(song);
+          sound_manager->play_music(std::string("music/") + music);
           Menu::set_current(0);
           if (!savegame_file.empty())
             savegame(savegame_file);
@@ -793,10 +837,16 @@ WorldMap::update(float delta)
       /* The porpose of the next checking is that if the player lost
          the level (in case there is one), don't show anything */
       if(level_finished) {
-        if (!level->extro_filename.empty()) {
-          // Display a text file
-          std::string filename = levels_path + level->extro_filename;
-          display_text_file(filename);
+        if (level->extro_script != "") {
+          try {
+            std::auto_ptr<ScriptInterpreter> interpreter 
+              (new ScriptInterpreter(levels_path));
+            std::istringstream in(level->extro_script);
+            interpreter->run_script(in, "level-extro-script");
+            add_object(interpreter.release());
+          } catch(std::exception& e) {
+            std::cerr << "Couldn't run level-extro-script:" << e.what() << "\n";
+          }
         }
 
         if (!level->next_worldmap.empty())
@@ -810,7 +860,6 @@ WorldMap::update(float delta)
     }
   else
     {
-      tux->action(delta);
 //      tux->set_direction(input_direction);
     }
 }
@@ -818,14 +867,7 @@ WorldMap::update(float delta)
 const Tile*
 WorldMap::at(Vector p)
 {
-  assert(p.x >= 0 
-         && p.x < width
-         && p.y >= 0
-         && p.y < height);
-
-  int x = int(p.x);
-  int y = int(p.y);
-  return tile_manager->get(tilemap[width * y + x]);
+  return solids->get_tile((int) p.x, (int) p.y);
 }
 
 WorldMap::Level*
@@ -855,13 +897,12 @@ WorldMap::at_special_tile()
 void
 WorldMap::draw(DrawingContext& context)
 {
-  for(int y = 0; y < height; ++y)
-    for(int x = 0; x < width; ++x)
-      {
-        const Tile* tile = at(Vector(x, y));
-        tile->draw(context, Vector(x*32, y*32), LAYER_TILES);
-      }
-
+  for(GameObjects::iterator i = game_objects.begin();
+      i != game_objects.end(); ++i) {
+    GameObject* object = *i;
+    object->draw(context);
+  }
+  
   for(Levels::iterator i = levels.begin(); i != levels.end(); ++i)
     {
       if (i->solved)
@@ -886,7 +927,6 @@ WorldMap::draw(DrawingContext& context)
                 Vector(i->pos.x*32, i->pos.y*32), LAYER_TILES+1);
     }
 
-  tux->draw(context);
   draw_status(context);
 }
 
@@ -895,38 +935,8 @@ WorldMap::draw_status(DrawingContext& context)
 {
   context.push_transform();
   context.set_translation(Vector(0, 0));
-  
-  char str[80];
-  sprintf(str, " %d", total_stats.get_points(SCORE_STAT));
-
-  context.draw_text(white_text, _("SCORE"), Vector(0, 0), LEFT_ALLIGN, LAYER_FOREGROUND1);
-  context.draw_text(gold_text, str, Vector(96, 0), LEFT_ALLIGN, LAYER_FOREGROUND1);
-
-  sprintf(str, "%d", player_status.coins);
-  context.draw_text(white_text, _("COINS"), Vector(SCREEN_WIDTH/2 - 16*5, 0),
-      LEFT_ALLIGN, LAYER_FOREGROUND1);
-  context.draw_text(gold_text, str, Vector(SCREEN_WIDTH/2 + (16*5)/2, 0),
-        LEFT_ALLIGN, LAYER_FOREGROUND1);
-
-  if (player_status.lives >= 5)
-    {
-      sprintf(str, "%dx", player_status.lives);
-      context.draw_text(gold_text, str, 
-          Vector(SCREEN_WIDTH - gold_text->get_text_width(str) - tux_life->w, 0),
-          LEFT_ALLIGN, LAYER_FOREGROUND1);
-      context.draw_surface(tux_life, Vector(SCREEN_WIDTH -
-            gold_text->get_text_width("9"), 0), LEFT_ALLIGN, LAYER_FOREGROUND1);
-    }
-  else
-    {
-      for(int i= 0; i < player_status.lives; ++i)
-        context.draw_surface(tux_life,
-            Vector(SCREEN_WIDTH - tux_life->w*4 + (tux_life->w*i), 0),
-            LAYER_FOREGROUND1);
-    }
-  context.draw_text(white_text, _("LIVES"),
-      Vector(SCREEN_WIDTH - white_text->get_text_width(_("LIVES")) - white_text->get_text_width("   99"), 0),
-      LEFT_ALLIGN, LAYER_FOREGROUND1);
+ 
+  player_status.draw(context);
 
   if (!tux->is_moving())
     {
@@ -961,7 +971,7 @@ WorldMap::draw_status(DrawingContext& context)
         }
     }
   /* Display a passive message in the map, if needed */
-  if(passive_message_timer.check())
+  if(passive_message_timer.started())
     context.draw_text(gold_text, passive_message, 
             Vector(SCREEN_WIDTH/2, SCREEN_HEIGHT - white_text->get_height() - 60),
             CENTER_ALLIGN, LAYER_FOREGROUND1);
@@ -976,12 +986,20 @@ WorldMap::display()
 
   quit = false;
 
-  song = sound_manager->load_music(datadir +  "/music/" + music);
-  sound_manager->play_music(song);
-
-  if(!intro_displayed && intro_filename != "") {
-    std::string filename = levels_path + intro_filename;
-    display_text_file(filename);
+  sound_manager->play_music(std::string("music/") + music);
+
+  if(!intro_displayed && intro_script != "") {
+    try {
+      std::auto_ptr<ScriptInterpreter> interpreter 
+        (new ScriptInterpreter(levels_path));
+      std::istringstream in(intro_script);
+      interpreter->run_script(in, "worldmap-intro-script");
+      add_object(interpreter.release());
+    } catch(std::exception& e) {
+      std::cerr << "Couldn't execute worldmap-intro-script: "
+        << e.what() << "\n";
+    }
+                                           
     intro_displayed = true;
   }
 
@@ -990,34 +1008,37 @@ WorldMap::display()
   while(!quit) {
     Uint32 ticks = SDL_GetTicks();
     float elapsed_time = float(ticks - lastticks) / 1000;
-    global_time += elapsed_time;
+    game_time += elapsed_time;
     lastticks = ticks;
     
-    // 40 fps minimum
+    // 40 fps minimum // TODO use same code as in GameSession here
     if(elapsed_time > .025)
       elapsed_time = .025;
     
     Vector tux_pos = tux->get_pos();
-    
-    offset.x = -tux_pos.x + SCREEN_WIDTH/2;
-    offset.y = -tux_pos.y + SCREEN_HEIGHT/2;
+    offset.x = tux_pos.x - SCREEN_WIDTH/2;
+    offset.y = tux_pos.y - SCREEN_HEIGHT/2;
 
-    if (offset.x > 0) offset.x = 0;
-    if (offset.y > 0) offset.y = 0;
+    if (offset.x < 0)
+      offset.x = 0;
+    if (offset.y < 0)
+      offset.y = 0;
+
+    if (offset.x > solids->get_width()*32 - SCREEN_WIDTH)
+      offset.x = solids->get_width()*32 - SCREEN_WIDTH;
+    if (offset.y > solids->get_height()*32 - SCREEN_HEIGHT)
+      offset.y = solids->get_height()*32 - SCREEN_HEIGHT;
 
-    if (offset.x < SCREEN_WIDTH - width*32) offset.x = SCREEN_WIDTH - width*32;
-    if (offset.y < SCREEN_HEIGHT - height*32) offset.y = SCREEN_HEIGHT - height*32;
-  
     context.push_transform();
-    context.set_translation(-offset);
+    context.set_translation(offset);
     draw(context);
     context.pop_transform();
     get_input();
     update(elapsed_time);
+    sound_manager->update();
       
     if(Menu::current()) {
       Menu::current()->draw(context);
-      mouse_cursor->draw(context);
     }
 
     context.do_drawing();
@@ -1030,8 +1051,7 @@ WorldMap::savegame(const std::string& filename)
   if(filename == "")
     return;
 
-  std::ofstream file(filename.c_str(), std::ios::out);
-  lisp::Writer writer(file);
+  lisp::Writer writer(filename);
 
   int nb_solved_levels = 0, total_levels = 0;
   for(Levels::iterator i = levels.begin(); i != levels.end(); ++i) {
@@ -1148,13 +1168,13 @@ WorldMap::loadgame(const std::string& filename)
           }
         } else {
           std::cerr << "Unknown token '" << iter.item() 
-            << "' in levels block in worldmap.\n";
+                    << "' in levels block in worldmap.\n";
         }
       }
     }
   } catch(std::exception& e) {
     std::cerr << "Problem loading game '" << filename << "': " << e.what() 
-      << "\n";
+              << "\n";
     load_map();
     player_status.reset();
   }