X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Flevel.cpp;h=485e5e82d301e9d68206fa693d94546f7c473065;hb=5dba61177d71c5572fd29af172fcdab7b1f9a561;hp=e316e4790adc7619d909c89d6e59389ac74b0a56;hpb=aadd77c676baae31db931c8e64cd1713c24289d5;p=supertux.git

diff --git a/src/level.cpp b/src/level.cpp
index e316e4790..485e5e82d 100644
--- a/src/level.cpp
+++ b/src/level.cpp
@@ -1,20 +1,29 @@
+//  $Id$
+// 
+//  SuperTux
+//  Copyright (C) 2004 SuperTux Development Team, see AUTHORS for details
 //
-// C Implementation: level
-//
-// Description:
-//
-//
-// Author: Tobias Glaesser <tobi.web@gmx.de>, (C) 2003
-//
-// Copyright: See COPYING file that comes with this distribution
-//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
 //
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+// 
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+//  02111-1307, USA.
 
 #include <map>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <iostream>
+#include <fstream>
 #include "globals.h"
 #include "setup.h"
 #include "screen.h"
@@ -23,27 +32,37 @@
 #include "scene.h"
 #include "tile.h"
 #include "lispreader.h"
+#include "resources.h"
+#include "music_manager.h"
+#include "gameobjs.h"
+#include "world.h"
+#include "lispwriter.h"
 
 using namespace std;
 
-st_subset::st_subset()
+LevelSubset::LevelSubset()
+    : image(0), levels(0)
+{
+}
+
+LevelSubset::~LevelSubset()
 {
-  levels = 0;
+  delete image;
 }
 
-void st_subset::create(const std::string& subset_name)
+void LevelSubset::create(const std::string& subset_name)
 {
   Level new_lev;
-  st_subset new_subset;
+  LevelSubset new_subset;
   new_subset.name = subset_name;
   new_subset.title = "Unknown Title";
   new_subset.description = "No description so far.";
   new_subset.save();
   new_lev.init_defaults();
-  new_lev.save(subset_name.c_str(),1);
+  new_lev.save(subset_name, 1, 0);
 }
 
-void st_subset::parse (lisp_object_t* cursor)
+void LevelSubset::parse (lisp_object_t* cursor)
 {
   while(!lisp_nil_p(cursor))
     {
@@ -75,7 +94,7 @@ void st_subset::parse (lisp_object_t* cursor)
     }
 }
 
-void st_subset::load(char *subset)
+void LevelSubset::load(char *subset)
 {
   FILE* fi;
   char filename[1024];
@@ -117,17 +136,20 @@ void st_subset::load(char *subset)
 
         }
 
+      lisp_free(root_obj);
       fclose(fi);
 
       snprintf(str, 1024, "%s.png", filename);
       if(faccessible(str))
         {
-          texture_load(&image,str,IGNORE_ALPHA);
+          delete image;
+          image = new Surface(str,IGNORE_ALPHA);
         }
       else
         {
           snprintf(filename, 1024, "%s/images/status/level-subset-info.png", datadir.c_str());
-          texture_load(&image,filename,IGNORE_ALPHA);
+          delete image;
+          image = new Surface(filename,IGNORE_ALPHA);
         }
     }
 
@@ -145,7 +167,7 @@ void st_subset::load(char *subset)
   levels = --i;
 }
 
-void st_subset::save()
+void LevelSubset::save()
 {
   FILE* fi;
   string filename;
@@ -181,360 +203,265 @@ void st_subset::save()
     }
 }
 
