Sector Class Reference

Represents one of (potentially) multiple, separate parts of a Level. More...

#include <sector.hpp>

Inherits scripting::SSector, and Currenton< Sector >.

List of all members.

Public Types
typedef std::vector< GameObject * >	GameObjects
typedef std::vector< MovingObject * >	MovingObjects
typedef std::vector< SpawnPoint * >	SpawnPoints
typedef std::vector< Portable * >	Portables
Public Member Functions
	Sector (Level *parent)
	~Sector ()
Level *	get_level ()
	get parent level
void	parse (const Reader &lisp)
	read sector from lisp file
void	parse_old_format (const Reader &lisp)
void	activate (const std::string &spawnpoint)
	activates this sector (change music, initialize player class, ...)
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)
	runs a script in the context of the sector (sector_table will be the roottable of this squirrel VM)
void	add_object (GameObject *object)
	adds a gameobject
void	set_name (const std::string &name)
const std::string &	get_name () const
bool	inside (const Rectf &rectangle) const
	tests if a given rectangle is inside the sector (a rectangle that is on top of the sector is considered inside)
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)
int	get_total_badguys ()
	Get total number of badguys.
template<class T>
int	get_total_count ()
	Get total number of GameObjects of given type.
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
	Checks if the specified rectangle is free of (solid) tiles.
bool	is_free_of_statics (const Rectf &rect, const MovingObject *ignore_object=0, const bool ignoreUnisolid=false) const
	Checks if the specified rectangle is free of both 1.
bool	is_free_of_movingstatics (const Rectf &rect, const MovingObject *ignore_object=0) const
	Checks if the specified rectangle is free of both 1.
std::vector< Player * >	get_players ()
	returns a list of players currently in the sector
Player *	get_nearest_player (const Vector &pos)
Player *	get_nearest_player (const Rectf &pos)
std::vector< MovingObject * >	get_nearby_objects (const Vector &center, float max_distance)
Rectf	get_active_region ()
float	get_width () const
	returns the width (in px) of a sector)
float	get_height () const
	returns the height (in px) of a sector)
void	change_solid_tiles (uint32_t old_tile_id, uint32_t new_tile_id)
	globally changes solid tilemaps' tile ids
void	set_ambient_light (float red, float green, float blue)
	get/set color of ambient light
float	get_ambient_red ()
float	get_ambient_green ()
float	get_ambient_blue ()
void	set_gravity (float gravity)
	set gravity throughout sector
float	get_gravity () const
Static Public Member Functions
static Sector *	current ()
	get currently activated sector.
Public Attributes
GameObjects	gameobjects
MovingObjects	moving_objects
SpawnPoints	spawnpoints
Portables	portables
std::string	music
float	gravity
Player *	player
std::list< TileMap * >	solid_tilemaps
Camera *	camera
DisplayEffect *	effect
Static Public Attributes
static bool	show_collrects
	show collision rectangles of moving objects (for debugging)
static bool	draw_solids_only
Private Types
typedef std::vector< HSQOBJECT >	ScriptList
	sector scripts
Private Member Functions
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 ()
	Checks for all possible collisions.
void	collision_object (MovingObject *object1, MovingObject *object2) const
	Does collision detection between 2 objects and does instant collision response handling in case of a collision.
void	collision_static (collision::Constraints *constraints, const Vector &movement, const Rectf &dest, MovingObject &object)
	Does collision detection of an object against all other static objects (and the tilemap) in the level.
void	collision_static_constrains (MovingObject &object)
GameObject *	parse_object (const std::string &name, const Reader &lisp)
void	fix_old_tiles ()
	Sector (const Sector &)
Sector &	operator= (const Sector &)
Private Attributes
Level *	level
	Parent level containing this sector.
std::string	name
std::vector< Bullet * >	bullets
std::string	init_script
GameObjects	gameobjects_new
	container for newly created objects, they'll be added in Sector::update
MusicType	currentmusic
HSQOBJECT	sector_table
ScriptList	scripts
Color	ambient_light
Static Private Attributes
static Sector *	_current

---

Detailed Description

Represents one of (potentially) multiple, separate parts of a Level.

Sectors contain GameObjects, e.g. Badguys and Players.

Definition at line 65 of file sector.hpp.

---

Member Typedef Documentation

typedef std::vector<GameObject*> Sector::GameObjects

Definition at line 187 of file sector.hpp.

typedef std::vector<MovingObject*> Sector::MovingObjects

Definition at line 188 of file sector.hpp.

typedef std::vector<SpawnPoint*> Sector::SpawnPoints

Definition at line 189 of file sector.hpp.

typedef std::vector<Portable*> Sector::Portables

Definition at line 190 of file sector.hpp.

typedef std::vector<HSQOBJECT> Sector::ScriptList [private]

sector scripts

Definition at line 265 of file sector.hpp.

---

Constructor & Destructor Documentation

Sector::Sector

(

Level *

parent

)

Definition at line 67 of file sector.cpp.

References add_object(), Currenton< GameSession >::current(), scripting::global_vm, SoundManager::preload(), sector_table, and sound_manager.

                            :
  level(parent), 
  name(),
  bullets(),
  init_script(),
  gameobjects_new(),
  currentmusic(LEVEL_MUSIC),
  sector_table(),
  scripts(),
  ambient_light( 1.0f, 1.0f, 1.0f, 1.0f ), 
  gameobjects(),
  moving_objects(),
  spawnpoints(),
  portables(),
  music(),
  gravity(10.0), 
  player(0), 
  solid_tilemaps(),
  camera(0), 
  effect(0)
{
  add_object(new Player(GameSession::current()->get_player_status(), "Tux"));
  add_object(new DisplayEffect("Effect"));
  add_object(new TextObject("Text"));

  sound_manager->preload("sounds/shoot.wav");

  // create a new squirrel table for the sector
  using namespace scripting;

  sq_collectgarbage(global_vm);

  sq_newtable(global_vm);
  sq_pushroottable(global_vm);
  if(SQ_FAILED(sq_setdelegate(global_vm, -2)))
    throw scripting::SquirrelError(global_vm, "Couldn't set sector_table delegate");

  sq_resetobject(&sector_table);
  if(SQ_FAILED(sq_getstackobj(global_vm, -1, &sector_table)))
    throw scripting::SquirrelError(global_vm, "Couldn't get sector table");
  sq_addref(global_vm, &sector_table);
  sq_pop(global_vm, 1);
}

Sector::~Sector

(

)

Definition at line 111 of file sector.cpp.

References before_object_remove(), deactivate(), gameobjects, gameobjects_new, scripting::global_vm, scripts, sector_table, spawnpoints, and update_game_objects().

{
  using namespace scripting;

  deactivate();

  for(ScriptList::iterator i = scripts.begin();
      i != scripts.end(); ++i) {
    HSQOBJECT& object = *i;
    sq_release(global_vm, &object);
  }
  sq_release(global_vm, &sector_table);
  sq_collectgarbage(global_vm);

  update_game_objects();
  assert(gameobjects_new.size() == 0);

  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    GameObject* object = *i;
    before_object_remove(object);
    object->unref();
  }

  for(SpawnPoints::iterator i = spawnpoints.begin(); i != spawnpoints.end();
      ++i)
    delete *i;
}

Sector::Sector

(

const Sector &

)

[private]

---

Member Function Documentation

Level * Sector::get_level

(

)

get parent level

Definition at line 141 of file sector.cpp.

References level.

Referenced by activate(), Coin::collect(), OneUp::collision(), SecretAreaTrigger::event(), BadGuy::run_dead_script(), and BonusBlock::try_open().

{
  return level;
}

void Sector::parse

(

const Reader &

lisp

)

read sector from lisp file

Definition at line 186 of file sector.cpp.

References add_object(), ambient_light, camera, fix_old_tiles(), lisp::Lisp::get(), gravity, init_script, lisp::ListIterator::item(), lisp::ListIterator::lisp(), log_warning, music, name, lisp::ListIterator::next(), parse_object(), Gradient::set_gradient(), solid_tilemaps, spawnpoints, update_game_objects(), and lisp::ListIterator::value().

Referenced by Level::load().

{
  bool has_background = false;
  lisp::ListIterator iter(&sector);
  while(iter.next()) {
    const std::string& token = iter.item();
    if(token == "name") {
      iter.value()->get(name);
    } else if(token == "gravity") {
      iter.value()->get(gravity);
    } else if(token == "music") {
      iter.value()->get(music);
    } else if(token == "spawnpoint") {
      SpawnPoint* sp = new SpawnPoint(*iter.lisp());
      spawnpoints.push_back(sp);
    } else if(token == "init-script") {
      iter.value()->get(init_script);
    } else if(token == "ambient-light") {
      std::vector<float> vColor;
      sector.get( "ambient-light", vColor );
      if(vColor.size() < 3) {
        log_warning << "(ambient-light) requires a color as argument" << std::endl;
      } else {
        ambient_light = Color( vColor );
      }
    } else {
      GameObject* object = parse_object(token, *(iter.lisp()));
      if(object) {
        if(dynamic_cast<Background *>(object)) {
          has_background = true;
        } else if(dynamic_cast<Gradient *>(object)) {
          has_background = true;
        }
        add_object(object);
      }
    }
  }

  if(!has_background) {
    Gradient* gradient = new Gradient();
    gradient->set_gradient(Color(0.3, 0.4, 0.75), Color(1, 1, 1));
    add_object(gradient);
  }

  update_game_objects();

  if(solid_tilemaps.size() < 1) log_warning << "sector '" << name << "' does not contain a solid tile layer." << std::endl;

  fix_old_tiles();
  if(!camera) {
    log_warning << "sector '" << name << "' does not contain a camera." << std::endl;
    update_game_objects();
    add_object(new Camera(this, "Camera"));
  }

  update_game_objects();
}

