worldmap::WorldMap Class Reference

Screen that runs a WorldMap, which lets the player choose a Level. More...

#include <worldmap.hpp>

Inherits Screen.

List of all members.

Public Member Functions
	WorldMap (const std::string &filename, PlayerStatus *player_status, const std::string &force_spawnpoint="")
	~WorldMap ()
void	add_object (GameObject *object)
void	try_expose (GameObject *object)
void	try_unexpose (GameObject *object)
virtual void	setup ()
	gets called before this screen gets activated (which is at least once before the first draw or update call
virtual void	leave ()
	gets called when the current screen is temporarily suspended
virtual void	update (float delta)
	Update worldmap state.
virtual void	draw (DrawingContext &context)
	Draw worldmap.
Vector	get_next_tile (Vector pos, Direction direction)
int	available_directions_at (Vector pos)
	gets a bitfield of Tile::WORLDMAP_NORTH | Tile::WORLDMAP_WEST | .
int	tile_data_at (Vector pos)
	returns a bitfield representing the union of all Tile::WORLDMAP_XXX values of all solid tiles at the given position
size_t	level_count ()
size_t	solved_level_count ()
void	finished_level (Level *level)
	gets called from the GameSession when a level has been successfully finished
Tux *	get_tux ()
	returns current Tux incarnation
PlayerStatus *	get_player_status ()
	returns player status
LevelTile *	at_level ()
SpecialTile *	at_special_tile ()
SpriteChange *	at_sprite_change (const Vector &pos)
Teleporter *	at_teleporter (const Vector &pos)
bool	path_ok (Direction direction, const Vector &pos, Vector *new_pos)
	Check if it is possible to walk from pos into direction, if possible, write the new position to new_pos.
void	save_state ()
	Save worldmap state to squirrel state table.
void	load_state ()
	Load worldmap state from squirrel state table.
const std::string &	get_title () const
HSQUIRRELVM	run_script (std::istream &in, const std::string &sourcename)
	runs a script in the context of the worldmap (and keeps a reference to the script (so the script gets destroyed when the worldmap is destroyed)
void	change (const std::string &filename, const std::string &force_spawnpoint="")
	switch to another worldmap.
void	move_to_spawnpoint (const std::string &spawnpoint, bool pan=false)
	moves Tux to the given spawnpoint
float	get_width () const
	returns the width (in tiles) of a worldmap
float	get_height () const
	returns the height (in tiles) of a worldmap
Static Public Member Functions
static WorldMap *	current ()
Public Attributes
Timer	passive_message_timer
	Variables to deal with the passive map messages.
std::string	passive_message
Private Types
typedef std::vector< SpecialTile * >	SpecialTiles
typedef std::vector< SpriteChange * >	SpriteChanges
typedef std::vector< SpawnPoint * >	SpawnPoints
typedef std::vector< LevelTile * >	LevelTiles
typedef std::vector< GameObject * >	GameObjects
typedef std::vector< HSQOBJECT >	ScriptList
Private Member Functions
void	get_level_title (LevelTile &level)
void	draw_status (DrawingContext &context)
void	calculate_total_stats ()
void	load (const std::string &filename)
void	on_escape_press ()
Vector	get_camera_pos_for_tux ()
void	clamp_camera_position (Vector &c)
	WorldMap (const WorldMap &)
WorldMap &	operator= (const WorldMap &)
Private Attributes
Tux *	tux
PlayerStatus *	player_status
TileSet *	tileset
bool	free_tileset
std::auto_ptr< Menu >	worldmap_menu
Vector	camera_offset
std::string	name
std::string	music
std::string	init_script
GameObjects	game_objects
std::list< TileMap * >	solid_tilemaps
std::string	map_filename
std::string	levels_path
SpecialTiles	special_tiles
LevelTiles	levels
SpriteChanges	sprite_changes
SpawnPoints	spawn_points
std::vector< Teleporter * >	teleporters
Statistics	total_stats
HSQOBJECT	worldmap_table
ScriptList	scripts
Color	ambient_light
std::string	force_spawnpoint
	if set, spawnpoint will be forced to this value
bool	in_level
Vector	pan_pos
bool	panning
Static Private Attributes
static Color	level_title_color
static Color	message_color
static Color	teleporter_message_color
static WorldMap *	current_

---

Detailed Description

Screen that runs a WorldMap, which lets the player choose a Level.

Definition at line 65 of file worldmap.hpp.

---

Member Typedef Documentation

typedef std::vector<SpecialTile*> worldmap::WorldMap::SpecialTiles [private]

Definition at line 72 of file worldmap.hpp.

typedef std::vector<SpriteChange*> worldmap::WorldMap::SpriteChanges [private]

Definition at line 73 of file worldmap.hpp.

typedef std::vector<SpawnPoint*> worldmap::WorldMap::SpawnPoints [private]

Definition at line 74 of file worldmap.hpp.

typedef std::vector<LevelTile*> worldmap::WorldMap::LevelTiles [private]

Definition at line 75 of file worldmap.hpp.

typedef std::vector<GameObject*> worldmap::WorldMap::GameObjects [private]

Definition at line 76 of file worldmap.hpp.

typedef std::vector<HSQOBJECT> worldmap::WorldMap::ScriptList [private]

Definition at line 77 of file worldmap.hpp.

---

Constructor & Destructor Documentation

worldmap::WorldMap::WorldMap	(	const std::string &	filename,
		PlayerStatus *	player_status,
		const std::string &	force_spawnpoint = ""
	)

Definition at line 80 of file worldmap.cpp.

References add_object(), scripting::global_vm, load(), music, name, SoundManager::preload(), Statistics::reset(), sound_manager, total_stats, tux, worldmap_menu, and worldmap_table.

Referenced by change().

                                                                                                            :
  tux(0),
  player_status(player_status),
  tileset(NULL), 
  free_tileset(false),
  worldmap_menu(),
  camera_offset(),
  name(),
  music(),
  init_script(),
  game_objects(),
  solid_tilemaps(),
  passive_message_timer(),
  passive_message(),
  map_filename(),
  levels_path(),
  special_tiles(),
  levels(),
  sprite_changes(),
  spawn_points(),
  teleporters(),
  total_stats(),
  worldmap_table(),
  scripts(),
  ambient_light( 1.0f, 1.0f, 1.0f, 1.0f ), 
  force_spawnpoint(force_spawnpoint),
  in_level(false), 
  pan_pos(),
  panning(false)
{
  tux = new Tux(this);
  add_object(tux);

  name = "<no title>";
  music = "music/salcon.ogg";

  total_stats.reset();

  worldmap_menu.reset(new WorldmapMenu());

  // create a new squirrel table for the worldmap
  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 worldmap_table delegate");

  sq_resetobject(&worldmap_table);
  if(SQ_FAILED(sq_getstackobj(global_vm, -1, &worldmap_table)))
    throw scripting::SquirrelError(global_vm, "Couldn't get table from stack");

  sq_addref(global_vm, &worldmap_table);
  sq_pop(global_vm, 1);

  sound_manager->preload("sounds/warp.wav");
  
  // load worldmap objects
  load(filename);
}

worldmap::WorldMap::~WorldMap

(

)

Definition at line 142 of file worldmap.cpp.

References current_, free_tileset, game_objects, scripting::global_vm, scripts, spawn_points, tileset, try_unexpose(), and worldmap_table.

{
  using namespace scripting;

  if(free_tileset)
    delete tileset;

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

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

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

  sq_collectgarbage(global_vm);

  if(current_ == this)
    current_ = NULL;
}

worldmap::WorldMap::WorldMap

(

const WorldMap &

)

[private]

---

Member Function Documentation

void worldmap::WorldMap::add_object

(

GameObject *

object

)

Definition at line 175 of file worldmap.cpp.

References game_objects, TileMap::is_solid(), RefCounter::ref(), solid_tilemaps, and try_expose().

Referenced by load(), and WorldMap().

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

  object->ref();
  try_expose(object);
  game_objects.push_back(object);
}

void worldmap::WorldMap::try_expose

(

GameObject *

object

)

Definition at line 188 of file worldmap.cpp.

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

Referenced by add_object().

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

void worldmap::WorldMap::try_unexpose

(

GameObject *

object

)

Definition at line 200 of file worldmap.cpp.

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

Referenced by update(), and ~WorldMap().

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

static WorldMap* worldmap::WorldMap::current

(

)

[inline, static]

Definition at line 137 of file worldmap.hpp.

References current_.

  { return current_; }

void worldmap::WorldMap::setup

(

)

[virtual]

gets called before this screen gets activated (which is at least once before the first draw or update call

Reimplemented from Screen.

Definition at line 877 of file worldmap.cpp.

References current_, force_spawnpoint, scripting::global_vm, init_script, levels_path, load_state(), move_to_spawnpoint(), music, SoundManager::play_music(), run_script(), MenuManager::set_current(), worldmap::Tux::setup(), sound_manager, tux, and worldmap_table.

{
  sound_manager->play_music(music);
  MenuManager::set_current(NULL);

  current_ = this;
  load_state();

  // if force_spawnpoint was set, move Tux there, then clear force_spawnpoint
  if (force_spawnpoint != "") {
    move_to_spawnpoint(force_spawnpoint);
    force_spawnpoint = "";
  }

  tux->setup();

  // register worldmap_table as worldmap in scripting
  using namespace scripting;

  sq_pushroottable(global_vm);
  sq_pushstring(global_vm, "worldmap", -1);
  sq_pushobject(global_vm, worldmap_table);
  if(SQ_FAILED(sq_createslot(global_vm, -3)))
    throw SquirrelError(global_vm, "Couldn't set worldmap in roottable");
  sq_pop(global_vm, 1);

  //Run default.nut just before init script
  try {
    IFileStream in(levels_path + "/default.nut");
    run_script(in, "WorldMap::default.nut");
  } catch(std::exception& ) {
    // doesn't exist or erroneous; do nothing
  }

  if(init_script != "") {
    std::istringstream in(init_script);
    run_script(in, "WorldMap::init");
  }
}

void worldmap::WorldMap::leave

(

)

[virtual]

gets called when the current screen is temporarily suspended

Reimplemented from Screen.

Definition at line 918 of file worldmap.cpp.

References scripting::global_vm, and save_state().

{
  using namespace scripting;

  // save state of world and player
  save_state();

  // remove worldmap_table from roottable
  sq_pushroottable(global_vm);
  sq_pushstring(global_vm, "worldmap", -1);
  if(SQ_FAILED(sq_deleteslot(global_vm, -2, SQFalse)))
    throw SquirrelError(global_vm, "Couldn't unset worldmap in roottable");
  sq_pop(global_vm, 1);
}

void worldmap::WorldMap::update

(

float

delta

)

[virtual]

Update worldmap state.

Implements Screen.

Definition at line 536 of file worldmap.cpp.

References Controller::ACTION, at_level(), at_teleporter(), worldmap::LevelTile::auto_play, worldmap::Teleporter::automatic, worldmap::Tux::back_direction, camera_offset, CAMERA_PAN_SPEED, change(), clamp_camera_position(), MenuManager::current(), worldmap::D_NONE, ScreenManager::exit_screen(), g_jk_controller, g_screen_manager, game_objects, get_camera_pos_for_tux(), JoystickKeyboardController::get_main_controller(), GameObject::get_name(), worldmap::Tux::get_tile_pos(), in_level, worldmap::Tux::is_moving(), Controller::JUMP, levels_path, log_fatal, log_warning, Controller::MENU_SELECT, MNID_QUITWORLDMAP, MNID_RETURNWORLDMAP, move_to_spawnpoint(), Vector::norm(), on_escape_press(), pan_pos, panning, Controller::PAUSE_MENU, SoundManager::play(), player_status, worldmap::LevelTile::pos, Controller::pressed(), ScreenManager::push_screen(), save_state(), MenuManager::set_current(), solid_tilemaps, worldmap::LevelTile::solved, sound_manager, worldmap::Teleporter::spawnpoint, worldmap::LevelTile::statistics, tile_data_at(), try_unexpose(), tux, Controller::UP, worldmap::Teleporter::worldmap, Tile::WORLDMAP_EAST, worldmap_menu, Tile::WORLDMAP_NORTH, Tile::WORLDMAP_SOUTH, Tile::WORLDMAP_WEST, Vector::x, and Vector::y.

{
  if(!in_level) {
    Menu* menu = MenuManager::current();
    if(menu != NULL) {
      if(menu == worldmap_menu.get()) {
        switch (worldmap_menu->check())
        {
          case MNID_RETURNWORLDMAP: // Return to game
            MenuManager::set_current(0);
            break;
          case MNID_QUITWORLDMAP: // Quit Worldmap
            g_screen_manager->exit_screen();
            break;
        }
      }

      return;
    }

    // update GameObjects
    for(size_t i = 0; i < game_objects.size(); ++i) {
      GameObject* object = game_objects[i];
      if(!panning || object != tux) {
        object->update(delta);
      }
    }

    // remove old GameObjects
    for(GameObjects::iterator i = game_objects.begin();
        i != game_objects.end(); ) {
      GameObject* object = *i;
      if(!object->is_valid()) {
        try_unexpose(object);
        object->unref();
        i = game_objects.erase(i);
      } else {
        ++i;
      }
    }

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

    Vector requested_pos;

    // position "camera"
    if(!panning) {
      camera_offset = get_camera_pos_for_tux();
    } else {
      Vector delta = pan_pos - camera_offset;
      float mag = delta.norm();
      if(mag > CAMERA_PAN_SPEED) {
        delta *= CAMERA_PAN_SPEED/mag;
      }
      camera_offset += delta;
      if(camera_offset == pan_pos) {
        panning = false;
      }
    }

    requested_pos = camera_offset;
    clamp_camera_position(camera_offset);

    if(panning) {
      if(requested_pos.x != camera_offset.x) {
        pan_pos.x = camera_offset.x;
      }
      if(requested_pos.y != camera_offset.y) {
        pan_pos.y = camera_offset.y;
      }
    }

    // handle input
    Controller *controller = g_jk_controller->get_main_controller();
    bool enter_level = false;
    if(controller->pressed(Controller::ACTION)
       || controller->pressed(Controller::JUMP)
       || controller->pressed(Controller::MENU_SELECT)) {
      /* some people define UP and JUMP on the same key... */
      if(!controller->pressed(Controller::UP))
        enter_level = true;
    }
    if(controller->pressed(Controller::PAUSE_MENU))
      on_escape_press();

    // check for teleporters
    Teleporter* teleporter = at_teleporter(tux->get_tile_pos());
    if (teleporter && (teleporter->automatic || (enter_level && (!tux->is_moving())))) {
      enter_level = false;
      if (teleporter->worldmap != "") {
        change(teleporter->worldmap, teleporter->spawnpoint);
      } else {
        // TODO: an animation, camera scrolling or a fading would be a nice touch
        sound_manager->play("sounds/warp.wav");
        tux->back_direction = D_NONE;
        move_to_spawnpoint(teleporter->spawnpoint, true);
      }
    }

    // check for auto-play levels
    LevelTile* level = at_level();
    if (level && (level->auto_play) && (!level->solved) && (!tux->is_moving())) {
      enter_level = true;
    }

    if (enter_level && !tux->is_moving())
    {
      /* Check level action */
      LevelTile* level = at_level();
      if (!level) {
        //Respawn if player on a tile with no level and nowhere to go.
        int tile_data = tile_data_at(tux->get_tile_pos());
        if(!( tile_data & ( Tile::WORLDMAP_NORTH |  Tile::WORLDMAP_SOUTH | Tile::WORLDMAP_WEST | Tile::WORLDMAP_EAST ))){
          log_warning << "Player at illegal position " << tux->get_tile_pos().x << ", " << tux->get_tile_pos().y << " respawning." << std::endl;
          move_to_spawnpoint("main");
          return;
        }
        log_warning << "No level to enter at: " << tux->get_tile_pos().x << ", " << tux->get_tile_pos().y << std::endl;
        return;
      }

      if (level->pos == tux->get_tile_pos()) {
        try {
          Vector shrinkpos = Vector(level->pos.x*32 + 16 - camera_offset.x,
                                    level->pos.y*32 +  8 - camera_offset.y);
          std::string levelfile = levels_path + level->get_name();

          // update state and savegame
          save_state();

          g_screen_manager->push_screen(new GameSession(levelfile, player_status, &level->statistics),
                                   new ShrinkFade(shrinkpos, 1.0f));
          in_level = true;
        } catch(std::exception& e) {
          log_fatal << "Couldn't load level: " << e.what() << std::endl;
        }
      }
    }
    else
    {
      //      tux->set_direction(input_direction);
    }
  }
}

void worldmap::WorldMap::draw

(

DrawingContext &

context

)

[virtual]

Draw worldmap.

Implements Screen.

Definition at line 761 of file worldmap.cpp.

References ambient_light, camera_offset, DrawingContext::draw_filled_rect(), draw_status(), game_objects, get_height(), get_width(), LAYER_BACKGROUND0, panning, DrawingContext::pop_transform(), DrawingContext::push_transform(), SCREEN_HEIGHT, SCREEN_WIDTH, DrawingContext::set_ambient_color(), DrawingContext::set_translation(), and tux.

{
  if (int(get_width()*32) < SCREEN_WIDTH || int(get_height()*32) < SCREEN_HEIGHT)
    context.draw_filled_rect(Vector(0, 0), Vector(SCREEN_WIDTH, SCREEN_HEIGHT),
                             Color(0.0f, 0.0f, 0.0f, 1.0f), LAYER_BACKGROUND0);

  context.set_ambient_color( ambient_light );
  context.push_transform();
  context.set_translation(camera_offset);

  for(GameObjects::iterator i = game_objects.begin();
      i != game_objects.end(); ++i) {
    GameObject* object = *i;
    if(!panning || object != tux) {
      object->draw(context);
    }
  }

  /*
  // FIXME: make this a runtime switch similar to draw_collrects/show_collrects?
  // draw visual indication of possible walk directions
  static int flipme = 0; 
  if (flipme++ & 0x04)
  for (int x = 0; x < get_width(); x++) {
  for (int y = 0; y < get_height(); y++) {
  int data = tile_data_at(Vector(x,y));
  int px = x * 32;
  int py = y * 32;
  const int W = 4;
  if (data & Tile::WORLDMAP_NORTH)    context.draw_filled_rect(Rect(px + 16-W, py       , px + 16+W, py + 16-W), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  if (data & Tile::WORLDMAP_SOUTH)    context.draw_filled_rect(Rect(px + 16-W, py + 16+W, px + 16+W, py + 32  ), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  if (data & Tile::WORLDMAP_EAST)     context.draw_filled_rect(Rect(px + 16+W, py + 16-W, px + 32  , py + 16+W), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  if (data & Tile::WORLDMAP_WEST)     context.draw_filled_rect(Rect(px       , py + 16-W, px + 16-W, py + 16+W), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  if (data & Tile::WORLDMAP_DIR_MASK) context.draw_filled_rect(Rect(px + 16-W, py + 16-W, px + 16+W, py + 16+W), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  if (data & Tile::WORLDMAP_STOP)     context.draw_filled_rect(Rect(px + 4   , py + 4   , px + 28  , py + 28  ), Color(0.2f, 0.2f, 0.2f, 0.7f), LAYER_FOREGROUND1 + 1000);
  }
  }
  */

  draw_status(context);
  context.pop_transform();
}

Vector worldmap::WorldMap::get_next_tile	(	Vector	pos,
		Direction	direction
	)

Definition at line 391 of file worldmap.cpp.

References worldmap::D_EAST, worldmap::D_NONE, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, Vector::x, and Vector::y.

Referenced by path_ok(), and worldmap::Tux::tryStartWalking().

{
  switch(direction) {
    case D_WEST:
      pos.x -= 1;
      break;
    case D_EAST:
      pos.x += 1;
      break;
    case D_NORTH:
      pos.y -= 1;
      break;
    case D_SOUTH:
      pos.y += 1;
      break;
    case D_NONE:
      break;
  }
  return pos;
}

int worldmap::WorldMap::available_directions_at

(

Vector

pos

)

gets a bitfield of Tile::WORLDMAP_NORTH | Tile::WORLDMAP_WEST | .

.. values, which indicates the directions Tux can move to when at the given position.

Definition at line 706 of file worldmap.cpp.

References tile_data_at(), and Tile::WORLDMAP_DIR_MASK.

Referenced by finished_level().

{
  return tile_data_at(p) & Tile::WORLDMAP_DIR_MASK;
}

int worldmap::WorldMap::tile_data_at

(

Vector

pos

)

returns a bitfield representing the union of all Tile::WORLDMAP_XXX values of all solid tiles at the given position

Definition at line 691 of file worldmap.cpp.

References Tile::getData(), solid_tilemaps, Vector::x, and Vector::y.

Referenced by available_directions_at(), path_ok(), worldmap::Tux::tryContinueWalking(), and update().

{
  int dirs = 0;

  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* tilemap = *i;
    const Tile* tile = tilemap->get_tile((int)p.x, (int)p.y);
    int dirdata = tile->getData();
    dirs |= dirdata;
  }

  return dirs;
}

size_t worldmap::WorldMap::level_count

(

)

Definition at line 1082 of file worldmap.cpp.

References levels.

{
  return levels.size();
}

size_t worldmap::WorldMap::solved_level_count

(

)

Definition at line 1088 of file worldmap.cpp.

References levels.

{
  size_t count = 0;
  for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
    LevelTile* level = *i;

    if(level->solved)
      count++;
  }

  return count;
}