-void st_subset::free()
+Level::Level()
+  : img_bkgd(0)
 {
-  title.clear();
-  description.clear();
-  name.clear();
-  texture_free(&image);
-  levels = 0;
+  init_defaults();
+}
+
+Level::~Level()
+{
+  delete img_bkgd;
 }
 
 void
 Level::init_defaults()
 {
   name       = "UnNamed";
-  theme      = "antarctica";
+  author     = "UnNamed";
   song_title = "Mortimers_chipdisko.mod";
-  bkgd_image = "arctis.png";
-  width      = 21;
+  bkgd_image = "arctis.jpg";
+  width      = 0;
+  height     = 0;
+  start_pos.x = 100;
+  start_pos.y = 170;
   time_left  = 100;
   gravity    = 10.;
-  bkgd_red   = 0;
-  bkgd_green = 0;
-  bkgd_blue  = 0;
-
-  for(int i = 0; i < 15; ++i)
-    {
-      ia_tiles[i] = (unsigned int*) malloc((width+1)*sizeof(unsigned int));
-      ia_tiles[i][width] = (unsigned int) '\0';
-      for(int y = 0; y < width; ++y)
-        ia_tiles[i][y] = 0;
-      ia_tiles[i][width] = (unsigned int) '\0';
-
-      bg_tiles[i] = (unsigned int*) malloc((width+1)*sizeof(unsigned int));
-      bg_tiles[i][width] = (unsigned int) '\0';
-      for(int y = 0; y < width; ++y)
-        bg_tiles[i][y] = 0;
-      bg_tiles[i][width] = (unsigned int) '\0';
-
-      fg_tiles[i] = (unsigned int*) malloc((width+1)*sizeof(unsigned int));
-      fg_tiles[i][width] = (unsigned int) '\0';
-      for(int y = 0; y < width; ++y)
-        fg_tiles[i][y] = 0;
-      fg_tiles[i][width] = (unsigned int) '\0';
-    }
+  bkgd_speed = 50;
+  bkgd_top.red   = 0;
+  bkgd_top.green = 0;
+  bkgd_top.blue  = 0;
+  bkgd_bottom.red   = 255;
+  bkgd_bottom.green = 255;
+  bkgd_bottom.blue  = 255;
+
+  resize(21, 19);
 }
 
 int
-Level::load(const  char *subset, int level)
+Level::load(const std::string& subset, int level, World* world)
 {
   char filename[1024];
 
   // Load data file:
-  snprintf(filename, 1024, "%s/levels/%s/level%d.stl", st_dir, subset, level);
+  snprintf(filename, 1024, "%s/levels/%s/level%d.stl", st_dir, subset.c_str(), level);
   if(!faccessible(filename))
-    snprintf(filename, 1024, "%s/levels/%s/level%d.stl", datadir.c_str(), subset, level);
+    snprintf(filename, 1024, "%s/levels/%s/level%d.stl", datadir.c_str(), subset.c_str(), level);
 
-  return load(filename);
+  return load(filename, world);
 }
 
 int 