void Sector::parse_old_format

(

const Reader &

lisp

)

Definition at line 245 of file sector.cpp.

References add_object(), Color::blue, camera, fix_old_tiles(), lisp::Lisp::get(), lisp::Lisp::get_lisp(), Level::get_tileset(), gravity, Color::green, lisp::ListIterator::item(), LAYER_BACKGROUNDTILES, LAYER_FOREGROUNDTILES, LAYER_TILES, level, lisp::ListIterator::lisp(), log_warning, music, SpawnPoint::name, name, lisp::ListIterator::next(), parse_object(), SpawnPoint::pos, Color::red, Gradient::set_gradient(), Background::set_image(), solid_tilemaps, spawnpoints, update_game_objects(), Vector::x, and Vector::y.

Referenced by Level::load_old_format().

{
  name = "main";
  reader.get("gravity", gravity);

  std::string backgroundimage;
  if (reader.get("background", backgroundimage) && (backgroundimage != "")) {
    if (backgroundimage == "arctis.png") backgroundimage = "arctis.jpg";
    if (backgroundimage == "arctis2.jpg") backgroundimage = "arctis.jpg";
    if (backgroundimage == "ocean.png") backgroundimage = "ocean.jpg";
    backgroundimage = "images/background/" + backgroundimage;
    if (!PHYSFS_exists(backgroundimage.c_str())) {
      log_warning << "Background image \"" << backgroundimage << "\" not found. Ignoring." << std::endl;
      backgroundimage = "";
    }
  }

  float bgspeed = .5;
  reader.get("bkgd_speed", bgspeed);
  bgspeed /= 100;

  Color bkgd_top, bkgd_bottom;
  int r = 0, g = 0, b = 128;
  reader.get("bkgd_red_top", r);
  reader.get("bkgd_green_top",  g);
  reader.get("bkgd_blue_top",  b);
  bkgd_top.red = static_cast<float> (r) / 255.0f;
  bkgd_top.green = static_cast<float> (g) / 255.0f;
  bkgd_top.blue = static_cast<float> (b) / 255.0f;

  reader.get("bkgd_red_bottom",  r);
  reader.get("bkgd_green_bottom", g);
  reader.get("bkgd_blue_bottom", b);
  bkgd_bottom.red = static_cast<float> (r) / 255.0f;
  bkgd_bottom.green = static_cast<float> (g) / 255.0f;
  bkgd_bottom.blue = static_cast<float> (b) / 255.0f;

  if(backgroundimage != "") {
    Background* background = new Background();
    background->set_image(backgroundimage, bgspeed);
    add_object(background);
  } else {
    Gradient* gradient = new Gradient();
    gradient->set_gradient(bkgd_top, bkgd_bottom);
    add_object(gradient);
  }

  std::string particlesystem;
  reader.get("particle_system", particlesystem);
  if(particlesystem == "clouds")
    add_object(new CloudParticleSystem());
  else if(particlesystem == "snow")
    add_object(new SnowParticleSystem());
  else if(particlesystem == "rain")
    add_object(new RainParticleSystem());

  Vector startpos(100, 170);
  reader.get("start_pos_x", startpos.x);
  reader.get("start_pos_y", startpos.y);

  SpawnPoint* spawn = new SpawnPoint;
  spawn->pos = startpos;
  spawn->name = "main";
  spawnpoints.push_back(spawn);

  music = "chipdisko.ogg";
  // skip reading music filename. It's all .ogg now, anyway
  /*
    reader.get("music", music);
  */
  music = "music/" + music;

  int width = 30, height = 15;
  reader.get("width", width);
  reader.get("height", height);

  std::vector<unsigned int> tiles;
  if(reader.get("interactive-tm", tiles)
     || reader.get("tilemap", tiles)) {
    TileMap* tilemap = new TileMap(level->get_tileset());
    tilemap->set(width, height, tiles, LAYER_TILES, true);

    // replace tile id 112 (old invisible tile) with 1311 (new invisible tile)
    for(size_t x=0; x < tilemap->get_width(); ++x) {
      for(size_t y=0; y < tilemap->get_height(); ++y) {
        uint32_t id = tilemap->get_tile_id(x, y);
        if(id == 112)
          tilemap->change(x, y, 1311);
      }
    }

    if (height < 19) tilemap->resize(width, 19);
    add_object(tilemap);
  }

  if(reader.get("background-tm", tiles)) {
    TileMap* tilemap = new TileMap(level->get_tileset());
    tilemap->set(width, height, tiles, LAYER_BACKGROUNDTILES, false);
    if (height < 19) tilemap->resize(width, 19);
    add_object(tilemap);
  }

  if(reader.get("foreground-tm", tiles)) {
    TileMap* tilemap = new TileMap(level->get_tileset());
    tilemap->set(width, height, tiles, LAYER_FOREGROUNDTILES, false);

    // fill additional space in foreground with tiles of ID 2035 (lightmap/black)
    if (height < 19) tilemap->resize(width, 19, 2035);

    add_object(tilemap);
  }

  // read reset-points (now spawn-points)
  const lisp::Lisp* resetpoints = reader.get_lisp("reset-points");
  if(resetpoints) {
    lisp::ListIterator iter(resetpoints);
    while(iter.next()) {
      if(iter.item() == "point") {
        Vector sp_pos;
        if(reader.get("x", sp_pos.x) && reader.get("y", sp_pos.y))
        {
          SpawnPoint* sp = new SpawnPoint;
          sp->name = "main";
          sp->pos = sp_pos;
          spawnpoints.push_back(sp);
        }
      } else {
        log_warning << "Unknown token '" << iter.item() << "' in reset-points." << std::endl;
      }
    }
  }

  // read objects
  const lisp::Lisp* objects = reader.get_lisp("objects");
  if(objects) {
    lisp::ListIterator iter(objects);
    while(iter.next()) {
      GameObject* object = parse_object(iter.item(), *(iter.lisp()));
      if(object) {
        add_object(object);
      } else {
        log_warning << "Unknown object '" << iter.item() << "' in level." << std::endl;
      }
    }
  }

  // add a camera
  Camera* camera = new Camera(this, "Camera");
  add_object(camera);

  update_game_objects();

  if(solid_tilemaps.size() < 1) log_warning << "sector '" << name << "' does not contain a solid tile layer." << std::endl;

  fix_old_tiles();
  update_game_objects();
}

void Sector::activate

(

const std::string &

spawnpoint

)

activates this sector (change music, initialize player class, ...)

Definition at line 525 of file sector.cpp.

References log_warning, SpawnPoint::pos, and spawnpoints.

Referenced by TitleScreen::make_tux_jump(), GameSession::restart_level(), TitleScreen::setup(), GameSession::setup(), and GameSession::update().

{
  SpawnPoint* sp = 0;
  for(SpawnPoints::iterator i = spawnpoints.begin(); i != spawnpoints.end();
      ++i) {
    if((*i)->name == spawnpoint) {
      sp = *i;
      break;
    }
  }
  if(!sp) {
    log_warning << "Spawnpoint '" << spawnpoint << "' not found." << std::endl;
    if(spawnpoint != "main") {
      activate("main");
    } else {
      activate(Vector(0, 0));
    }
  } else {
    activate(sp->pos);
  }
}

void Sector::activate

(

const Vector &

player_pos

)

Definition at line 548 of file sector.cpp.

References _current, camera, deactivate(), FileSystem::dirname(), gameobjects, get_level(), MovingObject::get_pos(), scripting::global_vm, init_script, is_free_of_tiles(), log_warning, player, Camera::reset(), run_script(), sector_table, try_expose(), try_expose_me(), update_game_objects(), and Vector::y.

