GameSession Class Reference

Screen that runs a Level, where Players run and jump through Sectors. More...

#include <game_session.hpp>

Inherits Screen, and Currenton< GameSession >.

List of all members.

Public Member Functions
	GameSession (const std::string &levelfile, PlayerStatus *player_status, Statistics *statistics=NULL)
	~GameSession ()
void	record_demo (const std::string &filename)
int	get_demo_random_seed (const std::string &filename)
void	play_demo (const std::string &filename)
void	draw (DrawingContext &context)
	gets called once per frame.
void	update (float frame_ratio)
	gets called for once (per logical) frame.
void	setup ()
	gets called before this screen gets activated (which is at least once before the first draw or update call
void	finish (bool win=true)
	ends the current level
void	respawn (const std::string &sectorname, const std::string &spawnpointname)
void	set_reset_point (const std::string &sectorname, const Vector &pos)
std::string	get_reset_point_sectorname ()
Vector	get_reset_point_pos ()
Sector *	get_current_sector ()
Level *	get_current_level ()
PlayerStatus *	get_player_status ()
void	start_sequence (const std::string &sequencename)
std::string	get_working_directory ()
	returns the "working directory" usually this is the directory where the currently played level resides.
int	restart_level ()
void	toggle_pause ()
void	set_editmode (bool edit_mode=true)
	Enters or leaves level editor mode.
void	force_ghost_mode ()
	Forces all Players to enter ghost mode.
Private Types
typedef std::vector< HSQOBJECT >	ScriptList
Private Member Functions
void	check_end_conditions ()
void	process_events ()
void	capture_demo_step ()
void	drawstatus (DrawingContext &context)
void	draw_pause (DrawingContext &context)
HSQUIRRELVM	run_script (std::istream &in, const std::string &sourcename)
void	on_escape_press ()
void	process_menu ()
	GameSession (const GameSession &)
GameSession &	operator= (const GameSession &)
Private Attributes
std::auto_ptr< Level >	level
SurfacePtr	statistics_backdrop
ScriptList	scripts
Sector *	currentsector
int	levelnb
int	pause_menu_frame
EndSequence *	end_sequence
bool	game_pause
float	speed_before_pause
std::string	levelfile
std::string	reset_sector
Vector	reset_pos
std::string	newsector
std::string	newspawnpoint
Statistics *	best_level_statistics
PlayerStatus *	player_status
std::ostream *	capture_demo_stream
std::string	capture_file
std::istream *	playback_demo_stream
CodeController *	demo_controller
std::auto_ptr< Menu >	game_menu
float	play_time
	total time in seconds that this session ran interactively
bool	edit_mode
	true if GameSession runs in level editor mode
bool	levelintro_shown
	true if the LevelIntro screen was already shown

---

Detailed Description

Screen that runs a Level, where Players run and jump through Sectors.

Definition at line 40 of file game_session.hpp.

---

Member Typedef Documentation

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

Definition at line 112 of file game_session.hpp.

---

Constructor & Destructor Documentation

GameSession::GameSession	(	const std::string &	levelfile,
		PlayerStatus *	player_status,
		Statistics *	statistics = NULL
	)

Definition at line 46 of file game_session.cpp.

References Surface::create(), currentsector, g_screen_manager, game_menu, game_pause, ScreenManager::get_speed(), level, restart_level(), speed_before_pause, and statistics_backdrop.

                                                                                                         :
  level(0), 
  statistics_backdrop(),
  scripts(),
  currentsector(0),
  levelnb(),
  pause_menu_frame(),
  end_sequence(0),
  game_pause(),
  speed_before_pause(),
  levelfile(levelfile_), 
  reset_sector(),
  reset_pos(),
  newsector(),
  newspawnpoint(),
  best_level_statistics(statistics),
  player_status(player_status),
  capture_demo_stream(0), 
  capture_file(),
  playback_demo_stream(0), 
  demo_controller(0),
  game_menu(),
  play_time(0), 
  edit_mode(false), 
  levelintro_shown(false)
{
  currentsector = NULL;

  game_pause = false;
  speed_before_pause = g_screen_manager->get_speed();

  statistics_backdrop = Surface::create("images/engine/menu/score-backdrop.png");

  if (restart_level() != 0)
    throw std::runtime_error ("Initializing the level failed.");

  game_menu.reset(new GameMenu(*level));
}

GameSession::~GameSession

(

)

Definition at line 146 of file game_session.cpp.

References capture_demo_stream, demo_controller, and playback_demo_stream.

{
  delete capture_demo_stream;
  delete playback_demo_stream;
  delete demo_controller;
}

GameSession::GameSession

(

const GameSession &

)

[private]

---

Member Function Documentation

void GameSession::record_demo

(

const std::string &

filename

)

Definition at line 154 of file game_session.cpp.

References capture_demo_stream, capture_file, g_config, and Config::random_seed.

Referenced by scripting::record_demo(), and restart_level().

{
  delete capture_demo_stream;

  capture_demo_stream = new std::ofstream(filename.c_str());
  if(!capture_demo_stream->good()) {
    std::stringstream msg;
    msg << "Couldn't open demo file '" << filename << "' for writing.";
    throw std::runtime_error(msg.str());
  }
  capture_file = filename;

  char buf[30];                            // save the seed in the demo file
  snprintf(buf, sizeof(buf), "random_seed=%10d", g_config->random_seed);
  for (int i=0; i==0 || buf[i-1]; i++)
    capture_demo_stream->put(buf[i]);
}

int GameSession::get_demo_random_seed

(

const std::string &

filename

)

Definition at line 173 of file game_session.cpp.

References log_info.

Referenced by scripting::play_demo().

{
  std::istream* test_stream = new std::ifstream(filename.c_str());
  if(test_stream->good()) {
    char buf[30];                     // recall the seed from the demo file
    int seed;
    for (int i=0; i<30 && (i==0 || buf[i-1]); i++)
      test_stream->get(buf[i]);
    if (sscanf(buf, "random_seed=%10d", &seed) == 1) {
      log_info << "Random seed " << seed << " from demo file" << std::endl;
      return seed;
    }
    else
      log_info << "Demo file contains no random number" << std::endl;
  }
  return 0;
}

void GameSession::play_demo

(

const std::string &

filename

)

Definition at line 192 of file game_session.cpp.

References currentsector, demo_controller, playback_demo_stream, and Sector::player.

Referenced by scripting::play_demo().

{
  delete playback_demo_stream;
  delete demo_controller;

  playback_demo_stream = new std::ifstream(filename.c_str());
  if(!playback_demo_stream->good()) {
    std::stringstream msg;
    msg << "Couldn't open demo file '" << filename << "' for reading.";
    throw std::runtime_error(msg.str());
  }

  Player& tux = *currentsector->player;
  demo_controller = new CodeController();
  tux.set_controller(demo_controller);

  // skip over random seed, if it exists in the file
  char buf[30];                            // ascii decimal seed
  int seed;
  for (int i=0; i<30 && (i==0 || buf[i-1]); i++)
    playback_demo_stream->get(buf[i]);
  if (sscanf(buf, "random_seed=%010d", &seed) != 1)
    playback_demo_stream->seekg(0);     // old style w/o seed, restart at beg
}

void GameSession::draw

(

DrawingContext &

context

)

[virtual]

gets called once per frame.

The screen should draw itself in this function. State changes should not be done in this function, but rather in update

Implements Screen.

Definition at line 371 of file game_session.cpp.

References currentsector, Sector::draw(), draw_pause(), drawstatus(), and game_pause.

{
  currentsector->draw(context);
  drawstatus(context);

  if(game_pause)
    draw_pause(context);
}

void GameSession::update

(

float

frame_ratio

)

[virtual]

gets called for once (per logical) frame.

Screens should do their state updates and logic here

Implements Screen.

Definition at line 431 of file game_session.cpp.

References Sector::activate(), Sector::camera, check_end_conditions(), MenuManager::current(), currentsector, edit_mode, end_sequence, g_jk_controller, g_screen_manager, game_pause, Camera::get_center(), JoystickKeyboardController::get_main_controller(), Sector::get_music_type(), Sector::get_players(), Timer::get_timeleft(), HERRING_MUSIC, HERRING_WARNING_MUSIC, Player::invincible_timer, EndSequence::is_tux_stopped(), level, LEVEL_MUSIC, log_warning, newsector, newspawnpoint, on_escape_press(), Controller::PAUSE_MENU, Sector::play_music(), play_time, Sector::player, Controller::pressed(), process_events(), process_menu(), SoundManager::set_listener_position(), ScreenManager::set_speed(), sound_manager, speed_before_pause, Timer::started(), TUX_INVINCIBLE_TIME_WARNING, EndSequence::update(), and Sector::update().

{
  // handle controller
  if(g_jk_controller->get_main_controller()->pressed(Controller::PAUSE_MENU))
    on_escape_press();

  process_events();
  process_menu();

  // Unpause the game if the menu has been closed
  if (game_pause && !MenuManager::current()) {
    g_screen_manager->set_speed(speed_before_pause);
    game_pause = false;
  }

  check_end_conditions();

  // respawning in new sector?
  if(newsector != "" && newspawnpoint != "") {
    Sector* sector = level->get_sector(newsector);
    if(sector == 0) {
      log_warning << "Sector '" << newsector << "' not found" << std::endl;
      sector = level->get_sector("main");
    }
    sector->activate(newspawnpoint);
    sector->play_music(LEVEL_MUSIC);
    currentsector = sector;
    //Keep persistent across sectors
    if(edit_mode)
      currentsector->get_players()[0]->set_edit_mode(edit_mode);
    newsector = "";
    newspawnpoint = "";
  }

  // Update the world state and all objects in the world
  if(!game_pause) {
    // Update the world
    if (!end_sequence) {
      play_time += elapsed_time; //TODO: make sure we don't count cutscene time
      level->stats.time = play_time;
      currentsector->update(elapsed_time);
    } else {
      if (!end_sequence->is_tux_stopped()) {
        currentsector->update(elapsed_time);
      } else {
        end_sequence->update(elapsed_time);
      }
    }
  }

  // update sounds
  if (currentsector && currentsector->camera) sound_manager->set_listener_position(currentsector->camera->get_center());

  /* Handle music: */
  if (end_sequence)
    return;

  if(currentsector->player->invincible_timer.started()) {
    if(currentsector->player->invincible_timer.get_timeleft() <=
       TUX_INVINCIBLE_TIME_WARNING) {
      currentsector->play_music(HERRING_WARNING_MUSIC);
    } else {
      currentsector->play_music(HERRING_MUSIC);
    }
  } else if(currentsector->get_music_type() != LEVEL_MUSIC) {
    currentsector->play_music(LEVEL_MUSIC);
  }
}

void GameSession::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 409 of file game_session.cpp.

References Sector::activate(), best_level_statistics, Sector::current(), currentsector, g_screen_manager, MovingObject::get_pos(), level, LEVEL_MUSIC, levelintro_shown, Sector::play_music(), Sector::player, and ScreenManager::push_screen().

{
  if (currentsector == NULL)
    return;

  if(currentsector != Sector::current()) {
    currentsector->activate(currentsector->player->get_pos());
  }
  currentsector->play_music(LEVEL_MUSIC);

  // Eat unneeded events
  SDL_Event event;
  while(SDL_PollEvent(&event))
  {}

  if (!levelintro_shown) {
    levelintro_shown = true;
    g_screen_manager->push_screen(new LevelIntro(level.get(), best_level_statistics));
  }
}

void GameSession::finish

(

bool

win = true

)

ends the current level

Definition at line 501 of file game_session.cpp.

References edit_mode, ScreenManager::exit_screen(), force_ghost_mode(), g_screen_manager, and level.

Referenced by check_end_conditions(), and scripting::Level_finish().

{
  using namespace worldmap;

  if (edit_mode) {
    force_ghost_mode();
    return;
  }

  if(win) {
    if(WorldMap::current())
      WorldMap::current()->finished_level(level.get());
  }

  g_screen_manager->exit_screen();
}

void GameSession::respawn	(	const std::string &	sectorname,
		const std::string &	spawnpointname
	)

Definition at line 519 of file game_session.cpp.

References newsector, and newspawnpoint.

Referenced by Door::collision(), WillOWisp::collision_player(), and scripting::Level_spawn().

{
  newsector = sector;
  newspawnpoint = spawnpoint;
}

void GameSession::set_reset_point	(	const std::string &	sectorname,
		const Vector &	pos
	)

Definition at line 526 of file game_session.cpp.

References reset_pos, and reset_sector.

Referenced by Firefly::collision().

{
  reset_sector = sector;
  reset_pos = pos;
}

std::string GameSession::get_reset_point_sectorname

(

)

[inline]

Definition at line 59 of file game_session.hpp.

References reset_sector.

  { return reset_sector; }

Vector GameSession::get_reset_point_pos

(

)

[inline]

Definition at line 62 of file game_session.hpp.

References reset_pos.

  { return reset_pos; }

Sector* GameSession::get_current_sector

(

)

[inline]

Definition at line 65 of file game_session.hpp.

References currentsector.

  { return currentsector; }

Level* GameSession::get_current_level

(

)

[inline]

Definition at line 68 of file game_session.hpp.

References level.

  { return level.get(); }

PlayerStatus* GameSession::get_player_status

(

)

[inline]

Definition at line 71 of file game_session.hpp.

References player_status.

  { return player_status; }

void GameSession::start_sequence

(

const std::string &

sequencename

)

Definition at line 539 of file game_session.cpp.

References Sector::add_object(), currentsector, edit_mode, end_sequence, force_ghost_mode(), g_screen_manager, Sector::gameobjects, Sector::get_players(), log_warning, SoundManager::play_music(), Sector::player, ScreenManager::set_speed(), Player::set_winning(), sound_manager, EndSequence::start(), LevelTime::stop(), and EndSequence::stop_tux().

Referenced by Player::trigger_sequence().

{
  // do not play sequences when in edit mode
  if (edit_mode) {
    force_ghost_mode();
    return;
  }

  // handle special "stoptux" sequence
  if (sequencename == "stoptux") {
    if (!end_sequence) {
      log_warning << "Final target reached without an active end sequence" << std::endl;
      this->start_sequence("endsequence");
    }
    if (end_sequence) end_sequence->stop_tux();
    return;
  }

  // abort if a sequence is already playing
  if (end_sequence)
    return;

  if (sequencename == "endsequence") {
    if (currentsector->get_players()[0]->get_physic().get_velocity_x() < 0) {
      end_sequence = new EndSequenceWalkLeft();
    } else {
      end_sequence = new EndSequenceWalkRight();
    }
  } else if (sequencename == "fireworks") {
    end_sequence = new EndSequenceFireworks();
  } else {
    log_warning << "Unknown sequence '" << sequencename << "'. Ignoring." << std::endl;
    return;
  }

  /* slow down the game for end-sequence */
  g_screen_manager->set_speed(0.5f);

  currentsector->add_object(end_sequence);
  end_sequence->start();

  sound_manager->play_music("music/leveldone.ogg", false);
  currentsector->player->set_winning();

  // Stop all clocks.
  for(std::vector<GameObject*>::iterator i = currentsector->gameobjects.begin();
      i != currentsector->gameobjects.end(); ++i)
  {
    GameObject* obj = *i;

    LevelTime* lt = dynamic_cast<LevelTime*> (obj);
    if(lt)
      lt->stop();
  }
}

std::string GameSession::get_working_directory

(

)

returns the "working directory" usually this is the directory where the currently played level resides.

This is used when locating additional resources for the current level/world

Definition at line 533 of file game_session.cpp.

References FileSystem::dirname(), and levelfile.

{
  return FileSystem::dirname(levelfile);
}

int GameSession::restart_level

(

)

Definition at line 86 of file game_session.cpp.

References Sector::activate(), capture_file, currentsector, edit_mode, end_sequence, ScreenManager::exit_screen(), force_ghost_mode(), g_config, g_jk_controller, g_screen_manager, game_pause, gameRandom, level, LEVEL_MUSIC, levelfile, log_fatal, log_info, Sector::play_music(), play_time, RandomGenerator::rand(), Config::random_seed, record_demo(), JoystickKeyboardController::reset(), reset_pos, reset_sector, sound_manager, RandomGenerator::srand(), and SoundManager::stop_music().

Referenced by check_end_conditions(), GameSession(), scripting::play_demo(), scripting::record_demo(), scripting::restart(), and set_editmode().

{

  if (edit_mode) {
    force_ghost_mode();
    return (-1);
  }

  game_pause   = false;
  end_sequence = 0;

  g_jk_controller->reset();

  currentsector = 0;

  level.reset(new Level);
  try {
    level->load(levelfile);
    level->stats.total_coins = level->get_total_coins();
    level->stats.total_badguys = level->get_total_badguys();
    level->stats.total_secrets = level->get_total_secrets();
    level->stats.reset();

    if(reset_sector != "") {
      currentsector = level->get_sector(reset_sector);
      if(!currentsector) {
        std::stringstream msg;
        msg << "Couldn't find sector '" << reset_sector << "' for resetting tux.";
        throw std::runtime_error(msg.str());
      }
      level->stats.declare_invalid();
      currentsector->activate(reset_pos);
    } else {
      currentsector = level->get_sector("main");
      if(!currentsector)
        throw std::runtime_error("Couldn't find main sector");
      play_time = 0;
      currentsector->activate("main");
    }
  } catch(std::exception& e) {
    log_fatal << "Couldn't start level: " << e.what() << std::endl;
    g_screen_manager->exit_screen();
    return (-1);
  }

  sound_manager->stop_music();
  currentsector->play_music(LEVEL_MUSIC);

  if(capture_file != "") {
    int newSeed=0;               // next run uses a new seed
    while (newSeed == 0)            // which is the next non-zero random num.
      newSeed = gameRandom.rand();
    g_config->random_seed = gameRandom.srand(newSeed);
    log_info << "Next run uses random seed " << g_config->random_seed <<std::endl;
    record_demo(capture_file);
  }

  return (0);
}

void GameSession::toggle_pause

(

)

Definition at line 239 of file game_session.cpp.

References g_screen_manager, game_menu, game_pause, ScreenManager::get_speed(), MNID_CONTINUE, MenuManager::set_current(), ScreenManager::set_speed(), and speed_before_pause.

Referenced by scripting::Level_toggle_pause(), on_escape_press(), and process_menu().

{
  // pause
  if(!game_pause) {
    speed_before_pause = g_screen_manager->get_speed();
    g_screen_manager->set_speed(0);
    MenuManager::set_current(game_menu.get());
    game_menu->set_active_item(MNID_CONTINUE);
    game_pause = true;
  }

  // unpause is done in update() after the menu is processed
}

void GameSession::set_editmode

(

bool

edit_mode = true

)

Enters or leaves level editor mode.

Definition at line 254 of file game_session.cpp.

References currentsector, Sector::get_players(), and restart_level().

Referenced by scripting::Level_edit().

{
  if (this->edit_mode == edit_mode) return;
  this->edit_mode = edit_mode;

  currentsector->get_players()[0]->set_edit_mode(edit_mode);

  if (edit_mode) {

    // entering edit mode

  } else {

    // leaving edit mode
    restart_level();

  }
}

void GameSession::force_ghost_mode

(

)

Forces all Players to enter ghost mode.

Definition at line 274 of file game_session.cpp.

References currentsector, and Sector::get_players().

Referenced by finish(), restart_level(), and start_sequence().

{
  currentsector->get_players()[0]->set_ghost_mode(true);
}

void GameSession::check_end_conditions

(

)

[private]

Definition at line 358 of file game_session.cpp.

References currentsector, end_sequence, finish(), Player::is_dead(), EndSequence::is_done(), Sector::player, and restart_level().

Referenced by update().

{
  Player* tux = currentsector->player;

  /* End of level? */
  if(end_sequence && end_sequence->is_done()) {
    finish(true);
  } else if (!end_sequence && tux->is_dead()) {
    restart_level();
  }
}

void GameSession::process_events

(

)

[private]

Definition at line 310 of file game_session.cpp.

References Controller::ACTION, capture_demo_stream, demo_controller, Controller::DOWN, g_jk_controller, JoystickKeyboardController::get_main_controller(), Controller::hold(), Controller::JUMP, Controller::LEFT, playback_demo_stream, CodeController::press(), Controller::RIGHT, Controller::UP, and CodeController::update().

Referenced by update().

{
  // end of pause mode?
  // XXX this looks like a fail-safe to unpause the game if there's no menu
  // XXX having it enabled causes some unexpected problems
  // XXX hopefully disabling it won't...
  /*
    if(!Menu::current() && game_pause) {
    game_pause = false;
    }
  */

  // playback a demo?
  if(playback_demo_stream != 0) {
    demo_controller->update();
    char left = false;
    char right = false;
    char up = false;
    char down = false;
    char jump = false;
    char action = false;
    playback_demo_stream->get(left);
    playback_demo_stream->get(right);
    playback_demo_stream->get(up);
    playback_demo_stream->get(down);
    playback_demo_stream->get(jump);
    playback_demo_stream->get(action);
    demo_controller->press(Controller::LEFT, left);
    demo_controller->press(Controller::RIGHT, right);
    demo_controller->press(Controller::UP, up);
    demo_controller->press(Controller::DOWN, down);
    demo_controller->press(Controller::JUMP, jump);
    demo_controller->press(Controller::ACTION, action);
  }

  // save input for demo?
  if(capture_demo_stream != 0) {
    Controller *controller = g_jk_controller->get_main_controller();
    capture_demo_stream ->put(controller->hold(Controller::LEFT));
    capture_demo_stream ->put(controller->hold(Controller::RIGHT));
    capture_demo_stream ->put(controller->hold(Controller::UP));
    capture_demo_stream ->put(controller->hold(Controller::DOWN));
    capture_demo_stream ->put(controller->hold(Controller::JUMP));
    capture_demo_stream ->put(controller->hold(Controller::ACTION));
  }
}

void GameSession::capture_demo_step

(

)

[private]

void GameSession::drawstatus

(

DrawingContext &

context

)

[private]

Definition at line 597 of file game_session.cpp.

References best_level_statistics, PlayerStatus::draw(), end_sequence, level, player_status, and statistics_backdrop.

Referenced by draw().

{
  player_status->draw(context);

  // draw level stats while end_sequence is running
  if (end_sequence) {
    level->stats.draw_endseq_panel(context, best_level_statistics, statistics_backdrop);
  }
}

void GameSession::draw_pause

(

DrawingContext &

context

)

[private]

Definition at line 381 of file game_session.cpp.

References DrawingContext::draw_filled_rect(), LAYER_FOREGROUND1, SCREEN_HEIGHT, and SCREEN_WIDTH.

Referenced by draw().

{
  context.draw_filled_rect(
    Vector(0,0), Vector(SCREEN_WIDTH, SCREEN_HEIGHT),
    Color(0.0f, 0.0f, 0.0f, .25f), LAYER_FOREGROUND1);
}

HSQUIRRELVM GameSession::run_script	(	std::istream &	in,
		const std::string &	sourcename
	)			[private]

Definition at line 280 of file game_session.cpp.

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

Referenced by on_escape_press().

{
  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);

  compile_and_run(vm, in, sourcename);

  return vm;
}

