src/supertux/sector.hpp

Go to the documentation of this file.

//  SuperTux -  A Jump'n Run
//  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_SUPERTUX_SECTOR_HPP
#define HEADER_SUPERTUX_SUPERTUX_SECTOR_HPP

#include <list>
#include <squirrel.h>
#include <stdint.h>

#include "scripting/ssector.hpp"
#include "supertux/direction.hpp"
#include "util/reader_fwd.hpp"
#include "util/writer_fwd.hpp"
#include "util/currenton.hpp"
#include "video/color.hpp"
#include "object/anchor_point.hpp"

namespace collision {
class Constraints;
}

class Vector;
class Rectf;
class Sprite;
class GameObject;
class Player;
class PlayerStatus;
class Camera;
class TileMap;
class Bullet;
class ScriptInterpreter;
class SpawnPoint;
class MovingObject;
class CollisionHit;
class Level;
class Portable;
class DrawingContext;
class DisplayEffect;

enum MusicType {
  LEVEL_MUSIC,
  HERRING_MUSIC,
  HERRING_WARNING_MUSIC
};

class Sector : public scripting::SSector,
               public Currenton<Sector>
{
public:
  Sector(Level* parent);
  ~Sector();

  Level* get_level();

  void parse(const Reader& lisp);
  void parse_old_format(const Reader& lisp);
  
  void activate(const std::string& spawnpoint);
  void activate(const Vector& player_pos);
  void deactivate();

  void update(float elapsed_time);
  void update_game_objects();

  void draw(DrawingContext& context);

  HSQUIRRELVM run_script(std::istream& in, const std::string& sourcename);

  void add_object(GameObject* object);

  void set_name(const std::string& name)
  { this->name = name; }
  const std::string& get_name() const
  { return name; }

  bool inside(const Rectf& rectangle) const;

  void play_music(MusicType musictype);
  MusicType get_music_type();

  bool add_bullet(const Vector& pos, const PlayerStatus* player_status, float xm, Direction dir);
  bool add_smoke_cloud(const Vector& pos);

  static Sector* current()
  { return _current; }

  int get_total_badguys();

  template<class T> int get_total_count()
  {
    int total = 0;
    for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end(); ++i) {
      if (dynamic_cast<T*>(*i)) total++;
    }
    return total;
  }

  void collision_tilemap(collision::Constraints* constraints,
                         const Vector& movement, const Rectf& dest,
                         MovingObject &object) const;

  bool is_free_of_tiles(const Rectf& rect, const bool ignoreUnisolid = false) const;
  bool is_free_of_statics(const Rectf& rect, const MovingObject* ignore_object = 0, const bool ignoreUnisolid = false) const;
  bool is_free_of_movingstatics(const Rectf& rect, const MovingObject* ignore_object = 0) const;

  std::vector<Player*> get_players() {
    return std::vector<Player*>(1, this->player);
  }
  Player *get_nearest_player (const Vector& pos);
  Player *get_nearest_player (const Rectf& pos)
  {
    return (get_nearest_player (get_anchor_pos (pos, ANCHOR_MIDDLE)));
  }

  std::vector<MovingObject*> get_nearby_objects (const Vector& center, float max_distance);

  Rectf get_active_region();

  float get_width() const;

  float get_height() const;

  void change_solid_tiles(uint32_t old_tile_id, uint32_t new_tile_id);

  typedef std::vector<GameObject*> GameObjects;
  typedef std::vector<MovingObject*> MovingObjects;
  typedef std::vector<SpawnPoint*> SpawnPoints;
  typedef std::vector<Portable*> Portables;

  // --- scripting ---
  void set_ambient_light(float red, float green, float blue);
  float get_ambient_red();
  float get_ambient_green();
  float get_ambient_blue();

  void set_gravity(float gravity);
  float get_gravity() const;

private:
  uint32_t collision_tile_attributes(const Rectf& dest) const;

  void before_object_remove(GameObject* object);
  bool before_object_add(GameObject* object);

  void try_expose(GameObject* object);
  void try_unexpose(GameObject* object);
  void try_expose_me();
  void try_unexpose_me();

  void handle_collisions();

  void collision_object(MovingObject* object1, MovingObject* object2) const;

  void collision_static(collision::Constraints* constraints,
                        const Vector& movement, const Rectf& dest, MovingObject& object);

  void collision_static_constrains(MovingObject& object);

  GameObject* parse_object(const std::string& name, const Reader& lisp);

  void fix_old_tiles();

private:
  static Sector* _current;

  Level* level; 
  std::string name;

  std::vector<Bullet*> bullets;

  std::string init_script;

  GameObjects gameobjects_new;

  MusicType currentmusic;

  HSQOBJECT sector_table;
  typedef std::vector<HSQOBJECT> ScriptList;
  ScriptList scripts;

  Color ambient_light;

public: // TODO make this private again
  static bool show_collrects;
  static bool draw_solids_only;

  GameObjects gameobjects;
  MovingObjects moving_objects;
  SpawnPoints spawnpoints;
  Portables portables;

  std::string music;
  float gravity;

  // some special objects, where we need direct access
  // (try to avoid accessing them directly)
  Player* player;
  std::list<TileMap*> solid_tilemaps;
  Camera* camera;
  DisplayEffect* effect;

private:
  Sector(const Sector&);
  Sector& operator=(const Sector&);
};

#endif

/* EOF */

---