{
  if(_current != this) {
    if(_current != NULL)
      _current->deactivate();
    _current = this;

    // register sectortable as sector in scripting
    HSQUIRRELVM vm = scripting::global_vm;
    sq_pushroottable(vm);
    sq_pushstring(vm, "sector", -1);
    sq_pushobject(vm, sector_table);
    if(SQ_FAILED(sq_createslot(vm, -3)))
      throw scripting::SquirrelError(vm, "Couldn't set sector in roottable");
    sq_pop(vm, 1);

    for(GameObjects::iterator i = gameobjects.begin();
        i != gameobjects.end(); ++i) {
      GameObject* object = *i;

      try_expose(object);
    }
  }
  try_expose_me();


  // two-player hack: move other players to main player's position
  // Maybe specify 2 spawnpoints in the level?
  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    Player* p = dynamic_cast<Player*>(*i);
    if (!p) continue;

    // spawn smalltux below spawnpoint
    if (!p->is_big()) {
      p->move(player_pos + Vector(0,32));
    } else {
      p->move(player_pos);
    }

    // spawning tux in the ground would kill him
    if(!is_free_of_tiles(p->get_bbox())) {
      log_warning << "Tried spawning Tux in solid matter. Compensating." << std::endl;
      Vector npos = p->get_bbox().p1;
      npos.y-=32;
      p->move(npos);
    }
  }

  camera->reset(player->get_pos());
  update_game_objects();

  //Run default.nut just before init script
  //Check to see if it's in a levelset (info file)
  std::string basedir = FileSystem::dirname(get_level()->filename);
  if(PHYSFS_exists((basedir + "/info").c_str())) {
    try {
      IFileStream in(basedir + "/default.nut");
      run_script(in, "default.nut");
    } catch(std::exception& ) {
      // doesn't exist or erroneous; do nothing
    }
  }

  // Run init script
  if(init_script != "") {
    std::istringstream in(init_script);
    run_script(in, "init-script");
  }
}

void Sector::deactivate

(

)

Definition at line 620 of file sector.cpp.

References _current, gameobjects, scripting::global_vm, try_unexpose(), and try_unexpose_me().

Referenced by activate(), TitleScreen::leave(), and ~Sector().

{
  if(_current != this)
    return;

  // remove sector entry from global vm
  HSQUIRRELVM vm = scripting::global_vm;
  sq_pushroottable(vm);
  sq_pushstring(vm, "sector", -1);
  if(SQ_FAILED(sq_deleteslot(vm, -2, SQFalse)))
    throw scripting::SquirrelError(vm, "Couldn't unset sector in roottable");
  sq_pop(vm, 1);

  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    GameObject* object = *i;

    try_unexpose(object);
  }

  try_unexpose_me();
  _current = NULL;
}

void Sector::update

(

float

elapsed_time

)

Definition at line 653 of file sector.cpp.

References Player::check_bounds(), gameobjects, handle_collisions(), player, and update_game_objects().

Referenced by TitleScreen::update(), and GameSession::update().

{
  player->check_bounds();

  /* update objects */
  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    GameObject* object = *i;
    if(!object->is_valid())
      continue;

    object->update(elapsed_time);
  }

  /* Handle all possible collisions. */
  handle_collisions();
  update_game_objects();
}

void Sector::update_game_objects

(

)

Definition at line 673 of file sector.cpp.

References before_object_add(), before_object_remove(), gameobjects, gameobjects_new, and solid_tilemaps.

Referenced by activate(), parse(), parse_old_format(), update(), and ~Sector().

{
  for(std::vector<GameObject*>::iterator i = gameobjects.begin();
      i != gameobjects.end(); /* nothing */) {
    GameObject* object = *i;

    if(object->is_valid()) {
      ++i;
      continue;
    }

    before_object_remove(object);

    object->unref();
    i = gameobjects.erase(i);
  }

  /* add newly created objects */
  for(std::vector<GameObject*>::iterator i = gameobjects_new.begin();
      i != gameobjects_new.end(); ++i)
  {
    GameObject* object = *i;

    before_object_add(object);

    gameobjects.push_back(object);
  }
  gameobjects_new.clear();

  /* update solid_tilemaps list */
  //FIXME: this could be more efficient
  solid_tilemaps.clear();
  for(std::vector<GameObject*>::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i)
  {
    TileMap* tm = dynamic_cast<TileMap*>(*i);
    if (!tm) continue;
    if (tm->is_solid()) solid_tilemaps.push_back(tm);
  }

}

void Sector::draw

(

DrawingContext &

context

)

Definition at line 847 of file sector.cpp.

References ambient_light, camera, DrawingContext::draw_filled_rect(), draw_solids_only, gameobjects, Camera::get_translation(), TileMap::is_solid(), LAYER_FOREGROUND1, moving_objects, DrawingContext::pop_transform(), DrawingContext::push_transform(), DrawingContext::set_ambient_color(), DrawingContext::set_translation(), and show_collrects.

Referenced by TitleScreen::draw(), and GameSession::draw().

{
  context.set_ambient_color( ambient_light );
  context.push_transform();
  context.set_translation(camera->get_translation());

  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    GameObject* object = *i;
    if(!object->is_valid())
      continue;

    if (draw_solids_only)
    {
      TileMap* tm = dynamic_cast<TileMap*>(object);
      if (tm && !tm->is_solid())
        continue;
    }

    object->draw(context);
  }

  if(show_collrects) {
    Color color(1.0f, 0.0f, 0.0f, 0.75f);
    for(MovingObjects::iterator i = moving_objects.begin();
        i != moving_objects.end(); ++i) {
      MovingObject* object = *i;
      const Rectf& rect = object->get_bbox();

      context.draw_filled_rect(rect, color, LAYER_FOREGROUND1 + 10);
    }
  }

  context.pop_transform();
}

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

runs a script in the context of the sector (sector_table will be the roottable of this squirrel VM)

Definition at line 468 of file sector.cpp.

References scripting::compile_and_run(), scripting::create_thread(), scripting::global_vm, log_warning, name, scripting::object_to_vm(), scripts, and sector_table.

Referenced by activate(), Door::collision(), PushButton::collision(), PowerUp::collision(), WillOWisp::collision_player(), ScriptTrigger::event(), BadGuy::run_dead_script(), Switch::update(), and Ispy::update().

{
  using namespace scripting;

  // garbage collect thread list
  for(ScriptList::iterator i = scripts.begin();
      i != scripts.end(); ) {
    HSQOBJECT& object = *i;
    HSQUIRRELVM vm = object_to_vm(object);

    if(sq_getvmstate(vm) != SQ_VMSTATE_SUSPENDED) {
      sq_release(global_vm, &object);
      i = scripts.erase(i);
      continue;
    }

    ++i;
  }

  HSQOBJECT object = create_thread(global_vm);
  scripts.push_back(object);

  HSQUIRRELVM vm = object_to_vm(object);

  // set sector_table as roottable for the thread
  sq_pushobject(vm, sector_table);
  sq_setroottable(vm);

  try {
    compile_and_run(vm, in, "Sector " + name + " - " + sourcename);
  } catch(std::exception& e) {
    log_warning << "Error running script: " << e.what() << std::endl;
  }

  return vm;
}

void Sector::add_object

(

GameObject *

object

)

adds a gameobject

Definition at line 506 of file sector.cpp.

References gameobjects, gameobjects_new, and RefCounter::ref().

Referenced by GhostTree::active_update(), FlyingSnowBall::active_update(), add_bullet(), add_smoke_cloud(), Block::break_me(), Coin::collect(), Firefly::collision(), Player::collision_solid(), Stumpy::collision_squished(), Snowman::collision_squished(), PoisonIvy::collision_squished(), MrTree::collision_squished(), MrBomb::collision_squished(), Thunderstorm::electrify(), Explosion::explode(), SkyDive::explode(), ShortFuse::explode(), Bomb::explode(), DartTrap::fire(), fix_old_tiles(), scripting::FloatingImage::FloatingImage(), Player::handle_horizontal_input(), Owl::initialize(), MrBomb::kill_fall(), Haywire::kill_fall(), Dispenser::launch_badguy(), parse(), parse_old_format(), Candle::puff_smoke(), Sector(), Player::set_bonus(), GhostTree::spawn_lantern(), GameSession::start_sequence(), EndSequenceFireworks::starting(), Mole::throw_rock(), Brick::try_break(), BonusBlock::try_open(), Wind::update(), SpecialRiser::update(), RainParticleSystem::update(), PneumaticPlatform::update(), Player::update(), CometParticleSystem::update(), and BicyclePlatform::update().

{
  // make sure the object isn't already in the list
#ifndef NDEBUG
  for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end();
      ++i) {
    assert(*i != object);
  }
  for(GameObjects::iterator i = gameobjects_new.begin();
      i != gameobjects_new.end(); ++i) {
    assert(*i != object);
  }
#endif

  object->ref();
  gameobjects_new.push_back(object);
}

void Sector::set_name

(

const std::string &

name

)

[inline]

Definition at line 98 of file sector.hpp.

  { this->name = name; }

const std::string& Sector::get_name

(

)

const [inline]

Definition at line 100 of file sector.hpp.

References name.

Referenced by Level::add_sector().

  { return name; }

bool Sector::inside

(

const Rectf &

rectangle

)

const

tests if a given rectangle is inside the sector (a rectangle that is on top of the sector is considered inside)

Definition at line 1509 of file sector.cpp.

References Rectf::contains(), Rectf::p1, solid_tilemaps, and Vector::y.