void GameSession::on_escape_press

(

)

[private]

Definition at line 218 of file game_session.cpp.

References currentsector, Player::dying_timer, end_sequence, Player::is_dying(), level, Sector::player, run_script(), Timer::start(), and toggle_pause().

Referenced by update().

{
  if(currentsector->player->is_dying() || end_sequence)
  {
    // Let the timers run out, we fast-forward them to force past a sequence
    if (end_sequence)
      end_sequence->stop();

    currentsector->player->dying_timer.start(FLT_EPSILON);
    return;   // don't let the player open the menu, when he is dying
  }

  if(level->on_menukey_script != "") {
    std::istringstream in(level->on_menukey_script);
    run_script(in, "OnMenuKeyScript");
  } else {
    toggle_pause();
  }
}

void GameSession::process_menu

(

)

[private]

Definition at line 389 of file game_session.cpp.

References MenuManager::current(), ScreenManager::exit_screen(), g_screen_manager, game_menu, MNID_ABORTLEVEL, MNID_CONTINUE, MenuManager::set_current(), and toggle_pause().

Referenced by update().

{
  Menu* menu = MenuManager::current();
  if(menu) {
    if(menu == game_menu.get()) {
      switch (game_menu->check()) {
        case MNID_CONTINUE:
          MenuManager::set_current(0);
          toggle_pause();
          break;
        case MNID_ABORTLEVEL:
          MenuManager::set_current(0);
          g_screen_manager->exit_screen();
          break;
      }
    }
  }
}

