Fixed a Segmentation Fault when mr_iceblock was kicked into a brick containing coins...

[supertux.git] / src / supertux / tile.hpp

diff --git a/src/supertux/tile.hpp b/src/supertux/tile.hpp
index 58ebedb..d0dd424 100644 (file)
--- a/src/supertux/tile.hpp
+++ b/src/supertux/tile.hpp
@@ -1,6 +1,7 @@
 //  SuperTux
 //  Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
+//  Copyright (C) 2010 Florian Forster <supertux at octo.it>
 //
 //  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
@@ -21,18 +22,16 @@
 #include <vector>
 #include <stdint.h>
 
-#include "math/rect.hpp"
+#include "math/rectf.hpp"
 #include "video/surface.hpp"
 #include "util/reader_fwd.hpp"
 
-class TileSet;
 class DrawingContext;
 
 class Tile
 {
 public:
-  friend class TileSetParser;
-  
+  static bool draw_editor_images;
   /// bitset for tile attributes
   enum {
     /** solid tile that is indestructible by Tux */
@@ -85,18 +84,28 @@ public:
   };
 
   struct ImageSpec {
-    ImageSpec(const std::string& newfile, const Rect& newrect)
+    ImageSpec(const std::string& newfile, const Rectf& newrect)
       : file(newfile), rect(newrect)
     { }
 
     std::string file;
-    Rect rect;
+    Rectf rect;
+  };
+
+  enum
+  {
+    UNI_DIR_NORTH = 0,
+    UNI_DIR_SOUTH = 1,
+    UNI_DIR_WEST  = 2,
+    UNI_DIR_EAST  = 3,
+    UNI_DIR_MASK  = 3
   };
 
 private:
-  const TileSet&         tileset;
   std::vector<ImageSpec> imagespecs;
-  std::vector<Surface*>  images;
+  std::vector<SurfacePtr>  images;
+  std::vector<ImageSpec> editor_imagespecs;
+  std::vector<SurfacePtr>  editor_images;
 
   /// tile attributes
   uint32_t attributes;
@@ -104,12 +113,12 @@ private:
   /** General purpose data attached to a tile (content of a box, type of coin)*/
   int data;
 
-  float anim_fps;
+  float fps;
 
 public:
-  Tile(const TileSet& tileset);
-  Tile(const TileSet& tileset, std::vector<std::string> images, Rect rect,
-       uint32_t attributes, uint32_t data, float animfps);
+  Tile();
+  Tile(const std::vector<ImageSpec>& images, const std::vector<ImageSpec>& editor_images,
+       uint32_t attributes, uint32_t data, float fps);
   ~Tile();
 
   /** load Surfaces, if not already loaded */
@@ -124,6 +133,34 @@ public:
   int getData() const
   { return data; }
 
+  /** Checks the SLOPE attribute. Returns "true" if set, "false" otherwise. */
+  bool is_slope() const
+  {
+    return attributes & SLOPE;
+  }
+
+  /** Determine the solidity of a tile. This version behaves correctly for
+   * unisolid tiles by taking position and movement of the object in question
+   * into account. Because creating the arguments for this function can be
+   * expensive, you should handle trivial cases using the "is_solid()" and
+   * "is_unisolid()" methods first. */
+  bool is_solid (const Rectf& tile_bbox, const Rectf& position, const Vector& movement) const;
+
+  /** This version only checks the SOLID flag to determine the solidity of a
+   * tile. This means it will always return "true" for unisolid tiles. To
+   * determine the *current* solidity of unisolid tiles, use the "is_solid"
+   * method that takes position and movement into account (see above). */
+  bool is_solid() const
+  {
+    return attributes & SOLID;
+  }
+
+  /** Checks the UNISOLID attribute. Returns "true" if set, "false" otherwise. */
+  bool is_unisolid() const
+  {
+    return attributes & UNISOLID;
+  }
+
   void print_debug(int id) const;
 
 private:
@@ -131,6 +168,15 @@ private:
   //might miss (and rebuke them for it)
   void correct_attributes();
 
+  /** Returns zero if a unisolid tile is non-solid due to the movement
+   * direction, non-zero if the tile is solid due to direction. */
+  bool check_movement_unisolid (const Vector& movement) const;
+
+  /** Returns zero if a unisolid tile is non-solid due to the position of the
+   * tile and the object, non-zero if the tile is solid. */
+  bool check_position_unisolid (const Rectf& obj_bbox,
+                                const Rectf& tile_bbox) const;
+
 private:
   Tile(const Tile&);
   Tile& operator=(const Tile&);