{
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;

    Rectf bbox = solids->get_bbox();
    bbox.p1.y = -INFINITY; // pretend the tilemap extends infinitely far upwards

    if (bbox.contains(rect))
      return true;
  }
  return false;
}

void Sector::play_music

(

MusicType

musictype

)

Definition at line 1469 of file sector.cpp.

References currentmusic, HERRING_MUSIC, HERRING_WARNING_MUSIC, LEVEL_MUSIC, music, SoundManager::play_music(), sound_manager, SoundManager::stop_music(), and TUX_INVINCIBLE_TIME_WARNING.

Referenced by Player::make_invincible(), GameSession::restart_level(), TitleScreen::setup(), GameSession::setup(), and GameSession::update().

{
  currentmusic = type;
  switch(currentmusic) {
    case LEVEL_MUSIC:
      sound_manager->play_music(music);
      break;
    case HERRING_MUSIC:
      sound_manager->play_music("music/invincible.ogg");
      break;
    case HERRING_WARNING_MUSIC:
      sound_manager->stop_music(TUX_INVINCIBLE_TIME_WARNING);
      break;
    default:
      sound_manager->play_music("");
      break;
  }
}

MusicType Sector::get_music_type

(

)

Definition at line 1489 of file sector.cpp.

References currentmusic.

Referenced by GameSession::update().

{
  return currentmusic;
}

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

Definition at line 1443 of file sector.cpp.

References add_object(), PlayerStatus::bonus, bullets, FIRE_BONUS, ICE_BONUS, PlayerStatus::max_fire_bullets, PlayerStatus::max_ice_bullets, SoundManager::play(), player_status, and sound_manager.

Referenced by Player::handle_input().

{
  // TODO remove this function and move these checks elsewhere...

  Bullet* new_bullet = 0;
  if((player_status->bonus == FIRE_BONUS &&
      (int)bullets.size() >= player_status->max_fire_bullets) ||
     (player_status->bonus == ICE_BONUS &&
      (int)bullets.size() >= player_status->max_ice_bullets))
    return false;
  new_bullet = new Bullet(pos, xm, dir, player_status->bonus);
  add_object(new_bullet);

  sound_manager->play("sounds/shoot.wav");

  return true;
}

bool Sector::add_smoke_cloud

(

const Vector &

pos

)

Definition at line 1462 of file sector.cpp.

References add_object().

{
  add_object(new SmokeCloud(pos));
  return true;
}

static Sector* Sector::current

(

)

[inline, static]

get currently activated sector.

Reimplemented from Currenton< Sector >.

Definition at line 116 of file sector.hpp.

References _current.

Referenced by Totem::active_update(), Igel::active_update(), GhostTree::active_update(), FlyingSnowBall::active_update(), Player::adjust_height(), Block::break_me(), scripting::camera(), Player::check_bounds(), Coin::collect(), Door::collision(), PushButton::collision(), PowerUp::collision(), ParticleSystem_Interactive::collision(), OneUp::collision(), Firefly::collision(), WillOWisp::collision_player(), Player::collision_solid(), IceCrusher::collision_solid(), Stumpy::collision_squished(), Snowman::collision_squished(), PoisonIvy::collision_squished(), Owl::collision_squished(), MrTree::collision_squished(), MrBomb::collision_squished(), Player::draw(), InfoBlock::draw(), Background::draw(), Background::draw_image(), Yeti::drop_stalactite(), Electrifier::Electrifier(), Thunderstorm::electrify(), SecretAreaTrigger::event(), ScriptTrigger::event(), Explosion::explode(), SkyDive::explode(), ShortFuse::explode(), Bomb::explode(), DartTrap::fire(), scripting::FloatingImage::FloatingImage(), IceCrusher::found_victim(), Ispy::free_line_of_sight(), Physic::get_movement(), get_nearby_objects(), get_nearest_player(), InfoBlock::get_nearest_player(), BadGuy::get_nearest_player(), scripting::ghost(), scripting::gotoend(), scripting::grease(), Player::handle_horizontal_input(), Player::handle_input(), InfoBlock::hit(), Owl::initialize(), scripting::invincible(), Owl::is_above_player(), Player::kill(), MrBomb::kill_fall(), Haywire::kill_fall(), Dispenser::launch_badguy(), Player::make_invincible(), CaptainSnowball::might_climb(), BadGuy::might_fall(), scripting::mortal(), Candle::puff_smoke(), BadGuy::run_dead_script(), EndSequenceWalkRight::running(), EndSequenceWalkLeft::running(), Player::set_bonus(), TitleScreen::setup(), GameSession::setup(), GhostTree::spawn_lantern(), WeakBlock::spreadHit(), EndSequence::start(), EndSequenceFireworks::starting(), Mole::throw_rock(), Brick::try_break(), Player::try_grab(), BonusBlock::try_open(), Switch::update(), Wind::update(), SpriteParticle::update(), SpecialRiser::update(), SkullTile::update(), RainParticleSystem::update(), PneumaticPlatform::update(), Player::update(), Platform::update(), Particles::update(), OneUp::update(), MagicBlock::update(), LevelTime::update(), Ispy::update(), Fireworks::update(), Electrifier::update(), CometParticleSystem::update(), Bullet::update(), BicyclePlatform::update(), AmbientSound::update(), BadGuy::update(), scripting::validate_sector_player(), and scripting::whereami().

  { return _current; }

int Sector::get_total_badguys

(

)

Get total number of badguys.

Definition at line 1495 of file sector.cpp.

References gameobjects.

{
  int total_badguys = 0;
  for(GameObjects::iterator i = gameobjects.begin();
      i != gameobjects.end(); ++i) {
    BadGuy* badguy = dynamic_cast<BadGuy*> (*i);
    if (badguy && badguy->countMe)
      total_badguys++;
  }

  return total_badguys;
}

template<class T>

int Sector::get_total_count

(

)

[inline]

Get total number of GameObjects of given type.

Definition at line 123 of file sector.hpp.

References gameobjects.

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

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

Definition at line 961 of file sector.cpp.

References Rect::bottom, check_collisions(), MovingObject::get_bbox(), Rectf::get_bottom(), Rectf::get_left(), Rectf::get_right(), Rectf::get_top(), Tile::getData(), Tile::is_slope(), Tile::is_solid(), Tile::is_unisolid(), Rect::left, collision::rectangle_aatriangle(), Rect::right, solid_tilemaps, Rect::top, AATriangle::vertical_flip(), and VERTICAL_FLIP.

Referenced by collision_static().

{
  // calculate rectangle where the object will move
  float x1 = dest.get_left();
  float x2 = dest.get_right();
  float y1 = dest.get_top();
  float y2 = dest.get_bottom();

  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;

    // test with all tiles in this rectangle
    Rect test_tiles = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2));

    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
      for(int y = test_tiles.top; y < test_tiles.bottom; ++y) {
        const Tile* tile = solids->get_tile(x, y);
        if(!tile)
          continue;
        // skip non-solid tiles
        if(!tile->is_solid ())
          continue;
        Rectf tile_bbox = solids->get_tile_bbox(x, y);

        /* If the tile is a unisolid tile, the "is_solid()" function above
         * didn't do a thorough check. Calculate the position and (relative)
         * movement of the object and determine whether or not the tile is
         * solid with regard to those parameters. */
        if(tile->is_unisolid ()) {
          Vector relative_movement = movement
            - solids->get_movement(/* actual = */ true);

          if (!tile->is_solid (tile_bbox, object.get_bbox(), relative_movement))
            continue;
        } /* if (tile->is_unisolid ()) */

        if(tile->is_slope ()) { // slope tile
          AATriangle triangle;
          int slope_data = tile->getData();
          if (solids->get_drawing_effect() == VERTICAL_FLIP)
            slope_data = AATriangle::vertical_flip(slope_data);
          triangle = AATriangle(tile_bbox, slope_data);

          collision::rectangle_aatriangle(constraints, dest, triangle,
              solids->get_movement(/* actual = */ false));
        } else { // normal rectangular tile
          check_collisions(constraints, movement, dest, tile_bbox, NULL, NULL,
              solids->get_movement(/* actual = */ false));
        }
      }
    }
  }
}

bool Sector::is_free_of_tiles	(	const Rectf &	rect,
		const bool	ignoreUnisolid = false
	)			const

Checks if the specified rectangle is free of (solid) tiles.

Note that this does not include static objects, e.g. bonus blocks.

Definition at line 1365 of file sector.cpp.

References Rect::bottom, Tile::getAttributes(), Tile::getData(), Tile::is_slope(), Tile::is_unisolid(), Rect::left, collision::rectangle_aatriangle(), Rect::right, Tile::SOLID, solid_tilemaps, and Rect::top.

Referenced by activate(), is_free_of_movingstatics(), and is_free_of_statics().

