X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Flevel.cpp;h=4bdf8854f9320636c8eb45f8ed6a0059bdbc047a;hb=403f2652505e814b645892bffaf89a584984f9b8;hp=e21be87522ad53654ddfd5183ee328494a51381c;hpb=9ca86ab4672a4f71a3c6d4351093d9dcbcb02e34;p=supertux.git

diff --git a/src/level.cpp b/src/level.cpp
index e21be8752..4bdf8854f 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,16 +136,19 @@ void st_subset::load(char *subset)
 
         }
 
+      lisp_free(root_obj);
       fclose(fi);
 
       snprintf(str, 1024, "%s.png", filename);
       if(faccessible(str))
         {
+          delete image;
           image = new Surface(str,IGNORE_ALPHA);
         }
       else
         {
           snprintf(filename, 1024, "%s/images/status/level-subset-info.png", datadir.c_str());
+          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,27 +203,15 @@ void st_subset::save()
     }
 }
 
-void st_subset::free()
-{
-  title.clear();
-  description.clear();
-  name.clear();
-  delete image;
-  levels = 0;
-}
-
 Level::Level()
+  : img_bkgd(0)
 {
+  init_defaults();
 }
 
-Level::Level(const std::string& subset, int level)
+Level::~Level()
 {
-  load(subset, level);
-}
-
-Level::Level(const std::string& filename)
-{
-  load(filename);
+  delete img_bkgd;
 }
 
 void
@@ -209,44 +219,29 @@ Level::init_defaults()
 {
   name       = "UnNamed";
   author     = "UnNamed";
-  theme      = "antarctica";
   song_title = "Mortimers_chipdisko.mod";
   bkgd_image = "arctis.png";
-  width      = 21;
+  width      = 0;
+  height     = 0;
   start_pos_x = 100;
   start_pos_y = 170;
   time_left  = 100;
   gravity    = 10.;
+  back_scrolling = false;
+  hor_autoscroll_speed = 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;
-  endpos     = 0;
-
-  for(int i = 0; i < 15; ++i)
-    {
-      ia_tiles[i].resize(width+1, 0);
-      ia_tiles[i][width] = (unsigned int) '\0';
-
-      for(int y = 0; y < width; ++y)
-        ia_tiles[i][y] = 0;
-
-      bg_tiles[i].resize(width+1, 0);
-      bg_tiles[i][width] = (unsigned int) '\0';
-      for(int y = 0; y < width; ++y)
-        bg_tiles[i][y] = 0;
 
-      fg_tiles[i].resize(width+1, 0);
-      fg_tiles[i][width] = (unsigned int) '\0';
-      for(int y = 0; y < width; ++y)
-        fg_tiles[i][y] = 0;
-    }
+  resize(21, 19);
 }
 
 int
-Level::load(const std::string& subset, int level)
+Level::load(const std::string& subset, int level, World* world)
 {
   char filename[1024];
 
@@ -255,87 +250,121 @@ Level::load(const std::string& subset, int level)
   if(!faccessible(filename))
     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());
+      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);
+      if(!reader.read_int("width",  &width))
+        st_abort("No width specified for level.", "");
       if (!reader.read_int("start_pos_x", &start_pos_x)) start_pos_x = 100;
       if (!reader.read_int("start_pos_y", &start_pos_y)) start_pos_y = 170;
-      reader.read_int("time",  &time_left);
-
-      reader.read_int("bkgd_top_red",  &bkgd_top.red);
-      reader.read_int("bkgd_top_green",  &bkgd_top.green);
-      reader.read_int("bkgd_top_blue",  &bkgd_top.blue);
-
-      reader.read_int("bkgd_bottom_red",  &bkgd_bottom.red);
-      reader.read_int("bkgd_bottom_green",  &bkgd_bottom.green);
-      reader.read_int("bkgd_bottom_blue",  &bkgd_bottom.blue);
-
+      time_left = 500;
+      if(!reader.read_int("time",  &time_left)) {
+        printf("Warning no time specified for level.\n");
+      }
+      
+      height = 15;
+      reader.read_int("height",  &height);
+      
+      back_scrolling = false;
+      reader.read_bool("back_scrolling",  &back_scrolling);
+
+      hor_autoscroll_speed = 0;
+      reader.read_float("hor_autoscroll_speed",  &hor_autoscroll_speed);
+      
+      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);
+      author = "unknown author";
       reader.read_string("author", &author);
-      reader.read_string("theme",  &theme);
+      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);
               }
           }
       }
 