GameSession& GameSession::operator=

(

const GameSession &

)

[private]

---

Member Data Documentation

std::auto_ptr<Level> GameSession::level [private]

Definition at line 108 of file game_session.hpp.

Referenced by drawstatus(), finish(), GameSession(), get_current_level(), on_escape_press(), restart_level(), setup(), and update().

SurfacePtr GameSession::statistics_backdrop [private]

Definition at line 109 of file game_session.hpp.

Referenced by drawstatus(), and GameSession().

ScriptList GameSession::scripts [private]

Definition at line 113 of file game_session.hpp.

Referenced by run_script().

Sector* GameSession::currentsector [private]

Definition at line 115 of file game_session.hpp.

Referenced by check_end_conditions(), draw(), force_ghost_mode(), GameSession(), get_current_sector(), on_escape_press(), play_demo(), restart_level(), set_editmode(), setup(), start_sequence(), and update().

int GameSession::levelnb [private]

Definition at line 117 of file game_session.hpp.

int GameSession::pause_menu_frame [private]

Definition at line 118 of file game_session.hpp.

EndSequence* GameSession::end_sequence [private]

Definition at line 120 of file game_session.hpp.

Referenced by check_end_conditions(), drawstatus(), on_escape_press(), restart_level(), start_sequence(), and update().