{
  using namespace collision;

  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;

    // test with all tiles in this rectangle
    Rect test_tiles = solids->get_tiles_overlapping(rect);

    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
      for(int y = test_tiles.top; y < test_tiles.bottom; ++y) {
        const Tile* tile = solids->get_tile(x, y);
        if(!tile) continue;
        if(!(tile->getAttributes() & Tile::SOLID))
          continue;
        if(tile->is_unisolid () && ignoreUnisolid)
          continue;
        if(tile->is_slope ()) {
          AATriangle triangle;
          Rectf tbbox = solids->get_tile_bbox(x, y);
          triangle = AATriangle(tbbox, tile->getData());
          Constraints constraints;
          if(!collision::rectangle_aatriangle(&constraints, rect, triangle))
            continue;
        }
        // We have a solid tile that overlaps the given rectangle.
        return false;
      }
    }
  }

  return true;
}

bool Sector::is_free_of_statics	(	const Rectf &	rect,
		const MovingObject *	ignore_object = 0,
		const bool	ignoreUnisolid = false
	)			const

Checks if the specified rectangle is free of both 1.

) solid tiles and 2.) MovingObjects in COLGROUP_STATIC. Note that this does not include badguys or players.

Definition at line 1401 of file sector.cpp.

References COLGROUP_STATIC, collision::intersects(), is_free_of_tiles(), and moving_objects.

Referenced by TitleScreen::make_tux_jump(), and BadGuy::might_fall().

{
  using namespace collision;

  if (!is_free_of_tiles(rect, ignoreUnisolid)) return false;

  for(MovingObjects::const_iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    const MovingObject* moving_object = *i;
    if (moving_object == ignore_object) continue;
    if (!moving_object->is_valid()) continue;
    if (moving_object->get_group() == COLGROUP_STATIC) {
      if(intersects(rect, moving_object->get_bbox())) return false;
    }
  }

  return true;
}

bool Sector::is_free_of_movingstatics	(	const Rectf &	rect,
		const MovingObject *	ignore_object = 0
	)			const

Checks if the specified rectangle is free of both 1.

) solid tiles and 2.) MovingObjects in COLGROUP_STATIC, COLGROUP_MOVINGSTATIC or COLGROUP_MOVING. This includes badguys and players.

Definition at line 1421 of file sector.cpp.

References COLGROUP_MOVING, COLGROUP_MOVING_STATIC, COLGROUP_STATIC, collision::intersects(), is_free_of_tiles(), and moving_objects.

{
  using namespace collision;

  if (!is_free_of_tiles(rect)) return false;

  for(MovingObjects::const_iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    const MovingObject* moving_object = *i;
    if (moving_object == ignore_object) continue;
    if (!moving_object->is_valid()) continue;
    if ((moving_object->get_group() == COLGROUP_MOVING)
        || (moving_object->get_group() == COLGROUP_MOVING_STATIC)
        || (moving_object->get_group() == COLGROUP_STATIC)) {
      if(intersects(rect, moving_object->get_bbox())) return false;
    }
  }

  return true;
}

std::vector<Player*> Sector::get_players

(

)

[inline]

returns a list of players currently in the sector

Definition at line 159 of file sector.hpp.

References player.

Referenced by GameSession::force_ghost_mode(), get_nearby_objects(), get_nearest_player(), InfoBlock::get_nearest_player(), GameSession::set_editmode(), GameSession::start_sequence(), GameSession::update(), Platform::update(), and Ispy::update().

                                   {
    return std::vector<Player*>(1, this->player);
  }

Player * Sector::get_nearest_player

(

const Vector &

pos

)

Definition at line 1598 of file sector.cpp.

References current(), and get_players().

Referenced by Owl::collision_squished(), IceCrusher::found_victim(), get_nearest_player(), BadGuy::get_nearest_player(), and Owl::is_above_player().

{
  Player *nearest_player = NULL;
  float nearest_dist = std::numeric_limits<float>::max();

  std::vector<Player*> players = Sector::current()->get_players();
  for (std::vector<Player*>::iterator playerIter = players.begin();
      playerIter != players.end();
      ++playerIter)
  {
    Player *this_player = *playerIter;
    if (this_player->is_dying() || this_player->is_dead())
      continue;

    float this_dist = this_player->get_bbox ().distance(pos);

    if (this_dist < nearest_dist) {
      nearest_player = this_player;
      nearest_dist = this_dist;
    }
  }

  return nearest_player;
} /* Player *get_nearest_player */

Player* Sector::get_nearest_player

(

const Rectf &

pos

)

[inline]

Definition at line 163 of file sector.hpp.

References ANCHOR_MIDDLE, get_anchor_pos(), and get_nearest_player().

  {
    return (get_nearest_player (get_anchor_pos (pos, ANCHOR_MIDDLE)));
  }

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

Definition at line 1624 of file sector.cpp.

References current(), get_players(), and moving_objects.

Referenced by Explosion::explode().

{
  std::vector<MovingObject*> ret;
  std::vector<Player*> players = Sector::current()->get_players();

  for (size_t i = 0; i < players.size (); i++) {
    float distance = players[i]->get_bbox ().distance (center);
    if (distance <= max_distance)
      ret.push_back (players[i]);
  }

  for (size_t i = 0; i < moving_objects.size (); i++) {
    float distance = moving_objects[i]->get_bbox ().distance (center);
    if (distance <= max_distance)
      ret.push_back (moving_objects[i]);
  }

  return (ret);
}

Rectf Sector::get_active_region

(

)

Definition at line 645 of file sector.cpp.

References camera, Camera::get_translation(), SCREEN_HEIGHT, and SCREEN_WIDTH.

{
  return Rectf(
    camera->get_translation() - Vector(1600, 1200),
    camera->get_translation() + Vector(1600, 1200) + Vector(SCREEN_WIDTH,SCREEN_HEIGHT));
}

float Sector::get_width

(

)

const

returns the width (in px) of a sector)

Definition at line 1524 of file sector.cpp.

References solid_tilemaps.

Referenced by InfoBlock::draw(), Camera::keep_in_bounds(), TitleScreen::make_tux_jump(), and Camera::update_scroll_normal().

{
  float width = 0;
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
      i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    width = std::max(width, solids->get_bbox().get_right());
  }

  return width;
}

float Sector::get_height

(

)

const

returns the height (in px) of a sector)

Definition at line 1537 of file sector.cpp.

References solid_tilemaps.

Referenced by Camera::keep_in_bounds(), FlipLevelTransformer::transform_sector(), and Camera::update_scroll_normal().

{
  float height = 0;
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
      i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    height = std::max(height, solids->get_bbox().get_bottom());
  }

  return height;
}

void Sector::change_solid_tiles	(	uint32_t	old_tile_id,
		uint32_t	new_tile_id
	)

globally changes solid tilemaps' tile ids

Definition at line 1550 of file sector.cpp.

References solid_tilemaps.

Referenced by Electrifier::Electrifier(), and Electrifier::update().

{
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    solids->change_all(old_tile_id, new_tile_id);
  }
}

void Sector::set_ambient_light	(	float	red,
		float	green,
		float	blue
	)			[virtual]

get/set color of ambient light

Implements scripting::SSector.

Definition at line 1559 of file sector.cpp.

References ambient_light, Color::blue, Color::green, and Color::red.

{
  ambient_light.red = red;
  ambient_light.green = green;
  ambient_light.blue = blue;
}

float Sector::get_ambient_red

(

)

[virtual]

Implements scripting::SSector.

Definition at line 1567 of file sector.cpp.

References ambient_light, and Color::red.

{
  return ambient_light.red;
}

float Sector::get_ambient_green

(

)

[virtual]

Implements scripting::SSector.

Definition at line 1573 of file sector.cpp.

References ambient_light, and Color::green.

{
  return ambient_light.green;
}

float Sector::get_ambient_blue

(

)

[virtual]

Implements scripting::SSector.

Definition at line 1579 of file sector.cpp.

References ambient_light, and Color::blue.

{
  return ambient_light.blue;
}

void Sector::set_gravity

(

float

gravity

)

[virtual]

set gravity throughout sector

Implements scripting::SSector.

Definition at line 1585 of file sector.cpp.

References log_warning.

{
  log_warning << "Changing a Sector's gravitational constant might have unforeseen side-effects" << std::endl;
  this->gravity = gravity;
}

float Sector::get_gravity

(

)

const

Definition at line 1592 of file sector.cpp.

References gravity.

Referenced by FlyingSnowBall::active_update(), and Physic::get_movement().

{
  return gravity;
}

uint32_t Sector::collision_tile_attributes

(

const Rectf &

dest

)

const [private]

Definition at line 1018 of file sector.cpp.

References Rect::bottom, Tile::getAttributes(), Tile::ICE, Rect::left, Rectf::p1, Rectf::p2, Rect::right, SHIFT_DELTA, solid_tilemaps, Rect::top, Vector::x, and Vector::y.

Referenced by handle_collisions().

