X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Ftile.cpp;h=901dfcd2c702176d1551786863c38e5cf748106a;hb=c0093d25093395cb62fc2526ab42be65a9f015b8;hp=29575a04eb942a88b5aabd5f3b8b8bd4561ff519;hpb=d46c78c842ab4090a3f46e560c891234167f124b;p=supertux.git

diff --git a/src/tile.cpp b/src/tile.cpp
index 29575a04e..901dfcd2c 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -17,7 +17,6 @@
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 //  02111-1307, USA.
-
 #include <config.h>
 
 #include <cmath>
@@ -26,82 +25,15 @@
 #include <stdexcept>
 
 #include "app/globals.h"
+#include "lisp/lisp.h"
 #include "tile.h"
-#include "scene.h"
-#include "utils/lispreader.h"
+#include "resources.h"
+#include "timer.h"
 #include "math/vector.h"
 #include "video/drawing_context.h"
 
-/** Dirty little helper to create a surface from a snipped of lisp:
- *
- *  "filename"
- *  (region "filename" x y w h)
- */
-static
-Surface* create_surface(lisp_object_t* cur)
-{
-  if (lisp_string_p(cur))
-    {
-      return new Surface(datadir + "/images/tilesets/" + lisp_string(cur),
-                         true);
-    }
-  else if (lisp_cons_p(cur) && lisp_symbol_p(lisp_car(cur)))
-    {
-      lisp_object_t* sym  = lisp_car(cur);
-      lisp_object_t* data = lisp_cdr(cur);
-      
-      if (strcmp(lisp_symbol(sym), "region") == 0)
-        {
-          if (lisp_list_length(data) == 5) // (image-region filename x y w h)
-            {
-              return new Surface(datadir + "/images/tilesets/" + lisp_string(lisp_car(data)), 
-                                 lisp_integer(lisp_list_nth(data, 1)),
-                                 lisp_integer(lisp_list_nth(data, 2)),
-                                 lisp_integer(lisp_list_nth(data, 3)),
-                                 lisp_integer(lisp_list_nth(data, 4)),
-                                 true);
-            }
-          else
-            {
-              std::cout << "Tile: Type mispatch, should be '(region \"somestring\" x y w h)'" << std::endl;
-              return 0;
-            }
-        }
-      else
-        {
-          std::cout << "Tile: Unhandled tag: " << lisp_symbol(sym) << std::endl;
-          return 0;
-        }
-    }
-
-  std::cout << "Tile: unhandled element" << std::endl;
-  return 0;  
-}
-
-/** Create a vector of surfaces (aka Sprite) from a piece of lisp:
-    ((image "bla.png") (image-region "bla.png") ...)
- */
-static 
-std::vector<Surface*> create_surfaces(lisp_object_t* cur)
-{
-  std::vector<Surface*> surfs;
-
-  while(cur)
-    {
-      Surface* surface = create_surface(lisp_car(cur));
-      if (surface)
-        surfs.push_back(surface); 
-      else
-        std::cout << "Tile: Couldn't create image" << std::endl;
-        
-      cur = lisp_cdr(cur);
-    }
-  
-  return surfs;
-}
-
 Tile::Tile()
-  : id(0), attributes(0), data(0), next_tile(0), anim_speed(25)
+  : id(0), editor_image(0), attributes(0), data(0), anim_fps(1)
 {
 }
 
@@ -111,58 +43,135 @@ Tile::~Tile()
       ++i) {
     delete *i;
   }
-  for(std::vector<Surface*>::iterator i = editor_images.begin();
-      i != editor_images.end(); ++i) {
-    delete *i;                                                                
-  }
+  delete editor_image;
 }
 
 void