void worldmap::WorldMap::finished_level

(

Level *

level

)

gets called from the GameSession when a level has been successfully finished

Definition at line 452 of file worldmap.cpp.

References at_level(), available_directions_at(), worldmap::Tux::back_direction, calculate_total_stats(), worldmap::D_EAST, worldmap::D_NONE, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, worldmap::LevelTile::extro_script, worldmap::Tux::get_tile_pos(), log_warning, Statistics::merge(), run_script(), save_state(), worldmap::Tux::set_direction(), worldmap::LevelTile::solved, worldmap::LevelTile::sprite, worldmap::LevelTile::statistics, Level::stats, tux, Tile::WORLDMAP_CNEW, Tile::WORLDMAP_CNSE, Tile::WORLDMAP_CNSEW, Tile::WORLDMAP_CNSW, Tile::WORLDMAP_CSEW, Tile::WORLDMAP_EAST, Tile::WORLDMAP_NORTH, Tile::WORLDMAP_SOUTH, and Tile::WORLDMAP_WEST.

{
  // TODO use Level* parameter here?
  LevelTile* level = at_level();

  bool old_level_state = level->solved;
  level->solved = true;
  level->sprite->set_action("solved");

  // deal with statistics
  level->statistics.merge(gamelevel->stats);
  calculate_total_stats();

  save_state();

  if (old_level_state != level->solved) {
    // Try to detect the next direction to which we should walk
    // FIXME: Mostly a hack
    Direction dir = D_NONE;

    int dirdata = available_directions_at(tux->get_tile_pos());
    // first, test for crossroads
    if (dirdata == Tile::WORLDMAP_CNSE ||
        dirdata == Tile::WORLDMAP_CNSW ||
        dirdata == Tile::WORLDMAP_CNEW ||
        dirdata == Tile::WORLDMAP_CSEW ||
        dirdata == Tile::WORLDMAP_CNSEW)
      dir = D_NONE;
    else if (dirdata & Tile::WORLDMAP_NORTH
             && tux->back_direction != D_NORTH)
      dir = D_NORTH;
    else if (dirdata & Tile::WORLDMAP_SOUTH
             && tux->back_direction != D_SOUTH)
      dir = D_SOUTH;
    else if (dirdata & Tile::WORLDMAP_EAST
             && tux->back_direction != D_EAST)
      dir = D_EAST;
    else if (dirdata & Tile::WORLDMAP_WEST
             && tux->back_direction != D_WEST)
      dir = D_WEST;

    if (dir != D_NONE) {
      tux->set_direction(dir);
    }
  }

  if (level->extro_script != "") {
    try {
      std::istringstream in(level->extro_script);
      run_script(in, "worldmap:extro_script");
    } catch(std::exception& e) {
      log_warning << "Couldn't run level-extro-script: " << e.what() << std::endl;
    }
  }
}