-Level::load(const std::string& filename)
+Level::load(const std::string& filename, World* world)
 {
-  FILE * fi;
-  lisp_object_t* root_obj = 0;
-  fi = fopen(filename.c_str(), "r");
-  if (fi == NULL)
+  lisp_object_t* root_obj = lisp_read_from_file(filename);
+  if (!root_obj)
     {
-      perror(filename.c_str());
+      std::cout << "Level: Couldn't load file: " << filename << std::endl;
       return -1;
     }
 
-  lisp_stream_t stream;
-  lisp_stream_init_file (&stream, fi);
-  root_obj = lisp_read (&stream);
-
   if (root_obj->type == LISP_TYPE_EOF || root_obj->type == LISP_TYPE_PARSE_ERROR)
     {
-      printf("World: Parse Error in file %s", filename.c_str());
+      lisp_free(root_obj);
+      std::cout << "World: Parse Error in file '" << filename
+                << "'.\n";
+      return -1;
     }
 
-  vector<int> ia_tm;
-  vector<int> bg_tm;
-  vector<int> fg_tm;
-
   int version = 0;
   if (strcmp(lisp_symbol(lisp_car(root_obj)), "supertux-level") == 0)
     {
       LispReader reader(lisp_cdr(root_obj));
-
+      version = 0;
       reader.read_int("version",  &version);
-      reader.read_int("width",  &width);
-      reader.read_int("time",  &time_left);
-      reader.read_int("bkgd_red",  &bkgd_red);
-      reader.read_int("bkgd_green",  &bkgd_green);
-      reader.read_int("bkgd_blue",  &bkgd_blue);
+      if(!reader.read_int("width",  &width))
+        st_abort("No width specified for level.", "");
+      if (!reader.read_float("start_pos_x", &start_pos.x)) start_pos.x = 100;
+      if (!reader.read_float("start_pos_y", &start_pos.y)) start_pos.y = 170;
+      time_left = 500;
+      if(!reader.read_int("time",  &time_left)) {
+        printf("Warning: no time specified for level.\n");
+      }
+      
+      height = 15;
+      if(!reader.read_int("height",  &height)) {
+        printf("Warning: no height specified for level.\n");
+      }
+      
+      bkgd_speed = 50;
+      reader.read_int("bkgd_speed",  &bkgd_speed);
+      
+      bkgd_top.red = bkgd_top.green = bkgd_top.blue = 0;
+      reader.read_int("bkgd_red_top",  &bkgd_top.red);
+      reader.read_int("bkgd_green_top",  &bkgd_top.green);
+      reader.read_int("bkgd_blue_top",  &bkgd_top.blue);
+
+      bkgd_bottom.red = bkgd_bottom.green = bkgd_bottom.blue = 0;
+      reader.read_int("bkgd_red_bottom",  &bkgd_bottom.red);
+      reader.read_int("bkgd_green_bottom",  &bkgd_bottom.green);
+      reader.read_int("bkgd_blue_bottom",  &bkgd_bottom.blue);
+
+      gravity = 10;
       reader.read_float("gravity",  &gravity);
+      name = "Noname";
       reader.read_string("name",  &name);
-      reader.read_string("theme",  &theme);
+      author = "unknown author";
+      reader.read_string("author", &author);
+      song_title = "";
       reader.read_string("music",  &song_title);
+      bkgd_image = "";
       reader.read_string("background",  &bkgd_image);
+      particle_system = "";
       reader.read_string("particle_system", &particle_system);
-      reader.read_int_vector("background-tm",  &bg_tm);
 
-      if (!reader.read_int_vector("interactive-tm", &ia_tm))
-        reader.read_int_vector("tilemap", &ia_tm);
+      reader.read_int_vector("background-tm",  &bg_tiles);
+      if(int(bg_tiles.size()) != width * height)
+        st_abort("Wrong size of backgroundtilemap", "");
+
+      if (!reader.read_int_vector("interactive-tm", &ia_tiles))
+        reader.read_int_vector("tilemap", &ia_tiles);
+      if(int(ia_tiles.size()) != width * height)
+        st_abort("Wrong size of interactivetilemap", "");      
 
-      reader.read_int_vector("foreground-tm",  &fg_tm);
+      reader.read_int_vector("foreground-tm",  &fg_tiles);
+      if(int(fg_tiles.size()) != width * height)
+        st_abort("Wrong size of foregroundtilemap", "");      
 
-      {
+      { // Read ResetPoints
         lisp_object_t* cur = 0;
-        if (reader.read_lisp("objects",  &cur))
+        if (reader.read_lisp("reset-points",  &cur))
           {
             while (!lisp_nil_p(cur))
               {
                 lisp_object_t* data = lisp_car(cur);
 
-                BadGuyData bg_data;
-                bg_data.kind = badguykind_from_string(lisp_symbol(lisp_car(data)));
-                LispReader reader(lisp_cdr(data));
-                reader.read_int("x", &bg_data.x);
-                reader.read_int("y", &bg_data.y);
+                ResetPoint pos;
 
-                badguy_data.push_back(bg_data);
+                LispReader reader(lisp_cdr(data));
+                if (reader.read_int("x", &pos.x)
+                    && reader.read_int("y", &pos.y))
+                  {
+                    reset_points.push_back(pos);
+                  }
 
                 cur = lisp_cdr(cur);
               }
           }
       }
 
-      // Convert old levels to the new tile numbers
-      if (version == 0)
-        {
-          std::map<char, int> transtable;
-          transtable['.'] = 0;
-          transtable['x'] = 104;
-          transtable['X'] = 77;
-          transtable['y'] = 78;
-          transtable['Y'] = 105;
-          transtable['A'] = 83;
-          transtable['B'] = 102;
-          transtable['!'] = 103;
-          transtable['a'] = 84;
-          transtable['C'] = 85;
-          transtable['D'] = 86;
-          transtable['E'] = 87;
-          transtable['F'] = 88;
-          transtable['c'] = 89;
-          transtable['d'] = 90;
-          transtable['e'] = 91;
-          transtable['f'] = 92;
-
-          transtable['G'] = 93;
-          transtable['H'] = 94;
-          transtable['I'] = 95;
-          transtable['J'] = 96;
-
-          transtable['g'] = 97;
-          transtable['h'] = 98;
-          transtable['i'] = 99;
-          transtable['j'] = 100
-                            ;
-          transtable['#'] = 11;
-          transtable['['] = 13;
-          transtable['='] = 14;
-          transtable[']'] = 15;
-          transtable['$'] = 82;
-          transtable['^'] = 76;
-          transtable['*'] = 80;
-          transtable['|'] = 79;
-          transtable['\\'] = 81;
-          transtable['&'] = 75;
-
-          int x = 0;
-          int y = 0;
-          for(std::vector<int>::iterator i = ia_tm.begin(); i != ia_tm.end(); ++i)
-            {
-              if (*i == '0' || *i == '1' || *i == '2')
-                {
-                  badguy_data.push_back(BadGuyData(static_cast<BadGuyKind>(*i-'0'),
-                                                x*32, y*32));
-                  *i = 0;
-                }
-              else
-                {
-                  std::map<char, int>::iterator j = transtable.find(*i);
-                  if (j != transtable.end())
-                    *i = j->second;
-                  else
-                    printf("Error: conversion will fail, unsupported char: '%c' (%d)\n", *i, *i);
-                }
-              ++x;
-              if (x >= width)
-                {
-                  x = 0;
-                  ++y;
-                }
-            }
-        }
-    }
-
-  for(int i = 0; i < 15; ++i)
-    {
-      ia_tiles[i] = (unsigned int*) calloc((width +1) , sizeof(unsigned int) );
-      bg_tiles[i] = (unsigned int*) calloc((width +1) , sizeof(unsigned int) );
-      fg_tiles[i] = (unsigned int*) calloc((width +1) , sizeof(unsigned int) );
-    }
-
-  int i = 0;
-  int j = 0;
-  for(vector<int>::iterator it = ia_tm.begin(); it != ia_tm.end(); ++it, ++i)
-    {
-      ia_tiles[j][i] = (*it);
-      if(i == width - 1)
-        {
-          i = -1;
-          ++j;
-        }
-    }
-
-  i = j = 0;
-  for(vector<int>::iterator it = bg_tm.begin(); it != bg_tm.end(); ++it, ++i)
-    {
-
-      bg_tiles[j][i] = (*it);
-      if(i == width - 1)
-        {
-          i = -1;
-          ++j;
-        }
-    }
-
-  i = j = 0;
-  for(vector<int>::iterator it = fg_tm.begin(); it != fg_tm.end(); ++it, ++i)
-    {
+      { // Read Objects
+        lisp_object_t* cur = 0;
+        if (reader.read_lisp("objects",  &cur))
+          {
+            if(world)
+              world->parse_objects(cur);
+          }
+      }
 
-      fg_tiles[j][i] = (*it);
-      if(i == width - 1)
-        {
-          i = -1;
-          ++j;
-        }
+      { // Read Camera
+        lisp_object_t* cur = 0;
+        if (reader.read_lisp("camera", &cur))
+          {
+            LispReader reader(cur);
+            if(world) {
+              world->camera->read(reader);
+            }
+          }
+      }
     }
 
-  // FIXME: Set the global gravity to the latest loaded level's gravity
-  ::gravity = gravity;
-
-  //  Mark the end position of this level!
-  // FIXME: -10 is a rather random value, we still need some kind of
-  // real levelend gola
-  endpos = 32*(width-10);
-
-  fclose(fi);
+  lisp_free(root_obj);
   return 0;
 }
 
 /* Save data for level: */
 
 void 
-Level::save(const  char * subset, int level)
+Level::save(const std::string& subset, int level, World* world)
 {
   char filename[1024];
   char str[80];
 
   /* Save data file: */
-  sprintf(str, "/levels/%s/", subset);
+  snprintf(str, sizeof(str), "/levels/%s/", subset.c_str());
   fcreatedir(str);
-  snprintf(filename, 1024, "%s/levels/%s/level%d.stl", st_dir, subset, level);
+  snprintf(filename, sizeof(filename),
+      "%s/levels/%s/level%d.stl", st_dir, subset.c_str(), level);
   if(!fwriteable(filename))
-    snprintf(filename, 1024, "%s/levels/%s/level%d.stl", datadir.c_str(), subset, level);
-
-  FILE * fi = fopen(filename, "w");
-  if (fi == NULL)
-    {
-      perror(filename);
-      st_shutdown();
-      exit(-1);
-    }
+    snprintf(filename, sizeof(filename), "%s/levels/%s/level%d.stl",
+        datadir.c_str(), subset.c_str(), level);
 
+  std::ofstream out(filename);
+  if(!out.good()) {
+    st_abort("Couldn't write file.", filename);
+  }
+  LispWriter writer(out);
 
   /* Write header: */
-  fprintf(fi,";SuperTux-Level\n");
-  fprintf(fi,"(supertux-level\n");
-
-  fprintf(fi,"  (version %d)\n", 1);
-  fprintf(fi,"  (name \"%s\")\n", name.c_str());
-  fprintf(fi,"  (theme \"%s\")\n", theme.c_str());
-  fprintf(fi,"  (music \"%s\")\n", song_title.c_str());
-  fprintf(fi,"  (background \"%s\")\n", bkgd_image.c_str());
-  fprintf(fi,"  (particle_system \"%s\")\n", particle_system.c_str());
-  fprintf(fi,"  (bkgd_red %d)\n", bkgd_red);
-  fprintf(fi,"  (bkgd_green %d)\n", bkgd_green);
-  fprintf(fi,"  (bkgd_blue %d)\n", bkgd_blue);
-  fprintf(fi,"  (time %d)\n", time_left);
-  fprintf(fi,"  (width %d)\n", width);
-  fprintf(fi,"  (gravity %2.1f)\n", gravity);
-  fprintf(fi,"  (background-tm ");
-
-  for(int y = 0; y < 15; ++y)
-    {
-      for(int i = 0; i < width; ++i)
-        fprintf(fi," %d ", bg_tiles[y][i]);
-    }
-
-  fprintf( fi,")\n");
-  fprintf(fi,"  (interactive-tm ");
-
-  for(int y = 0; y < 15; ++y)
-    {
-      for(int i = 0; i < width; ++i)
-        fprintf(fi," %d ", ia_tiles[y][i]);
-    }
-
-  fprintf( fi,")\n");
-  fprintf(fi,"  (foreground-tm ");
-
-  for(int y = 0; y < 15; ++y)
-    {
-      for(int i = 0; i < width; ++i)
-        fprintf(fi," %d ", fg_tiles[y][i]);
-    }
-
-  fprintf( fi,")\n");
-  fprintf( fi,"(objects\n");
-
-  for(std::vector<BadGuyData>::iterator it = badguy_data.begin();
-      it != badguy_data.end();
-      ++it)
-    fprintf( fi,"(%s (x %d) (y %d))\n",badguykind_to_string((*it).kind).c_str(),(*it).x,(*it).y);
-
-  fprintf( fi,")\n");
-
-  fprintf( fi,")\n");
-
-  fclose(fi);
+  writer.write_comment("SuperTux level made using the built-in leveleditor");
+  writer.start_list("supertux-level");
+
+  writer.write_int("version", 1);
+  writer.write_string("name", name);
+  writer.write_string("author", author);
+  writer.write_string("music", song_title);
+  writer.write_string("background", bkgd_image);
+  writer.write_string("particle_system", particle_system);
+  writer.write_int("bkgd_speed", bkgd_speed);
+  writer.write_int("bkgd_red_top", bkgd_top.red);
+  writer.write_int("bkgd_green_top", bkgd_top.green);
+  writer.write_int("bkgd_blue_top", bkgd_top.blue);
+  writer.write_int("bkgd_red_bottom", bkgd_bottom.red);
+  writer.write_int("bkgd_green_bottom", bkgd_bottom.green);
+  writer.write_int("bkgd_blue_bottom", bkgd_bottom.blue);
+  writer.write_int("time", time_left);
+  writer.write_int("width", width);
+  writer.write_int("height", height);
+  writer.write_float("gravity", gravity);
+
+  writer.write_int_vector("background-tm", bg_tiles);
+  writer.write_int_vector("interactive-tm", ia_tiles);
+  writer.write_int_vector("foreground-tm", fg_tiles);
+
+  writer.start_list("reset-points");
+  for(std::vector<ResetPoint>::iterator i = reset_points.begin();
+      i != reset_points.end(); ++i) {
+    writer.start_list("point");
+    writer.write_int("x", i->x);
+    writer.write_int("y", i->y);
+    writer.end_list("point");
+  }
+  writer.end_list("reset-points");
+
+  // write objects
+  writer.start_list("objects");
+  // pick all objects that can be written into a levelfile
+  for(std::vector<GameObject*>::iterator it = world->gameobjects.begin();
+      it != world->gameobjects.end(); ++it) {
+    Serializable* serializable = dynamic_cast<Serializable*> (*it);
+    if(serializable)
+      serializable->write(writer);
+  }
+  writer.end_list("objects");
+
+  writer.end_list("supertux-level");
+  out.close();
 }
 
-
 /* Unload data for this level: */
-
 void
 Level::cleanup()
 {
-  for(int i=0; i < 15; ++i)
-    free(bg_tiles[i]);
-  for(int i=0; i < 15; ++i)
-    free(ia_tiles[i]);
-  for(int i=0; i < 15; ++i)
-    free(fg_tiles[i]);
-
-  name.clear();
-  theme.clear();
-  song_title.clear();
-  bkgd_image.clear();
-
-  badguy_data.clear();
+  bg_tiles.clear();
+  ia_tiles.clear();
+  fg_tiles.clear();
+
+  reset_points.clear();
+  name = "";
+  author = "";
+  song_title = "";
+  bkgd_image = "";
 }
 
 void 
@@ -546,24 +473,18 @@ Level::load_gfx()
       snprintf(fname, 1024, "%s/background/%s", st_dir, bkgd_image.c_str());
       if(!faccessible(fname))
         snprintf(fname, 1024, "%s/images/background/%s", datadir.c_str(), bkgd_image.c_str());
-      texture_load(&img_bkgd, fname, IGNORE_ALPHA);
+      delete img_bkgd;
+      img_bkgd = new Surface(fname, IGNORE_ALPHA);
     }
   else
     {
-      /* Quick hack to make sure an image is loaded, when we are freeing it afterwards. */
-      load_image(&img_bkgd, theme,"solid0.png", IGNORE_ALPHA);
+      delete img_bkgd;
+      img_bkgd = 0;
     }
 }
 