-Tile::read(LispReader& reader)
+Tile::parse(const lisp::Lisp& reader)
 {
-  if(!reader.read_uint("id", id)) {
+  if(!reader.get("id", id)) {
     throw std::runtime_error("Missing tile-id.");
   }
   
   bool value;
-  if(reader.read_bool("solid", value) && value)
+  if(reader.get("solid", value) && value)
     attributes |= SOLID;
-  if(reader.read_bool("unisolid", value) && value)
+  if(reader.get("unisolid", value) && value)
     attributes |= UNISOLID | SOLID;
-  if(reader.read_bool("brick", value) && value)
+  if(reader.get("brick", value) && value)
     attributes |= BRICK;
-  if(reader.read_bool("ice", value) && value)
+  if(reader.get("ice", value) && value)
     attributes |= ICE;
-  if(reader.read_bool("water", value) && value)
+  if(reader.get("water", value) && value)
     attributes |= WATER;
-  if(reader.read_bool("spike", value) && value)
+  if(reader.get("spike", value) && value)
     attributes |= SPIKE;
-  if(reader.read_bool("fullbox", value) && value)
+  if(reader.get("fullbox", value) && value)
     attributes |= FULLBOX;
-  if(reader.read_bool("distro", value) && value)
+  if(reader.get("coin", value) && value)
     attributes |= COIN;
-  if(reader.read_bool("coin", value) && value)
-    attributes |= COIN;
-  if(reader.read_bool("goal", value) && value)
+  if(reader.get("goal", value) && value)
     attributes |= GOAL;
 
-  reader.read_int("data", data);
-  reader.read_int("anim-speed", anim_speed);
-  reader.read_int("next-tile", next_tile);
+  if(reader.get("north", value) && value)
+    data |= WORLDMAP_NORTH;
+  if(reader.get("south", value) && value)
+    data |= WORLDMAP_SOUTH;
+  if(reader.get("west", value) && value)
+    data |= WORLDMAP_WEST;
+  if(reader.get("east", value) && value) 
+    data |= WORLDMAP_EAST;
+  if(reader.get("stop", value) && value)
+    data |= WORLDMAP_STOP;                      
+
+  reader.get("data", data);
+  reader.get("anim-fps", anim_fps);
 
-  if(reader.read_int("slope-type", data)) {
+  if(reader.get("slope-type", data)) {
     attributes |= SOLID | SLOPE;
   }
 
-  images        = create_surfaces(reader.read_lisp("images"));
-  editor_images = create_surfaces(reader.read_lisp("editor-images"));
+  const lisp::Lisp* images = reader.get_lisp("images");
+  if(images)
+    parse_images(*images);
+  reader.get("editor-images", editor_imagefile);
+}
+
+void
+Tile::parse_images(const lisp::Lisp& images_lisp)
+{
+  const lisp::Lisp* list = &images_lisp;
+  while(list) {
+    const lisp::Lisp* cur = list->get_car();
+    if(cur->get_type() == lisp::Lisp::TYPE_STRING) {
+      std::string file;
+      cur->get(file);
+      imagespecs.push_back(ImageSpec(file, Rectangle(0, 0, 0, 0)));
+    } else if(cur->get_type() == lisp::Lisp::TYPE_CONS && 
+        cur->get_car()->get_type() == lisp::Lisp::TYPE_SYMBOL) {
+      const lisp::Lisp* ptr = cur->get_cdr();
+
+      std::string file;
+      float x, y, w, h;
+      ptr->get_car()->get(file); ptr = ptr->get_cdr();
+      ptr->get_car()->get(x); ptr = ptr->get_cdr();
+      ptr->get_car()->get(y); ptr = ptr->get_cdr();
+      ptr->get_car()->get(w); ptr = ptr->get_cdr();
+      ptr->get_car()->get(h);
+      imagespecs.push_back(ImageSpec(file, Rectangle(x, y, x+w, y+h)));
+    } else {
+      std::cerr << "Expected string or list in images tag.\n";
+      continue;
+    }
+    
+    list = list->get_cdr();
+  }
+}
+
+void
+Tile::load_images(const std::string& tilesetpath)
+{
+  assert(images.size() == 0);
+  for(std::vector<ImageSpec>::iterator i = imagespecs.begin(); i !=
+      imagespecs.end(); ++i) {
+    const ImageSpec& spec = *i;
+    Surface* surface;
+    std::string file 
+      = get_resource_filename(tilesetpath + spec.file);
+    if(spec.rect.get_width() <= 0) {
+      surface = new Surface(file, true);
+    } else {
+      surface = new Surface(file,
+          (int) spec.rect.p1.x,
+          (int) spec.rect.p1.y,
+          (int) spec.rect.get_width(),
+          (int) spec.rect.get_height(), true);
+    }
+    images.push_back(surface);
+  }
+  if(editor_imagefile != "") {
+    editor_image = new Surface(
+        get_resource_filename(
+          std::string("images/tilesets/") + editor_imagefile), true);
+  }
+}
+
+Surface*
+Tile::get_editor_image() const
+{
+  if(editor_image)
+    return editor_image;
+  if(images.size() > 0)
+    return images[0];
+
+  return 0;
 }
 
 void
 Tile::draw(DrawingContext& context, const Vector& pos, int layer) const
 {
   if(images.size() > 1) {
-    size_t frame = ((global_frame_counter*25) / anim_speed) % images.size();
+    size_t frame = size_t(global_time * anim_fps) % images.size();
     context.draw_surface(images[frame], pos, layer);
   } else if (images.size() == 1) {
     context.draw_surface(images[0], pos, layer);