Tux* worldmap::WorldMap::get_tux

(

)

[inline]

returns current Tux incarnation

Definition at line 172 of file worldmap.hpp.

References tux.

{ return tux; }

PlayerStatus* worldmap::WorldMap::get_player_status

(

)

[inline]

returns player status

Definition at line 175 of file worldmap.hpp.

References player_status.

Referenced by worldmap::Tux::draw().

{ return player_status; }

LevelTile * worldmap::WorldMap::at_level

(

)

Definition at line 712 of file worldmap.cpp.

References worldmap::Tux::get_tile_pos(), levels, and tux.

Referenced by finished_level(), worldmap::Tux::tryContinueWalking(), worldmap::Tux::tryStartWalking(), and update().

{
  for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
    LevelTile* level = *i;
    if (level->pos == tux->get_tile_pos())
      return level;
  }

  return NULL;
}

SpecialTile * worldmap::WorldMap::at_special_tile

(

)

Definition at line 724 of file worldmap.cpp.

References worldmap::Tux::get_tile_pos(), special_tiles, and tux.

Referenced by worldmap::Tux::tryContinueWalking().

{
  for(SpecialTiles::iterator i = special_tiles.begin();
      i != special_tiles.end(); ++i) {
    SpecialTile* special_tile = *i;
    if (special_tile->pos == tux->get_tile_pos())
      return special_tile;
  }

  return NULL;
}