-void
-Level::free_gfx()
-{
-  texture_free(&img_bkgd);
-}
-
 /* Load a level-specific graphic... */
-void
-Level::load_image(texture_type* ptexture, string theme,const  char * file, int use_alpha)
+void Level::load_image(Surface** ptexture, string theme,const  char * file, int use_alpha)
 {
   char fname[1024];
 
@@ -571,33 +492,46 @@ Level::load_image(texture_type* ptexture, string theme,const  char * file, int u
   if(!faccessible(fname))
     snprintf(fname, 1024, "%s/images/themes/%s/%s", datadir.c_str(), theme.c_str(), file);
 
-  texture_load(ptexture, fname, use_alpha);
-}
-
-void tilemap_change_size(unsigned int** tilemap[15], int w, int old_w)
-{
-  int j,y;
-  for(y = 0; y < 15; ++y)
-    {
-      *tilemap[y] = (unsigned int*) realloc(*tilemap[y],(w+1)*sizeof(unsigned int));
-      if(w > old_w)
-        for(j = 0; j < w - old_w; ++j)
-          *tilemap[y][old_w+j] = 0;
-      *tilemap[y][w] = 0;
-    }
+  *ptexture = new Surface(fname, use_alpha);
 }
 
-/* Change the size of a level (width) */
+/* Change the size of a level */
 void 
-Level::change_size (int new_width)
+Level::resize(int new_width, int new_height)
 {
-  if(new_width < 21)
-    new_width = 21;
-
-  tilemap_change_size((unsigned int***)&ia_tiles, new_width, width);
-  tilemap_change_size((unsigned int***)&bg_tiles, new_width, width);
-  tilemap_change_size((unsigned int***)&fg_tiles, new_width, width);
+  if(new_width < width) {
+    // remap tiles for new width
+    for(int y = 0; y < height && y < new_height; ++y) {
+      for(int x = 0; x < new_width; ++x) {
+        ia_tiles[y * new_width + x] = ia_tiles[y * width + x];
+        bg_tiles[y * new_width + x] = bg_tiles[y * width + x];
+        fg_tiles[y * new_width + x] = fg_tiles[y * width + x];
+      }
+    }
+  }
+
+  ia_tiles.resize(new_width * new_height);
+  bg_tiles.resize(new_width * new_height);
+  fg_tiles.resize(new_width * new_height); 
+
+  if(new_width > width) {
+    // remap tiles
+    for(int y = std::min(height, new_height)-1; y >= 0; --y) {
+      for(int x = new_width-1; x >= 0; --x) {
+        if(x >= width) {
+          ia_tiles[y * new_width + x] = 0;
+          bg_tiles[y * new_width + x] = 0;
+          fg_tiles[y * new_width + x] = 0;
+        } else {
+          ia_tiles[y * new_width + x] = ia_tiles[y * width + x];
+          bg_tiles[y * new_width + x] = bg_tiles[y * width + x];
+          fg_tiles[y * new_width + x] = fg_tiles[y * width + x];
+        }
+      }
+    }
+  }
 
+  height = new_height;
   width = new_width;
 }
 
@@ -607,37 +541,30 @@ Level::change(float x, float y, int tm, unsigned int c)
   int yy = ((int)y / 32);
   int xx = ((int)x / 32);
 
-  if (yy >= 0 && yy < 15 && xx >= 0 && xx <= width)
+  if (yy >= 0 && yy < height && xx >= 0 && xx <= width)
     {
       switch(tm)
         {
         case TM_BG:
-          bg_tiles[yy][xx] = c;
+          bg_tiles[yy * width + xx] = c;
           break;
         case TM_IA:
-          ia_tiles[yy][xx] = c;
+          ia_tiles[yy * width + xx] = c;
           break;
         case TM_FG:
-          fg_tiles[yy][xx] = c;
+          fg_tiles[yy * width + xx] = c;
           break;
         }
     }
 }
 
