src/object/tilemap.hpp

Go to the documentation of this file.

//  SuperTux
//  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
//
//  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 3 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, see <http://www.gnu.org/licenses/>.

#ifndef HEADER_SUPERTUX_OBJECT_TILEMAP_HPP
#define HEADER_SUPERTUX_OBJECT_TILEMAP_HPP

#include <boost/shared_ptr.hpp>

#include "object/path_walker.hpp"
#include "supertux/game_object.hpp"
#include "supertux/script_interface.hpp"
#include "video/drawing_context.hpp"

namespace lisp {
class Lisp;
}

class Level;
class TileManager;
class Tile;
class TileSet;

class TileMap : public GameObject, 
                public ScriptInterface
{
public:
  TileMap(const TileSet *tileset);
  TileMap(const Reader& reader);
  TileMap(const TileSet *tileset, std::string name, int z_pos, bool solid_,
          size_t width_, size_t height_);
  virtual ~TileMap();

  virtual void update(float elapsed_time);
  virtual void draw(DrawingContext& context);

  void goto_node(int node_no);

  void start_moving();

  void stop_moving();

  virtual void expose(HSQUIRRELVM vm, SQInteger table_idx);
  virtual void unexpose(HSQUIRRELVM vm, SQInteger table_idx);

  void set(int width, int height, const std::vector<unsigned int>& vec,
           int z_pos, bool solid);

  void resize(int newwidth, int newheight, int fill_id = 0);

  size_t get_width() const
  { return width; }

  size_t get_height() const
  { return height; }

  Vector get_offset() const
  { return offset; }

  Vector get_movement(bool actual) const
  {
    if(actual) {
      return movement;
    } else {
      return Vector(movement.x, std::max(0.0f,movement.y));
    }
  }

  boost::shared_ptr<Path> get_path()
  { return path; }

  boost::shared_ptr<PathWalker> get_walker()
  { return walker; }

  void set_offset(const Vector &offset)
  { this->offset = offset; }

  /* Returns the position of the upper-left corner of
   * tile (x, y) in the sector. */
  Vector get_tile_position(int x, int y) const
  { return offset + Vector(x,y) * 32; }

  Rectf get_bbox() const
  { return Rectf(get_tile_position(0, 0), get_tile_position(width, height)); }

  Rectf get_tile_bbox(int x, int y) const
  { return Rectf(get_tile_position(x, y), get_tile_position(x+1, y+1)); }

  /* Returns the half-open rectangle of (x, y) tile indices
   * that overlap the given rectangle in the sector. */
  Rect get_tiles_overlapping(const Rectf &rect) const;

  int get_layer() const
  { return z_pos; }

  bool is_solid() const
  { return real_solid && effective_solid; }

  void set_solid(bool solid = true);

  const Tile* get_tile(int x, int y) const;
  const Tile* get_tile_at(const Vector& pos) const;
  uint32_t get_tile_id(int x, int y) const;
  uint32_t get_tile_id_at(const Vector& pos) const;

  void change(int x, int y, uint32_t newtile);

  void change_at(const Vector& pos, uint32_t newtile);

  void change_all(uint32_t oldtile, uint32_t newtile);

  void set_drawing_effect(DrawingEffect effect)
  {
    drawing_effect = effect;
  }

  DrawingEffect get_drawing_effect()
  {
    return drawing_effect;
  }

  void fade(float alpha, float seconds = 0);

  void set_alpha(float alpha);

  float get_alpha();

private:
  const TileSet *tileset;

  typedef std::vector<uint32_t> Tiles;
  Tiles tiles;

  /* read solid: In *general*, is this a solid layer?
   * effective solid: is the layer *currently* solid? A generally solid layer
   * may be not solid when its alpha is low.
   * See `is_solid' above. */
  bool real_solid;
  bool effective_solid;
  void update_effective_solid (void);

  float speed_x;
  float speed_y;
  int width, height;
  int z_pos;
  Vector offset;
  Vector movement; 
  DrawingEffect drawing_effect;
  float alpha; 
  float current_alpha; 
  float remaining_fade_time; 
  boost::shared_ptr<Path> path;
  boost::shared_ptr<PathWalker> walker;

  DrawingContext::Target draw_target; 
private:
  TileMap(const TileMap&);
  TileMap& operator=(const TileMap&);
};

#endif /*SUPERTUX_TILEMAP_H*/

/* EOF */

---