SpriteChange * worldmap::WorldMap::at_sprite_change

(

const Vector &

pos

)

Definition at line 737 of file worldmap.cpp.

References sprite_changes.

Referenced by worldmap::Tux::setup(), and worldmap::Tux::tryContinueWalking().

{
  for(SpriteChanges::iterator i = sprite_changes.begin();
      i != sprite_changes.end(); ++i) {
    SpriteChange* sprite_change = *i;
    if(sprite_change->pos == pos)
      return sprite_change;
  }

  return NULL;
}

Teleporter * worldmap::WorldMap::at_teleporter

(

const Vector &

pos

)

Definition at line 750 of file worldmap.cpp.

References teleporters.

Referenced by draw_status(), worldmap::Tux::tryContinueWalking(), and update().

{
  for(std::vector<Teleporter*>::iterator i = teleporters.begin(); i != teleporters.end(); ++i) {
    Teleporter* teleporter = *i;
    if(teleporter->pos == pos) return teleporter;
  }

  return NULL;
}

bool worldmap::WorldMap::path_ok	(	Direction	direction,
		const Vector &	pos,
		Vector *	new_pos
	)

Check if it is possible to walk from pos into direction, if possible, write the new position to new_pos.

Definition at line 413 of file worldmap.cpp.

References worldmap::D_EAST, worldmap::D_NONE, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, get_height(), get_next_tile(), get_width(), tile_data_at(), Tile::WORLDMAP_EAST, Tile::WORLDMAP_NORTH, Tile::WORLDMAP_SOUTH, Tile::WORLDMAP_WEST, Vector::x, and Vector::y.