+      { // Read BadGuys
+        lisp_object_t* cur = 0;
+        if (reader.read_lisp("objects",  &cur))
+          {
+            if(world)
+              world->parse_objects(cur);
+          }
+      }
+
+#if 0 // TODO fix this or remove it
       // Convert old levels to the new tile numbers
       if (version == 0)
         {
@@ -386,7 +415,7 @@ Level::load(const std::string& filename)
               if (*i == '0' || *i == '1' || *i == '2')
                 {
                   badguy_data.push_back(BadGuyData(static_cast<BadGuyKind>(*i-'0'),
-                                                x*32, y*32));
+                                                   x*32, y*32, false));
                   *i = 0;
                 }
               else
@@ -405,165 +434,101 @@ Level::load(const std::string& filename)
                 }
             }
         }
+#endif
     }
 
-  for(int i = 0; i < 15; ++i)
-    {
-      ia_tiles[i].resize(width + 1, 0);
-      bg_tiles[i].resize(width + 1, 0);
-      fg_tiles[i].resize(width + 1, 0);
-    }
-
-  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)
-    {
-
-      fg_tiles[j][i] = (*it);
-      if(i == width - 1)
-        {
-          i = -1;
-          ++j;
-        }
-    }
-
-  //  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);
+  sprintf(str, "/levels/%s/", subset.c_str());
   fcreatedir(str);
-  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(!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, 1024, "%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,"  (author \"%s\")\n", author.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_top_red %d)\n", bkgd_top.red);
-  fprintf(fi,"  (bkgd_top_green %d)\n", bkgd_top.green);
-  fprintf(fi,"  (bkgd_top_blue %d)\n", bkgd_top.blue);
-  fprintf(fi,"  (bkgd_bottom_red %d)\n", bkgd_bottom.red);
-  fprintf(fi,"  (bkgd_bottom_green %d)\n", bkgd_bottom.green);
-  fprintf(fi,"  (bkgd_bottom_blue %d)\n", bkgd_bottom.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_bool("back_scrolling", back_scrolling);
+  writer.write_float("hor_autoscroll_speed", hor_autoscroll_speed);
+  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("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)
-    {
-      bg_tiles[i].clear();
-      ia_tiles[i].clear();
-      fg_tiles[i].clear();
-    }
-
-  name.clear();
-  author.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 
@@ -575,24 +540,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());
+      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()
-{
-  delete img_bkgd;
-}
-
 /* Load a level-specific graphic... */
-void
-Level::load_image(Surface** 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];
 
@@ -603,20 +562,31 @@ Level::load_image(Surface** ptexture, string theme,const  char * file, int use_a
   *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;
-
-  for(int y = 0; y < 15; ++y)
-    {
-      ia_tiles[y].resize(new_width, 0);
-      bg_tiles[y].resize(new_width, 0);
-      fg_tiles[y].resize(new_width, 0);
+  // first: resize height
+  ia_tiles.resize(new_height * width, 0);
+  bg_tiles.resize(new_height * width, 0);
+  fg_tiles.resize(new_height * width, 0);
+  height = new_height;
+
+  // remap horizontal tiles for new width
+  int np = 0;
+  for(int y = 0; y < height; ++y) {
+    for(int x = 0; x < new_width && x < width; ++x) {
+      ia_tiles[np] = ia_tiles[y * width + x];
+      bg_tiles[np] = bg_tiles[y * width + x];
+      fg_tiles[np] = fg_tiles[y * width + x];
+      np++;
     }
+  }
 
+  ia_tiles.resize(new_height * new_width);
+  bg_tiles.resize(new_height * new_width);
+  fg_tiles.resize(new_height * new_width); 
+  
   width = new_width;
 }
 
@@ -626,28 +596,40 @@ 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)
+void Level::draw_bg()
 {
-  free_music(level_song);
-  free_music(level_song_fast);
+  if(img_bkgd)
+    {
+    // Tile background horizontally
+    int sx = (int)((float)scroll_x * ((float)bkgd_speed/100.0f)) % img_bkgd->w;
+    int sy = (int)((float)scroll_y * ((float)bkgd_speed/100.0f)) % img_bkgd->h;
+    for (int x = 0; (x-1)*img_bkgd->w <= screen->w; x++)
+      for (int y = 0; (y-1)*img_bkgd->h <= screen->h; y++)
+        img_bkgd->draw_part(x == 0 ? sx : 0, y == 0 ? sy : 0,
+                   x == 0 ? 0 : (img_bkgd->w * x) - sx, y == 0 ? 0 : (img_bkgd->h * y) - sy,
+                   x == 0 ? img_bkgd->w - sx : img_bkgd->w, y == 0 ? img_bkgd->h - sy : img_bkgd->h);
+    }
+  else
+    {
+    drawgradient(bkgd_top, bkgd_bottom);
+    }
 }
 
 void
@@ -656,7 +638,7 @@ 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);
@@ -664,13 +646,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;
@@ -678,12 +676,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 */