bool GameSession::game_pause [private]

Definition at line 122 of file game_session.hpp.

Referenced by draw(), GameSession(), restart_level(), toggle_pause(), and update().

float GameSession::speed_before_pause [private]

Definition at line 123 of file game_session.hpp.

Referenced by GameSession(), toggle_pause(), and update().

std::string GameSession::levelfile [private]

Definition at line 125 of file game_session.hpp.

Referenced by get_working_directory(), and restart_level().

std::string GameSession::reset_sector [private]

Definition at line 128 of file game_session.hpp.

Referenced by get_reset_point_sectorname(), restart_level(), and set_reset_point().

Vector GameSession::reset_pos [private]

Definition at line 129 of file game_session.hpp.

Referenced by get_reset_point_pos(), restart_level(), and set_reset_point().

std::string GameSession::newsector [private]

Definition at line 132 of file game_session.hpp.

Referenced by respawn(), and update().

std::string GameSession::newspawnpoint [private]

Definition at line 133 of file game_session.hpp.

Referenced by respawn(), and update().

Statistics* GameSession::best_level_statistics [private]

Definition at line 135 of file game_session.hpp.

Referenced by drawstatus(), and setup().

PlayerStatus* GameSession::player_status [private]

Definition at line 136 of file game_session.hpp.