{
  float x1 = dest.p1.x;
  float y1 = dest.p1.y;
  float x2 = dest.p2.x;
  float y2 = dest.p2.y;

  uint32_t result = 0;
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;

    // test with all tiles in this rectangle
    Rect test_tiles = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2));
    // For ice (only), add a little fudge to recognize tiles Tux is standing on.
    Rect test_tiles_ice = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2 + SHIFT_DELTA));

    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
      int y;
      for(y = test_tiles.top; y < test_tiles.bottom; ++y) {
        const Tile* tile = solids->get_tile(x, y);
        if(!tile)
          continue;
        result |= tile->getAttributes();
      }
      for(; y < test_tiles_ice.bottom; ++y) {
        const Tile* tile = solids->get_tile(x, y);
        if(!tile)
          continue;
        result |= (tile->getAttributes() & Tile::ICE);
      }
    }
  }

  return result;
}

void Sector::before_object_remove

(

GameObject *

object

)

[private]

Definition at line 796 of file sector.cpp.

References _current, bullets, moving_objects, portables, and try_unexpose().

Referenced by update_game_objects(), and ~Sector().

{
  Portable* portable = dynamic_cast<Portable*> (object);
  if(portable != NULL) {
    portables.erase(std::find(portables.begin(), portables.end(), portable));
  }
  Bullet* bullet = dynamic_cast<Bullet*> (object);
  if(bullet != NULL) {
    bullets.erase(std::find(bullets.begin(), bullets.end(), bullet));
  }
  MovingObject* moving_object = dynamic_cast<MovingObject*> (object);
  if(moving_object != NULL) {
    moving_objects.erase(
      std::find(moving_objects.begin(), moving_objects.end(), moving_object));
  }

  if(_current == this)
    try_unexpose(object);
}

bool Sector::before_object_add

(

GameObject *

object

)

[private]

Definition at line 717 of file sector.cpp.

References _current, bullets, camera, effect, TileMap::is_solid(), log_warning, moving_objects, player, portables, solid_tilemaps, and try_expose().

Referenced by update_game_objects().

{
  Bullet* bullet = dynamic_cast<Bullet*> (object);
  if(bullet != NULL) {
    bullets.push_back(bullet);
  }

  MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
  if(movingobject != NULL) {
    moving_objects.push_back(movingobject);
  }

  Portable* portable = dynamic_cast<Portable*> (object);
  if(portable != NULL) {
    portables.push_back(portable);
  }

  TileMap* tilemap = dynamic_cast<TileMap*> (object);
  if(tilemap != NULL && tilemap->is_solid()) {
    solid_tilemaps.push_back(tilemap);
  }

  Camera* camera = dynamic_cast<Camera*> (object);
  if(camera != NULL) {
    if(this->camera != 0) {
      log_warning << "Multiple cameras added. Ignoring" << std::endl;
      return false;
    }
    this->camera = camera;
  }

  Player* player = dynamic_cast<Player*> (object);
  if(player != NULL) {
    if(this->player != 0) {
      log_warning << "Multiple players added. Ignoring" << std::endl;
      return false;
    }
    this->player = player;
  }

  DisplayEffect* effect = dynamic_cast<DisplayEffect*> (object);
  if(effect != NULL) {
    if(this->effect != 0) {
      log_warning << "Multiple DisplayEffects added. Ignoring" << std::endl;
      return false;
    }
    this->effect = effect;
  }

  if(_current == this) {
    try_expose(object);
  }

  return true;
}

void Sector::try_expose

(

GameObject *

object

)

[private]

Definition at line 774 of file sector.cpp.

References ScriptInterface::expose(), scripting::global_vm, and sector_table.

Referenced by activate(), and before_object_add().

{
  ScriptInterface* object_ = dynamic_cast<ScriptInterface*> (object);
  if(object_ != NULL) {
    HSQUIRRELVM vm = scripting::global_vm;
    sq_pushobject(vm, sector_table);
    object_->expose(vm, -1);
    sq_pop(vm, 1);
  }
}

void Sector::try_unexpose

(

GameObject *

object

)

[private]

Definition at line 817 of file sector.cpp.

References scripting::global_vm, log_warning, sector_table, and ScriptInterface::unexpose().

Referenced by before_object_remove(), and deactivate().

{
  ScriptInterface* object_ = dynamic_cast<ScriptInterface*> (object);
  if(object_ != NULL) {
    HSQUIRRELVM vm = scripting::global_vm;
    SQInteger oldtop = sq_gettop(vm);
    sq_pushobject(vm, sector_table);
    try {
      object_->unexpose(vm, -1);
    } catch(std::exception& e) {
      log_warning << "Couldn't unregister object: " << e.what() << std::endl;
    }
    sq_settop(vm, oldtop);
  }
}

void Sector::try_expose_me

(

)

[private]

Definition at line 786 of file sector.cpp.

References scripting::expose_object(), scripting::global_vm, and sector_table.

Referenced by activate().

{
  HSQUIRRELVM vm = scripting::global_vm;
  sq_pushobject(vm, sector_table);
  scripting::SSector* this_ = static_cast<scripting::SSector*> (this);
  expose_object(vm, -1, this_, "settings", false);
  sq_pop(vm, 1);
}

void Sector::try_unexpose_me

(

)

[private]

Definition at line 834 of file sector.cpp.

References scripting::global_vm, log_warning, sector_table, and scripting::unexpose_object().

Referenced by deactivate().

{
  HSQUIRRELVM vm = scripting::global_vm;
  SQInteger oldtop = sq_gettop(vm);
  sq_pushobject(vm, sector_table);
  try {
    scripting::unexpose_object(vm, -1, "settings");
  } catch(std::exception& e) {
    log_warning << "Couldn't unregister object: " << e.what() << std::endl;
  }
  sq_settop(vm, oldtop);
}

void Sector::handle_collisions

(

)

[private]

Checks for all possible collisions.

And calls the collision_handlers, which the collision_objects provide for this case (or not).

Definition at line 1251 of file sector.cpp.

References COLGROUP_MOVING, COLGROUP_MOVING_ONLY_STATIC, COLGROUP_MOVING_STATIC, COLGROUP_TOUCHABLE, collision_object(), collision_static_constrains(), collision_tile_attributes(), Tile::FIRST_INTERESTING_FLAG, get_hit_normal(), collision::intersects(), MAX_SPEED, moving_objects, Vector::norm(), Vector::unit(), Vector::x, and Vector::y.

Referenced by update().

{
  using namespace collision;

  // calculate destination positions of the objects
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;
    Vector mov = moving_object->get_movement();

    // make sure movement is never faster than MAX_SPEED. Norm is pretty fat, so two addl. checks are done before.
    if (((mov.x > MAX_SPEED * M_SQRT1_2) || (mov.y > MAX_SPEED * M_SQRT1_2)) && (mov.norm() > MAX_SPEED)) {
      moving_object->movement = mov.unit() * MAX_SPEED;
      //log_debug << "Temporarily reduced object's speed of " << mov.norm() << " to " << moving_object->movement.norm() << "." << std::endl;
    }

    moving_object->dest = moving_object->get_bbox();
    moving_object->dest.move(moving_object->get_movement());
  }

  // part1: COLGROUP_MOVING vs COLGROUP_STATIC and tilemap
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;
    if((moving_object->get_group() != COLGROUP_MOVING
        && moving_object->get_group() != COLGROUP_MOVING_STATIC
        && moving_object->get_group() != COLGROUP_MOVING_ONLY_STATIC)
       || !moving_object->is_valid())
      continue;

    collision_static_constrains(*moving_object);
  }

  // part2: COLGROUP_MOVING vs tile attributes
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;
    if((moving_object->get_group() != COLGROUP_MOVING
        && moving_object->get_group() != COLGROUP_MOVING_STATIC
        && moving_object->get_group() != COLGROUP_MOVING_ONLY_STATIC)
       || !moving_object->is_valid())
      continue;

    uint32_t tile_attributes = collision_tile_attributes(moving_object->dest);
    if(tile_attributes >= Tile::FIRST_INTERESTING_FLAG) {
      moving_object->collision_tile(tile_attributes);
    }
  }

  // part2.5: COLGROUP_MOVING vs COLGROUP_TOUCHABLE
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;
    if((moving_object->get_group() != COLGROUP_MOVING
        && moving_object->get_group() != COLGROUP_MOVING_STATIC)
       || !moving_object->is_valid())
      continue;

    for(MovingObjects::iterator i2 = moving_objects.begin();
        i2 != moving_objects.end(); ++i2) {
      MovingObject* moving_object_2 = *i2;
      if(moving_object_2->get_group() != COLGROUP_TOUCHABLE
         || !moving_object_2->is_valid())
        continue;

      if(intersects(moving_object->dest, moving_object_2->dest)) {
        Vector normal;
        CollisionHit hit;
        get_hit_normal(moving_object->dest, moving_object_2->dest,
                       hit, normal);
        if(!moving_object->collides(*moving_object_2, hit))
          continue;
        if(!moving_object_2->collides(*moving_object, hit))
          continue;

        moving_object->collision(*moving_object_2, hit);
        moving_object_2->collision(*moving_object, hit);
      }
    }
  }

  // part3: COLGROUP_MOVING vs COLGROUP_MOVING
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;

    if((moving_object->get_group() != COLGROUP_MOVING
        && moving_object->get_group() != COLGROUP_MOVING_STATIC)
       || !moving_object->is_valid())
      continue;

    for(MovingObjects::iterator i2 = i+1;
        i2 != moving_objects.end(); ++i2) {
      MovingObject* moving_object_2 = *i2;
      if((moving_object_2->get_group() != COLGROUP_MOVING
          && moving_object_2->get_group() != COLGROUP_MOVING_STATIC)
         || !moving_object_2->is_valid())
        continue;

      collision_object(moving_object, moving_object_2);
    }
  }

  // apply object movement
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;

    moving_object->bbox = moving_object->dest;
    moving_object->movement = Vector(0, 0);
  }
}