Referenced by worldmap::Tux::tryContinueWalking(), and worldmap::Tux::tryStartWalking().

{
  *new_pos = get_next_tile(old_pos, direction);

  if (!(new_pos->x >= 0 && new_pos->x < get_width()
        && new_pos->y >= 0 && new_pos->y < get_height()))
  { // New position is outsite the tilemap
    return false;
  }
  else
  { // Check if the tile allows us to go to new_pos
    int old_tile_data = tile_data_at(old_pos);
    int new_tile_data = tile_data_at(*new_pos);
    switch(direction)
    {
      case D_WEST:
        return (old_tile_data & Tile::WORLDMAP_WEST
                && new_tile_data & Tile::WORLDMAP_EAST);

      case D_EAST:
        return (old_tile_data & Tile::WORLDMAP_EAST
                && new_tile_data & Tile::WORLDMAP_WEST);

      case D_NORTH:
        return (old_tile_data & Tile::WORLDMAP_NORTH
                && new_tile_data & Tile::WORLDMAP_SOUTH);

      case D_SOUTH:
        return (old_tile_data & Tile::WORLDMAP_SOUTH
                && new_tile_data & Tile::WORLDMAP_NORTH);

      case D_NONE:
        assert(!"path_ok() can't walk if direction is NONE");
    }
    return false;
  }
}

void worldmap::WorldMap::save_state

(

)

Save worldmap state to squirrel state table.

Definition at line 934 of file worldmap.cpp.

References worldmap::Tux::back_direction, World::current(), worldmap::direction_to_string(), worldmap::Tux::get_tile_pos(), scripting::global_vm, levels, map_filename, World::save_state(), Statistics::serialize_to_squirrel(), scripting::store_bool(), scripting::store_float(), scripting::store_string(), total_stats, tux, Vector::x, and Vector::y.

Referenced by finished_level(), leave(), and update().

{
  using namespace scripting;

  HSQUIRRELVM vm = global_vm;
  int oldtop = sq_gettop(vm);

  try {
    // get state table
    sq_pushroottable(vm);
    sq_pushstring(vm, "state", -1);
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get state table");

    // get or create worlds table
    sq_pushstring(vm, "worlds", -1);
    if(SQ_FAILED(sq_get(vm, -2))) {
      sq_pushstring(vm, "worlds", -1);
      sq_newtable(vm);
      if(SQ_FAILED(sq_createslot(vm, -3)))
        throw scripting::SquirrelError(vm, "Couldn't create state.worlds");

      sq_pushstring(vm, "worlds", -1);
      if(SQ_FAILED(sq_get(vm, -2)))
        throw scripting::SquirrelError(vm, "Couldn't create.get state.worlds");
    }

    sq_pushstring(vm, map_filename.c_str(), map_filename.length());
    if(SQ_FAILED(sq_deleteslot(vm, -2, SQFalse)))
      sq_pop(vm, 1);

    // construct new table for this worldmap
    sq_pushstring(vm, map_filename.c_str(), map_filename.length());
    sq_newtable(vm);

    // store tux
    sq_pushstring(vm, "tux", -1);
    sq_newtable(vm);

    store_float(vm, "x", tux->get_tile_pos().x);
    store_float(vm, "y", tux->get_tile_pos().y);
    store_string(vm, "back", direction_to_string(tux->back_direction));

    sq_createslot(vm, -3);

    // levels...
    sq_pushstring(vm, "levels", -1);
    sq_newtable(vm);

    for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
      LevelTile* level = *i;

      sq_pushstring(vm, level->get_name().c_str(), -1);
      sq_newtable(vm);

      store_bool(vm, "solved", level->solved);
      level->statistics.serialize_to_squirrel(vm);

      sq_createslot(vm, -3);
    }

    sq_createslot(vm, -3);

    // overall statistics...
    total_stats.serialize_to_squirrel(vm);

    // push world into worlds table
    sq_createslot(vm, -3);
  } catch(std::exception& ) {
    sq_settop(vm, oldtop);
  }

  sq_settop(vm, oldtop);

  if(World::current() != NULL)
    World::current()->save_state();
}

void worldmap::WorldMap::load_state

(

)

Load worldmap state from squirrel state table.

Definition at line 1013 of file worldmap.cpp.

References worldmap::Tux::back_direction, scripting::global_vm, in_level, levels, log_debug, map_filename, scripting::read_bool(), scripting::read_float(), scripting::read_string(), worldmap::Tux::set_tile_pos(), worldmap::string_to_direction(), total_stats, tux, Statistics::unserialize_from_squirrel(), Vector::x, and Vector::y.

Referenced by setup().

{
  using namespace scripting;

  HSQUIRRELVM vm = global_vm;
  int oldtop = sq_gettop(vm);

  try {
    // get state table
    sq_pushroottable(vm);
    sq_pushstring(vm, "state", -1);
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get state table");

    // get worlds table
    sq_pushstring(vm, "worlds", -1);
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get state.worlds");

    // get table for our world
    sq_pushstring(vm, map_filename.c_str(), map_filename.length());
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get state.worlds.mapfilename");

    // load tux
    sq_pushstring(vm, "tux", -1);
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get tux");

    Vector p;
    p.x = read_float(vm, "x");
    p.y = read_float(vm, "y");
    std::string back_str = read_string(vm, "back");
    tux->back_direction = string_to_direction(back_str);
    tux->set_tile_pos(p);

    sq_pop(vm, 1);

    // load levels
    sq_pushstring(vm, "levels", -1);
    if(SQ_FAILED(sq_get(vm, -2)))
      throw scripting::SquirrelError(vm, "Couldn't get levels");

    for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
      LevelTile* level = *i;
      sq_pushstring(vm, level->get_name().c_str(), -1);
      if(SQ_SUCCEEDED(sq_get(vm, -2))) {
        level->solved = read_bool(vm, "solved");
        level->sprite->set_action(level->solved ? "solved" : "default");
        level->statistics.unserialize_from_squirrel(vm);
        sq_pop(vm, 1);
      }
    }

    // leave state table
    sq_pop(vm, 1);

    // load overall statistics
    total_stats.unserialize_from_squirrel(vm);

  } catch(std::exception& e) {
    log_debug << "Not loading worldmap state: " << e.what() << std::endl;
  }
  sq_settop(vm, oldtop);

  in_level = false;
}