Referenced by drawstatus(), and get_player_status().

std::ostream* GameSession::capture_demo_stream [private]

Definition at line 138 of file game_session.hpp.

Referenced by process_events(), record_demo(), and ~GameSession().

std::string GameSession::capture_file [private]

Definition at line 139 of file game_session.hpp.

Referenced by record_demo(), and restart_level().

std::istream* GameSession::playback_demo_stream [private]

Definition at line 140 of file game_session.hpp.

Referenced by play_demo(), process_events(), and ~GameSession().

CodeController* GameSession::demo_controller [private]

Definition at line 141 of file game_session.hpp.

Referenced by play_demo(), process_events(), and ~GameSession().

std::auto_ptr<Menu> GameSession::game_menu [private]

Definition at line 143 of file game_session.hpp.

Referenced by GameSession(), process_menu(), and toggle_pause().

float GameSession::play_time [private]

total time in seconds that this session ran interactively

Definition at line 145 of file game_session.hpp.

Referenced by restart_level(), and update().

bool GameSession::edit_mode [private]

true if GameSession runs in level editor mode

Definition at line 147 of file game_session.hpp.

Referenced by finish(), restart_level(), start_sequence(), and update().

bool GameSession::levelintro_shown [private]

true if the LevelIntro screen was already shown

Definition at line 148 of file game_session.hpp.

Referenced by setup().

---

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

• src/supertux/game_session.hpp
• src/supertux/game_session.cpp

---