void Sector::collision_object	(	MovingObject *	object1,
		MovingObject *	object2
	)			const [private]

Does collision detection between 2 objects and does instant collision response handling in case of a collision.

Definition at line 1085 of file sector.cpp.

References CollisionHit::bottom, MovingObject::collides(), MovingObject::collision(), CONTINUE, DELTA, MovingObject::dest, FORCE_MOVE, get_hit_normal(), collision::intersects(), CollisionHit::left, Rectf::move(), CollisionHit::right, and CollisionHit::top.

Referenced by handle_collisions().

{
  using namespace collision;

  const Rectf& r1 = object1->dest;
  const Rectf& r2 = object2->dest;

  CollisionHit hit;
  if(intersects(object1->dest, object2->dest)) {
    Vector normal;
    get_hit_normal(r1, r2, hit, normal);

    if(!object1->collides(*object2, hit))
      return;
    std::swap(hit.left, hit.right);
    std::swap(hit.top, hit.bottom);
    if(!object2->collides(*object1, hit))
      return;
    std::swap(hit.left, hit.right);
    std::swap(hit.top, hit.bottom);

    HitResponse response1 = object1->collision(*object2, hit);
    std::swap(hit.left, hit.right);
    std::swap(hit.top, hit.bottom);
    HitResponse response2 = object2->collision(*object1, hit);
    if(response1 == CONTINUE && response2 == CONTINUE) {
      normal *= (0.5 + DELTA);
      object1->dest.move(-normal);
      object2->dest.move(normal);
    } else if (response1 == CONTINUE && response2 == FORCE_MOVE) {
      normal *= (1 + DELTA);
      object1->dest.move(-normal);
    } else if (response1 == FORCE_MOVE && response2 == CONTINUE) {
      normal *= (1 + DELTA);
      object2->dest.move(normal);
    }
  }
}

void Sector::collision_static	(	collision::Constraints *	constraints,
		const Vector &	movement,
		const Rectf &	dest,
		MovingObject &	object
	)			[private]

Does collision detection of an object against all other static objects (and the tilemap) in the level.

Collision response is done for the first hit in time. (other hits get ignored, the function should be called repeatedly to resolve those)

returns true if the collision detection should be aborted for this object (because of ABORT_MOVE in the collision response or no collisions)

Definition at line 1125 of file sector.cpp.

References check_collisions(), COLGROUP_MOVING_STATIC, COLGROUP_STATIC, collision_tilemap(), and moving_objects.

Referenced by collision_static_constrains().

{
  collision_tilemap(constraints, movement, dest, object);

  // collision with other (static) objects
  for(MovingObjects::iterator i = moving_objects.begin();
      i != moving_objects.end(); ++i) {
    MovingObject* moving_object = *i;
    if(moving_object->get_group() != COLGROUP_STATIC
       && moving_object->get_group() != COLGROUP_MOVING_STATIC)
      continue;
    if(!moving_object->is_valid())
      continue;

    if(moving_object != &object)
      check_collisions(constraints, movement, dest, moving_object->bbox,
                       &object, moving_object);
  }
}

void Sector::collision_static_constrains

(

MovingObject &

object

)

[private]

Definition at line 1148 of file sector.cpp.

References CollisionHit::bottom, MovingObject::collision_solid(), collision_static(), CollisionHit::crush, DELTA, MovingObject::dest, MovingObject::get_bbox(), Rectf::get_height(), MovingObject::get_movement(), Rectf::get_width(), CollisionHit::left, Rectf::move(), Rectf::p1, Rectf::p2, CollisionHit::right, SHIFT_DELTA, CollisionHit::top, Vector::x, and Vector::y.

Referenced by handle_collisions().

{
  using namespace collision;
  float infinity = (std::numeric_limits<float>::has_infinity ? std::numeric_limits<float>::infinity() : std::numeric_limits<float>::max());

  Constraints constraints;
  Vector movement = object.get_movement();
  Rectf& dest = object.dest;

  for(int i = 0; i < 2; ++i) {
    collision_static(&constraints, Vector(0, movement.y), dest, object);
    if(!constraints.has_constraints())
      break;

    // apply calculated horizontal constraints
    if(constraints.get_position_bottom() < infinity) {
      float height = constraints.get_height ();
      if(height < object.get_bbox().get_height()) {
        // we're crushed, but ignore this for now, we'll get this again
        // later if we're really crushed or things will solve itself when
        // looking at the vertical constraints
      }
      dest.p2.y = constraints.get_position_bottom() - DELTA;
      dest.p1.y = dest.p2.y - object.get_bbox().get_height();
    } else if(constraints.get_position_top() > -infinity) {
      dest.p1.y = constraints.get_position_top() + DELTA;
      dest.p2.y = dest.p1.y + object.get_bbox().get_height();
    }
  }
  if(constraints.has_constraints()) {
    if(constraints.hit.bottom) {
      dest.move(constraints.ground_movement);
    }
    if(constraints.hit.top || constraints.hit.bottom) {
      constraints.hit.left = false;
      constraints.hit.right = false;
      object.collision_solid(constraints.hit);
    }
  }

  constraints = Constraints();
  for(int i = 0; i < 2; ++i) {
    collision_static(&constraints, movement, dest, object);
    if(!constraints.has_constraints())
      break;

    // apply calculated vertical constraints
    float width = constraints.get_width ();
    if(width < infinity) {
      if(width + SHIFT_DELTA < object.get_bbox().get_width()) {
#if 0
        printf("Object %p crushed horizontally... L:%f R:%f\n", &object,
               constraints.get_position_left(), constraints.get_position_right());
#endif
        CollisionHit h;
        h.left = true;
        h.right = true;
        h.crush = true;
        object.collision_solid(h);
      } else {
        float xmid = constraints.get_x_midpoint ();
        dest.p1.x = xmid - object.get_bbox().get_width()/2;
        dest.p2.x = xmid + object.get_bbox().get_width()/2;
      }
    } else if(constraints.get_position_right() < infinity) {
      dest.p2.x = constraints.get_position_right() - DELTA;
      dest.p1.x = dest.p2.x - object.get_bbox().get_width();
    } else if(constraints.get_position_left() > -infinity) {
      dest.p1.x = constraints.get_position_left() + DELTA;
      dest.p2.x = dest.p1.x + object.get_bbox().get_width();
    }
  }

  if(constraints.has_constraints()) {
    if( constraints.hit.left || constraints.hit.right
        || constraints.hit.top || constraints.hit.bottom
        || constraints.hit.crush )
      object.collision_solid(constraints.hit);
  }

  // an extra pass to make sure we're not crushed horizontally
  constraints = Constraints();
  collision_static(&constraints, movement, dest, object);
  if(constraints.get_position_bottom() < infinity) {
    float height = constraints.get_height ();
    if(height + SHIFT_DELTA < object.get_bbox().get_height()) {
#if 0
      printf("Object %p crushed vertically...\n", &object);
#endif
      CollisionHit h;
      h.top = true;
      h.bottom = true;
      h.crush = true;
      object.collision_solid(h);
    }
  }
}

GameObject * Sector::parse_object	(	const std::string &	name,
		const Reader &	lisp
	)			[private]

Definition at line 147 of file sector.cpp.

References camera, ObjectFactory::create(), ObjectFactory::instance(), log_warning, CloudParticleSystem::parse(), GhostParticleSystem::parse(), CometParticleSystem::parse(), RainParticleSystem::parse(), SnowParticleSystem::parse(), and Camera::parse().

Referenced by parse(), and parse_old_format().

{
  if(name == "camera") {
    Camera* camera = new Camera(this, "Camera");
    camera->parse(reader);
    return camera;
  } else if(name == "particles-snow") {
    SnowParticleSystem* partsys = new SnowParticleSystem();
    partsys->parse(reader);
    return partsys;
  } else if(name == "particles-rain") {
    RainParticleSystem* partsys = new RainParticleSystem();
    partsys->parse(reader);
    return partsys;
  } else if(name == "particles-comets") {
    CometParticleSystem* partsys = new CometParticleSystem();
    partsys->parse(reader);
    return partsys;
  } else if(name == "particles-ghosts") {
    GhostParticleSystem* partsys = new GhostParticleSystem();
    partsys->parse(reader);
    return partsys;
  } else if(name == "particles-clouds") {
    CloudParticleSystem* partsys = new CloudParticleSystem();
    partsys->parse(reader);
    return partsys;
  } else if(name == "money") { // for compatibility with old maps
    return new Jumpy(reader);
  } else {
    try {
      return ObjectFactory::instance().create(name, reader);
    } catch(std::exception& e) {
      log_warning << e.what() << "" << std::endl;
      return 0;
    }
  }
}