-void 
-Level::free_song(void)
-{
-  free_music(level_song);
-  free_music(level_song_fast);
-}
-
 void
 Level::load_song()
 {
   char* song_path;
   char* song_subtitle;
 
-  level_song = ::load_song(datadir + "/music/" + song_title);
+  level_song = music_manager->load_music(datadir + "/music/" + song_title);
 
   song_path = (char *) malloc(sizeof(char) * datadir.length() +
                               strlen(song_title.c_str()) + 8 + 5);
@@ -645,14 +572,29 @@ Level::load_song()
   strcpy(strstr(song_subtitle, "."), "\0");
   sprintf(song_path, "%s/music/%s-fast%s", datadir.c_str(), 
           song_subtitle, strstr(song_title.c_str(), "."));
-  level_song_fast = ::load_song(song_path);
+  if(!music_manager->exists_music(song_path)) {
+    level_song_fast = level_song;
+  } else {
+    level_song_fast = music_manager->load_music(song_path);
+  }
   free(song_subtitle);
   free(song_path);
 }
 
+MusicRef
+Level::get_level_music()
+{
+  return level_song;
+}
+
+MusicRef
+Level::get_level_music_fast()
+{
+  return level_song_fast;
+}
 
 unsigned int 
-Level::gettileid(float x, float y)
+Level::gettileid(float x, float y) const
 {
   int xx, yy;
   unsigned int c;
@@ -660,12 +602,21 @@ Level::gettileid(float x, float y)
   yy = ((int)y / 32);
   xx = ((int)x / 32);
 
-  if (yy >= 0 && yy < 15 && xx >= 0 && xx <= width)
-    c = ia_tiles[yy][xx];
+  if (yy >= 0 && yy < height && xx >= 0 && xx <= width)
+    c = ia_tiles[yy * width + xx];
   else
     c = 0;
 
   return c;
 }
 
+unsigned int
+Level::get_tile_at(int x, int y) const
+{
+  if(x < 0 || x >= width || y < 0 || y >= height)
+    return 0;
+  
+  return ia_tiles[y * width + x];
+}
+
 /* EOF */