const std::string& worldmap::WorldMap::get_title

(

)

const [inline]

Definition at line 196 of file worldmap.hpp.

References name.

  { return name; }

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

runs a script in the context of the worldmap (and keeps a reference to the script (so the script gets destroyed when the worldmap is destroyed)

Definition at line 1102 of file worldmap.cpp.

References scripting::compile_and_run(), scripting::create_thread(), scripting::global_vm, scripting::object_to_vm(), scripts, and worldmap_table.

Referenced by finished_level(), setup(), and worldmap::Tux::tryContinueWalking().

{
  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 worldmap_table as roottable for the thread
  sq_pushobject(vm, worldmap_table);
  sq_setroottable(vm);

  compile_and_run(vm, in, sourcename);

  return vm;
}

void worldmap::WorldMap::change	(	const std::string &	filename,
		const std::string &	force_spawnpoint = ""
	)

switch to another worldmap.

filename is relative to data root path

Definition at line 240 of file worldmap.cpp.

References ScreenManager::exit_screen(), g_screen_manager, player_status, ScreenManager::push_screen(), and WorldMap().

Referenced by update().

{
  g_screen_manager->exit_screen();
  g_screen_manager->push_screen(new WorldMap(filename, player_status, force_spawnpoint));
}

void worldmap::WorldMap::move_to_spawnpoint	(	const std::string &	spawnpoint,
		bool	pan = false
	)

moves Tux to the given spawnpoint

Definition at line 217 of file worldmap.cpp.

References clamp_camera_position(), get_camera_pos_for_tux(), log_warning, pan_pos, panning, worldmap::Tux::set_direction(), worldmap::Tux::set_tile_pos(), spawn_points, and tux.

Referenced by load(), setup(), and update().

{
  for(SpawnPoints::iterator i = spawn_points.begin(); i != spawn_points.end(); ++i) {
    SpawnPoint* sp = *i;
    if(sp->name == spawnpoint) {
      Vector p = sp->pos;
      tux->set_tile_pos(p);
      tux->set_direction(sp->auto_dir);
      if(pan) {
        panning = true;
        pan_pos = get_camera_pos_for_tux();
        clamp_camera_position(pan_pos);
      }
      return;
    }
  }
  log_warning << "Spawnpoint '" << spawnpoint << "' not found." << std::endl;
  if (spawnpoint != "main") {
    move_to_spawnpoint("main");
  }
}

float worldmap::WorldMap::get_width

(

)

const

returns the width (in tiles) of a worldmap

Definition at line 1136 of file worldmap.cpp.

References solid_tilemaps.

Referenced by clamp_camera_position(), draw(), and path_ok().

{
  float width = 0;
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    if (solids->get_width() > width) width = solids->get_width();
  }
  return width;
}

float worldmap::WorldMap::get_height

(

)

const

returns the height (in tiles) of a worldmap

Definition at line 1147 of file worldmap.cpp.

References solid_tilemaps.

Referenced by clamp_camera_position(), draw(), draw_status(), and path_ok().

{
  float height = 0;
  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    if (solids->get_height() > height) height = solids->get_height();
  }
  return height;
}

void worldmap::WorldMap::get_level_title

(

LevelTile &

level

)

[private]

Definition at line 347 of file worldmap.cpp.

References lisp::Lisp::get(), lisp::Lisp::get_lisp(), GameObject::get_name(), levels_path, log_warning, lisp::Parser::parse(), and worldmap::LevelTile::title.

Referenced by draw_status().

{
  level.title = "<no title>";

  try {
    lisp::Parser parser;
    const lisp::Lisp* root = parser.parse(levels_path + level.get_name());

    const lisp::Lisp* level_lisp = root->get_lisp("supertux-level");
    if(!level_lisp)
      return;

    level_lisp->get("name", level.title);
  } catch(std::exception& e) {
    log_warning << "Problem when reading leveltitle: " << e.what() << std::endl;
    return;
  }
}

void worldmap::WorldMap::draw_status

(

DrawingContext &

context

)

[private]

Definition at line 805 of file worldmap.cpp.

References ALIGN_CENTER, at_teleporter(), PlayerStatus::draw(), DrawingContext::draw_text(), get_height(), get_level_title(), worldmap::Tux::get_tile_pos(), worldmap::Tux::is_moving(), LAYER_FOREGROUND1, level_title_color, levels, worldmap::Teleporter::message, message_color, Resources::normal_font, passive_message, passive_message_timer, player_status, DrawingContext::pop_transform(), DrawingContext::push_transform(), SCREEN_HEIGHT, SCREEN_WIDTH, DrawingContext::set_translation(), special_tiles, Timer::started(), teleporter_message_color, and tux.

Referenced by draw().

{
  context.push_transform();
  context.set_translation(Vector(0, 0));

  player_status->draw(context);

  if (!tux->is_moving()) {
    for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
      LevelTile* level = *i;

      if (level->pos == tux->get_tile_pos()) {
        if(level->title == "")
          get_level_title(*level);

        context.draw_text(Resources::normal_font, level->title,
                          Vector(SCREEN_WIDTH/2,
                                 SCREEN_HEIGHT - Resources::normal_font->get_height() - 30),
                          ALIGN_CENTER, LAYER_FOREGROUND1, WorldMap::level_title_color);

        // if level is solved, draw level picture behind stats
        /*
          if (level->solved) {
          if (const Surface* picture = level->get_picture()) {
          Vector pos = Vector(SCREEN_WIDTH - picture->get_width(), SCREEN_HEIGHT - picture->get_height());
          context.push_transform();
          context.set_alpha(0.5);
          context.draw_surface(picture, pos, LAYER_FOREGROUND1-1);
          context.pop_transform();
          }
          }
        */

        level->statistics.draw_worldmap_info(context);
        break;
      }
    }

    for(SpecialTiles::iterator i = special_tiles.begin();
        i != special_tiles.end(); ++i) {
      SpecialTile* special_tile = *i;

      if (special_tile->pos == tux->get_tile_pos()) {
        /* Display an in-map message in the map, if any as been selected */
        if(!special_tile->map_message.empty() && !special_tile->passive_message)
          context.draw_text(Resources::normal_font, special_tile->map_message,
                            Vector(SCREEN_WIDTH/2,
                                   SCREEN_HEIGHT - Resources::normal_font->get_height() - 60),
                            ALIGN_CENTER, LAYER_FOREGROUND1, WorldMap::message_color);
        break;
      }
    }

    // display teleporter messages
    Teleporter* teleporter = at_teleporter(tux->get_tile_pos());
    if (teleporter && (teleporter->message != "")) {
      Vector pos = Vector(SCREEN_WIDTH/2, SCREEN_HEIGHT - Resources::normal_font->get_height() - 30);
      context.draw_text(Resources::normal_font, teleporter->message, pos, ALIGN_CENTER, LAYER_FOREGROUND1, WorldMap::teleporter_message_color);
    }

  }

  /* Display a passive message in the map, if needed */
  if(passive_message_timer.started())
    context.draw_text(Resources::normal_font, passive_message,
                      Vector(SCREEN_WIDTH/2, SCREEN_HEIGHT - Resources::normal_font->get_height() - 60),
                      ALIGN_CENTER, LAYER_FOREGROUND1, WorldMap::message_color);

  context.pop_transform();
}