void Sector::fix_old_tiles

(

)

[private]

Definition at line 404 of file sector.cpp.

References add_object(), Tile::BRICK, Tile::COIN, Tile::FULLBOX, gameobjects, Tile::getAttributes(), Tile::getData(), Tile::GOAL, solid_tilemaps, and Vector::x.

Referenced by parse(), and parse_old_format().

{
  for(std::list<TileMap*>::iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    for(size_t x=0; x < solids->get_width(); ++x) {
      for(size_t y=0; y < solids->get_height(); ++y) {
        uint32_t    id   = solids->get_tile_id(x, y);
        const Tile *tile = solids->get_tile(x, y);
        Vector pos = solids->get_tile_position(x, y);

        if(id == 112) {
          add_object(new InvisibleBlock(pos));
          solids->change(x, y, 0);
        } else if(tile->getAttributes() & Tile::COIN) {
          add_object(new Coin(pos, solids));
          solids->change(x, y, 0);
        } else if(tile->getAttributes() & Tile::FULLBOX) {
          add_object(new BonusBlock(pos, tile->getData()));
          solids->change(x, y, 0);
        } else if(tile->getAttributes() & Tile::BRICK) {
          add_object(new Brick(pos, tile->getData()));
          solids->change(x, y, 0);
        } else if(tile->getAttributes() & Tile::GOAL) {
          std::string sequence = tile->getData() == 0 ? "endsequence" : "stoptux";
          add_object(new SequenceTrigger(pos, sequence));
          solids->change(x, y, 0);
        }
      }
    }
  }

  // add lights for special tiles
  for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end(); i++) {
    TileMap* tm = dynamic_cast<TileMap*>(*i);
    if (!tm) continue;
    for(size_t x=0; x < tm->get_width(); ++x) {
      for(size_t y=0; y < tm->get_height(); ++y) {
        uint32_t id = tm->get_tile_id(x, y);
        Vector pos = tm->get_tile_position(x, y);
        Vector center = pos + Vector(16, 16);

        // torch
        if (id == 1517) {
          float pseudo_rnd = (float)((int)pos.x % 10) / 10;
          add_object(new PulsingLight(center, 1.0f + pseudo_rnd, 0.9f, 1.0f, Color(1.0f, 1.0f, 0.6f, 1.0f)));
        }
        // lava or lavaflow
        if ((id == 173) || (id == 1700) || (id == 1705) || (id == 1706)) {
          // space lights a bit
          if ((((tm->get_tile_id(x-1, y)) != tm->get_tile_id(x,y))
               && (tm->get_tile_id(x, y-1) != tm->get_tile_id(x,y)))
              || ((x % 3 == 0) && (y % 3 == 0))) {
            float pseudo_rnd = (float)((int)pos.x % 10) / 10;
            add_object(new PulsingLight(center, 1.0f + pseudo_rnd, 0.8f, 1.0f, Color(1.0f, 0.3f, 0.0f, 1.0f)));
          }
        }

      }
    }
  }

}

Sector& Sector::operator=

(

const Sector &

)

[private]

---

Member Data Documentation

Sector * Sector::_current [static, private]

Definition at line 248 of file sector.hpp.

Referenced by activate(), before_object_add(), before_object_remove(), current(), and deactivate().

Level* Sector::level [private]

Parent level containing this sector.

Definition at line 250 of file sector.hpp.

Referenced by get_level(), and parse_old_format().

std::string Sector::name [private]

Definition at line 252 of file sector.hpp.

Referenced by get_name(), parse(), parse_old_format(), and run_script().

std::vector<Bullet*> Sector::bullets [private]

Definition at line 254 of file sector.hpp.

Referenced by add_bullet(), before_object_add(), and before_object_remove().

std::string Sector::init_script [private]

Definition at line 256 of file sector.hpp.

Referenced by activate(), and parse().

GameObjects Sector::gameobjects_new [private]

container for newly created objects, they'll be added in Sector::update

Definition at line 259 of file sector.hpp.

Referenced by add_object(), update_game_objects(), and ~Sector().

MusicType Sector::currentmusic [private]

Definition at line 261 of file sector.hpp.

Referenced by get_music_type(), and play_music().

HSQOBJECT Sector::sector_table [private]

Definition at line 263 of file sector.hpp.

Referenced by activate(), run_script(), Sector(), try_expose(), try_expose_me(), try_unexpose(), try_unexpose_me(), and ~Sector().

ScriptList Sector::scripts [private]

Definition at line 266 of file sector.hpp.

Referenced by run_script(), and ~Sector().

Color Sector::ambient_light [private]

Definition at line 268 of file sector.hpp.

Referenced by draw(), get_ambient_blue(), get_ambient_green(), get_ambient_red(), parse(), and set_ambient_light().

bool Sector::show_collrects [static]

show collision rectangles of moving objects (for debugging)

Definition at line 272 of file sector.hpp.

Referenced by scripting::debug_collrects(), and draw().

bool Sector::draw_solids_only [static]

Definition at line 273 of file sector.hpp.

Referenced by scripting::debug_draw_solids_only(), and draw().

GameObjects Sector::gameobjects

Definition at line 275 of file sector.hpp.

Referenced by activate(), Igel::active_update(), add_object(), deactivate(), draw(), Yeti::drop_stalactite(), SecretAreaTrigger::event(), fix_old_tiles(), get_total_badguys(), get_total_count(), InfoBlock::hit(), WeakBlock::spreadHit(), GameSession::start_sequence(), FlipLevelTransformer::transform_sector(), update(), update_game_objects(), and ~Sector().

MovingObjects Sector::moving_objects

Definition at line 276 of file sector.hpp.

Referenced by Totem::active_update(), before_object_add(), before_object_remove(), collision_static(), draw(), Ispy::free_line_of_sight(), get_nearby_objects(), handle_collisions(), is_free_of_movingstatics(), and is_free_of_statics().

SpawnPoints Sector::spawnpoints

Definition at line 277 of file sector.hpp.

Referenced by activate(), parse(), parse_old_format(), FlipLevelTransformer::transform_sector(), and ~Sector().

Portables Sector::portables

Definition at line 278 of file sector.hpp.

Referenced by before_object_add(), and before_object_remove().

std::string Sector::music

Definition at line 280 of file sector.hpp.

Referenced by parse(), parse_old_format(), and play_music().

float Sector::gravity

Definition at line 281 of file sector.hpp.

Referenced by get_gravity(), parse(), and parse_old_format().

Player* Sector::player

Definition at line 285 of file sector.hpp.

Referenced by activate(), before_object_add(), GameSession::check_end_conditions(), Coin::collect(), get_players(), scripting::ghost(), scripting::gotoend(), scripting::grease(), scripting::invincible(), TitleScreen::make_tux_jump(), scripting::mortal(), GameSession::on_escape_press(), GameSession::play_demo(), EndSequenceWalkRight::running(), EndSequenceWalkLeft::running(), TitleScreen::setup(), GameSession::setup(), EndSequence::start(), GameSession::start_sequence(), FlipLevelTransformer::transform_sector(), Brick::try_break(), BonusBlock::try_open(), update(), GameSession::update(), LevelTime::update(), Camera::update_scroll_autoscroll(), Camera::update_scroll_normal(), and scripting::whereami().

std::list<TileMap*> Sector::solid_tilemaps

Definition at line 286 of file sector.hpp.

Referenced by before_object_add(), change_solid_tiles(), ParticleSystem_Interactive::collision(), collision_tile_attributes(), collision_tilemap(), fix_old_tiles(), Ispy::free_line_of_sight(), get_height(), get_width(), inside(), is_free_of_tiles(), parse(), parse_old_format(), and update_game_objects().

Camera* Sector::camera

Definition at line 287 of file sector.hpp.

Referenced by activate(), before_object_add(), scripting::camera(), Player::collision_solid(), IceCrusher::collision_solid(), draw(), Player::draw(), Yeti::drop_stalactite(), get_active_region(), scripting::gotoend(), TitleScreen::make_tux_jump(), parse(), parse_object(), parse_old_format(), FlipLevelTransformer::transform_sector(), GameSession::update(), SpriteParticle::update(), RainParticleSystem::update(), Particles::update(), MagicBlock::update(), Fireworks::update(), CometParticleSystem::update(), Bullet::update(), and AmbientSound::update().

DisplayEffect* Sector::effect

Definition at line 288 of file sector.hpp.

Referenced by before_object_add(), and Player::kill().

---

The documentation for this class was generated from the following files:

• src/supertux/sector.hpp
• src/supertux/sector.cpp

---