void worldmap::WorldMap::calculate_total_stats

(

)

[private]

Definition at line 367 of file worldmap.cpp.

References levels, total_stats, and Statistics::zero().

Referenced by finished_level().

{
  total_stats.zero();
  for(LevelTiles::iterator i = levels.begin(); i != levels.end(); ++i) {
    LevelTile* level = *i;
    if (level->solved) {
      total_stats += level->statistics;
    }
  }
}

void worldmap::WorldMap::load

(

const std::string &

filename

)

[private]

Definition at line 247 of file worldmap.cpp.

References add_object(), ambient_light, current_tileset, FileSystem::dirname(), free_tileset, lisp::Lisp::get(), lisp::Lisp::get_lisp(), TileManager::get_tileset(), init_script, lisp::ListIterator::item(), levels, levels_path, lisp::ListIterator::lisp(), log_warning, map_filename, move_to_spawnpoint(), music, name, lisp::ListIterator::next(), lisp::Parser::parse(), TileManager::parse_tileset_definition(), solid_tilemaps, spawn_points, special_tiles, sprite_changes, teleporters, tile_manager, tileset, and lisp::ListIterator::value().

Referenced by WorldMap().

{
  map_filename = filename;
  levels_path = FileSystem::dirname(map_filename);

  try {
    lisp::Parser parser;
    const lisp::Lisp* root = parser.parse(map_filename);

    const lisp::Lisp* level = root->get_lisp("supertux-level");
    if(level == NULL)
      throw std::runtime_error("file isn't a supertux-level file.");

    level->get("name", name);

    const lisp::Lisp* sector = level->get_lisp("sector");
    if(!sector)
      throw std::runtime_error("No sector specified in worldmap file.");

    const lisp::Lisp* tilesets_lisp = level->get_lisp("tilesets");
    if(tilesets_lisp != NULL) {
      tileset      = tile_manager->parse_tileset_definition(*tilesets_lisp);
      free_tileset = true;
    }
    std::string tileset_name;
    if(level->get("tileset", tileset_name)) {
      if(tileset != NULL) {
        log_warning << "multiple tilesets specified in level" << std::endl;
      } else {
        tileset = tile_manager->get_tileset(tileset_name);
      }
    }
    /* load default tileset */
    if(tileset == NULL) {
      tileset = tile_manager->get_tileset("images/worldmap.strf");
    }
    current_tileset = tileset;

    lisp::ListIterator iter(sector);
    while(iter.next()) {
      if(iter.item() == "tilemap") {
        add_object(new TileMap(*(iter.lisp())));
      } else if(iter.item() == "background") {
        add_object(new Background(*(iter.lisp())));
      } else if(iter.item() == "music") {
        iter.value()->get(music);
      } else if(iter.item() == "init-script") {
        iter.value()->get(init_script);
      } else if(iter.item() == "worldmap-spawnpoint") {
        SpawnPoint* sp = new SpawnPoint(*iter.lisp());
        spawn_points.push_back(sp);
      } else if(iter.item() == "level") {
        LevelTile* level = new LevelTile(levels_path, *iter.lisp());
        levels.push_back(level);
        add_object(level);
      } else if(iter.item() == "special-tile") {
        SpecialTile* special_tile = new SpecialTile(*iter.lisp());
        special_tiles.push_back(special_tile);
        add_object(special_tile);
      } else if(iter.item() == "sprite-change") {
        SpriteChange* sprite_change = new SpriteChange(*iter.lisp());
        sprite_changes.push_back(sprite_change);
        add_object(sprite_change);
      } else if(iter.item() == "teleporter") {
        Teleporter* teleporter = new Teleporter(*iter.lisp());
        teleporters.push_back(teleporter);
        add_object(teleporter);
      } else if(iter.item() == "decal") {
        Decal* decal = new Decal(*iter.lisp());
        add_object(decal);
      } else if(iter.item() == "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 if(iter.item() == "name") {
        // skip
      } else {
        log_warning << "Unknown token '" << iter.item() << "' in worldmap" << std::endl;
      }
    }
    current_tileset = NULL;

    if(solid_tilemaps.size() == 0)
      throw std::runtime_error("No solid tilemap specified");

    move_to_spawnpoint("main");

  } catch(std::exception& e) {
    std::stringstream msg;
    msg << "Problem when parsing worldmap '" << map_filename << "': " <<
      e.what();
    throw std::runtime_error(msg.str());
  }
}

void worldmap::WorldMap::on_escape_press

(

)

[private]

Definition at line 379 of file worldmap.cpp.

References MenuManager::current(), worldmap::D_NONE, MenuManager::set_current(), worldmap::Tux::set_direction(), tux, and worldmap_menu.

Referenced by update().

{
  // Show or hide the menu
  if(!MenuManager::current()) {
    MenuManager::set_current(worldmap_menu.get());
    tux->set_direction(D_NONE);  // stop tux movement when menu is called
  } else {
    MenuManager::set_current(NULL);
  }
}

Vector worldmap::WorldMap::get_camera_pos_for_tux

(

)

[private]

Definition at line 509 of file worldmap.cpp.

References camera_offset, worldmap::Tux::get_pos(), SCREEN_HEIGHT, SCREEN_WIDTH, tux, Vector::x, and Vector::y.

Referenced by move_to_spawnpoint(), and update().

                                 {
  Vector camera_offset;
  Vector tux_pos = tux->get_pos();
  camera_offset.x = tux_pos.x - SCREEN_WIDTH/2;
  camera_offset.y = tux_pos.y - SCREEN_HEIGHT/2;
  return camera_offset;
}

void worldmap::WorldMap::clamp_camera_position

(

Vector &

c

)

[private]

Definition at line 518 of file worldmap.cpp.

References get_height(), get_width(), SCREEN_HEIGHT, SCREEN_WIDTH, Vector::x, and Vector::y.

Referenced by move_to_spawnpoint(), and update().

                                         {
  if (c.x < 0)
    c.x = 0;
  if (c.y < 0)
    c.y = 0;

  if (c.x > (int)get_width()*32 - SCREEN_WIDTH)
    c.x = (int)get_width()*32 - SCREEN_WIDTH;
  if (c.y > (int)get_height()*32 - SCREEN_HEIGHT)
    c.y = (int)get_height()*32 - SCREEN_HEIGHT;

  if (int(get_width()*32) < SCREEN_WIDTH)
    c.x = get_width()*16.0 - SCREEN_WIDTH/2.0;
  if (int(get_height()*32) < SCREEN_HEIGHT)
    c.y = get_height()*16.0 - SCREEN_HEIGHT/2.0;
}

WorldMap& worldmap::WorldMap::operator=

(

const WorldMap &

)

[private]

---

Member Data Documentation

Color worldmap::WorldMap::level_title_color [static, private]

Definition at line 67 of file worldmap.hpp.

Referenced by draw_status().

Color worldmap::WorldMap::message_color [static, private]

Definition at line 68 of file worldmap.hpp.

Referenced by draw_status().

Color worldmap::WorldMap::teleporter_message_color [static, private]

Definition at line 69 of file worldmap.hpp.

Referenced by draw_status().

Tux* worldmap::WorldMap::tux [private]

Definition at line 79 of file worldmap.hpp.

Referenced by at_level(), at_special_tile(), draw(), draw_status(), finished_level(), get_camera_pos_for_tux(), get_tux(), load_state(), move_to_spawnpoint(), on_escape_press(), save_state(), setup(), update(), and WorldMap().

PlayerStatus* worldmap::WorldMap::player_status [private]

Definition at line 81 of file worldmap.hpp.

Referenced by change(), draw_status(), get_player_status(), and update().

TileSet* worldmap::WorldMap::tileset [private]

Definition at line 83 of file worldmap.hpp.

Referenced by load(), and ~WorldMap().

bool worldmap::WorldMap::free_tileset [private]

Definition at line 84 of file worldmap.hpp.

Referenced by load(), and ~WorldMap().

WorldMap * worldmap::WorldMap::current_ [static, private]

Definition at line 86 of file worldmap.hpp.

Referenced by current(), setup(), and ~WorldMap().

std::auto_ptr<Menu> worldmap::WorldMap::worldmap_menu [private]

Definition at line 88 of file worldmap.hpp.

Referenced by on_escape_press(), update(), and WorldMap().

Vector worldmap::WorldMap::camera_offset [private]

Definition at line 90 of file worldmap.hpp.

Referenced by draw(), get_camera_pos_for_tux(), and update().

std::string worldmap::WorldMap::name [private]

Definition at line 92 of file worldmap.hpp.

Referenced by get_title(), load(), and WorldMap().

std::string worldmap::WorldMap::music [private]

Definition at line 93 of file worldmap.hpp.

Referenced by load(), setup(), and WorldMap().

std::string worldmap::WorldMap::init_script [private]

Definition at line 94 of file worldmap.hpp.

Referenced by load(), and setup().

GameObjects worldmap::WorldMap::game_objects [private]

Definition at line 96 of file worldmap.hpp.

Referenced by add_object(), draw(), update(), and ~WorldMap().

std::list<TileMap*> worldmap::WorldMap::solid_tilemaps [private]

Definition at line 97 of file worldmap.hpp.

Referenced by add_object(), get_height(), get_width(), load(), tile_data_at(), and update().

Timer worldmap::WorldMap::passive_message_timer

Variables to deal with the passive map messages.

Definition at line 101 of file worldmap.hpp.

Referenced by draw_status(), and worldmap::Tux::tryContinueWalking().

std::string worldmap::WorldMap::passive_message

Definition at line 102 of file worldmap.hpp.

Referenced by draw_status(), and worldmap::Tux::tryContinueWalking().

std::string worldmap::WorldMap::map_filename [private]

Definition at line 105 of file worldmap.hpp.

Referenced by load(), load_state(), and save_state().

std::string worldmap::WorldMap::levels_path [private]

Definition at line 106 of file worldmap.hpp.

Referenced by get_level_title(), load(), setup(), and update().

SpecialTiles worldmap::WorldMap::special_tiles [private]

Definition at line 108 of file worldmap.hpp.

Referenced by at_special_tile(), draw_status(), and load().

LevelTiles worldmap::WorldMap::levels [private]

Definition at line 109 of file worldmap.hpp.

Referenced by at_level(), calculate_total_stats(), draw_status(), level_count(), load(), load_state(), save_state(), and solved_level_count().

SpriteChanges worldmap::WorldMap::sprite_changes [private]

Definition at line 110 of file worldmap.hpp.

Referenced by at_sprite_change(), and load().

SpawnPoints worldmap::WorldMap::spawn_points [private]

Definition at line 111 of file worldmap.hpp.

Referenced by load(), move_to_spawnpoint(), and ~WorldMap().

std::vector<Teleporter*> worldmap::WorldMap::teleporters [private]

Definition at line 112 of file worldmap.hpp.

Referenced by at_teleporter(), and load().

Statistics worldmap::WorldMap::total_stats [private]

Definition at line 114 of file worldmap.hpp.

Referenced by calculate_total_stats(), load_state(), save_state(), and WorldMap().

HSQOBJECT worldmap::WorldMap::worldmap_table [private]

Definition at line 116 of file worldmap.hpp.

Referenced by run_script(), setup(), try_expose(), try_unexpose(), WorldMap(), and ~WorldMap().

ScriptList worldmap::WorldMap::scripts [private]

Definition at line 117 of file worldmap.hpp.

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

Color worldmap::WorldMap::ambient_light [private]

Definition at line 119 of file worldmap.hpp.

Referenced by draw(), and load().

std::string worldmap::WorldMap::force_spawnpoint [private]

if set, spawnpoint will be forced to this value

Definition at line 120 of file worldmap.hpp.

Referenced by setup().

bool worldmap::WorldMap::in_level [private]

Definition at line 122 of file worldmap.hpp.

Referenced by load_state(), and update().

Vector worldmap::WorldMap::pan_pos [private]

Definition at line 125 of file worldmap.hpp.

Referenced by move_to_spawnpoint(), and update().

bool worldmap::WorldMap::panning [private]

Definition at line 126 of file worldmap.hpp.

Referenced by draw(), move_to_spawnpoint(), and update().

---

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

• src/worldmap/worldmap.hpp
• src/supertux/colorscheme.cpp
• src/worldmap/worldmap.cpp

---