src/supertux/game_session.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "supertux/game_session.hpp"
  18
  19 #include <float.h>
  20 #include <fstream>
  21
  22 #include "audio/sound_manager.hpp"
  23 #include "control/input_manager.hpp"
  24 #include "gui/menu.hpp"
  25 #include "gui/menu_manager.hpp"
  26 #include "math/random_generator.hpp"
  27 #include "object/camera.hpp"
  28 #include "object/endsequence_fireworks.hpp"
  29 #include "object/endsequence_walkleft.hpp"
  30 #include "object/endsequence_walkright.hpp"
  31 #include "object/level_time.hpp"
  32 #include "object/player.hpp"
  33 #include "scripting/scripting.hpp"
  34 #include "scripting/squirrel_util.hpp"
  35 #include "scripting/squirrel_util.hpp"
  36 #include "supertux/gameconfig.hpp"
  37 #include "supertux/globals.hpp"
  38 #include "supertux/levelintro.hpp"
  39 #include "supertux/levelset_screen.hpp"
  40 #include "supertux/menu/menu_storage.hpp"
  41 #include "supertux/menu/options_menu.hpp"
  42 #include "supertux/player_status.hpp"
  43 #include "supertux/savegame.hpp"
  44 #include "supertux/screen_fade.hpp"
  45 #include "supertux/screen_manager.hpp"
  46 #include "supertux/sector.hpp"
  47 #include "util/file_system.hpp"
  48 #include "util/gettext.hpp"
  49 #include "worldmap/worldmap.hpp"
  50
  51 GameSession::GameSession(const std::string& levelfile_, Savegame& savegame, Statistics* statistics) :
  52   level(),
  53   statistics_backdrop(Surface::create("images/engine/menu/score-backdrop.png")),
  54   scripts(),
  55   currentsector(nullptr),
  56   levelnb(),
  57   pause_menu_frame(),
  58   end_sequence(0),
  59   game_pause(false),
  60   speed_before_pause(ScreenManager::current()->get_speed()),
  61   levelfile(levelfile_),
  62   reset_sector(),
  63   reset_pos(),
  64   newsector(),
  65   newspawnpoint(),
  66   best_level_statistics(statistics),
  67   m_savegame(savegame),
  68   capture_demo_stream(0),
  69   capture_file(),
  70   playback_demo_stream(0),
  71   demo_controller(0),
  72   play_time(0),
  73   edit_mode(false),
  74   levelintro_shown(false),
  75   coins_at_start(),
  76   bonus_at_start(),
  77   max_fire_bullets_at_start(),
  78   max_ice_bullets_at_start(),
  79   active(false)
  80 {
  81   if (restart_level() != 0)
  82     throw std::runtime_error ("Initializing the level failed.");
  83 }
  84
  85 int
  86 GameSession::restart_level(bool after_death)
  87 {
  88     PlayerStatus* currentStatus = m_savegame.get_player_status();
  89     coins_at_start = currentStatus->coins;
  90     bonus_at_start = currentStatus->bonus;
  91     max_fire_bullets_at_start = currentStatus->max_fire_bullets;
  92     max_ice_bullets_at_start = currentStatus->max_ice_bullets;
  93
  94   if (edit_mode) {
  95     force_ghost_mode();
  96     return (-1);
  97   }
  98
  99   game_pause   = false;
 100   end_sequence = 0;
 101
 102   InputManager::current()->reset();
 103
 104   currentsector = 0;
 105
 106   level.reset(new Level);
 107   try {
 108     level->load(levelfile);
 109     level->stats.total_coins = level->get_total_coins();
 110     level->stats.total_badguys = level->get_total_badguys();
 111     level->stats.total_secrets = level->get_total_secrets();
 112     level->stats.reset();
 113
 114     if(reset_sector != "") {
 115       currentsector = level->get_sector(reset_sector);
 116       if(!currentsector) {
 117         std::stringstream msg;
 118         msg << "Couldn't find sector '" << reset_sector << "' for resetting tux.";
 119         throw std::runtime_error(msg.str());
 120       }
 121       currentsector->activate(reset_pos);
 122     } else {
 123       currentsector = level->get_sector("main");
 124       if(!currentsector)
 125         throw std::runtime_error("Couldn't find main sector");
 126       play_time = 0;
 127       currentsector->activate("main");
 128     }
 129   } catch(std::exception& e) {
 130     log_fatal << "Couldn't start level: " << e.what() << std::endl;
 131     ScreenManager::current()->pop_screen();
 132     return (-1);
 133   }
 134   if(after_death == true) {
 135     currentsector->resume_music();
 136   }
 137   else {
 138     SoundManager::current()->stop_music();
 139     currentsector->play_music(LEVEL_MUSIC);
 140   }
 141
 142   if(capture_file != "") {
 143     int newSeed=0;               // next run uses a new seed
 144     while (newSeed == 0)            // which is the next non-zero random num.
 145       newSeed = gameRandom.rand();
 146     g_config->random_seed = gameRandom.srand(newSeed);
 147     log_info << "Next run uses random seed " << g_config->random_seed <<std::endl;
 148     record_demo(capture_file);
 149   }
 150
 151   return (0);
 152 }
 153
 154 GameSession::~GameSession()
 155 {
 156   delete capture_demo_stream;
 157   delete playback_demo_stream;
 158   delete demo_controller;
 159 }
 160
 161 void
 162 GameSession::record_demo(const std::string& filename)
 163 {
 164   delete capture_demo_stream;
 165
 166   capture_demo_stream = new std::ofstream(filename.c_str());
 167   if(!capture_demo_stream->good()) {
 168     std::stringstream msg;
 169     msg << "Couldn't open demo file '" << filename << "' for writing.";
 170     throw std::runtime_error(msg.str());
 171   }
 172   capture_file = filename;
 173
 174   char buf[30];                            // save the seed in the demo file
 175   snprintf(buf, sizeof(buf), "random_seed=%10d", g_config->random_seed);
 176   for (int i=0; i==0 || buf[i-1]; i++)
 177     capture_demo_stream->put(buf[i]);
 178 }
 179
 180 int
 181 GameSession::get_demo_random_seed(const std::string& filename)
 182 {
 183   std::istream* test_stream = new std::ifstream(filename.c_str());
 184   if(test_stream->good()) {
 185     char buf[30];                     // recall the seed from the demo file
 186     int seed;
 187     for (int i=0; i<30 && (i==0 || buf[i-1]); i++)
 188       test_stream->get(buf[i]);
 189     if (sscanf(buf, "random_seed=%10d", &seed) == 1) {
 190       log_info << "Random seed " << seed << " from demo file" << std::endl;
 191       return seed;
 192     }
 193     else
 194       log_info << "Demo file contains no random number" << std::endl;
 195   }
 196   delete test_stream;
 197   test_stream = nullptr;
 198   return 0;
 199 }
 200
 201 void
 202 GameSession::play_demo(const std::string& filename)
 203 {
 204   delete playback_demo_stream;
 205   delete demo_controller;
 206
 207   playback_demo_stream = new std::ifstream(filename.c_str());
 208   if(!playback_demo_stream->good()) {
 209     std::stringstream msg;
 210     msg << "Couldn't open demo file '" << filename << "' for reading.";
 211     throw std::runtime_error(msg.str());
 212   }
 213
 214   Player& tux = *currentsector->player;
 215   demo_controller = new CodeController();
 216   tux.set_controller(demo_controller);
 217
 218   // skip over random seed, if it exists in the file
 219   char buf[30];                            // ascii decimal seed
 220   int seed;
 221   for (int i=0; i<30 && (i==0 || buf[i-1]); i++)
 222     playback_demo_stream->get(buf[i]);
 223   if (sscanf(buf, "random_seed=%010d", &seed) != 1)
 224     playback_demo_stream->seekg(0);     // old style w/o seed, restart at beg
 225 }
 226
 227 void
 228 GameSession::on_escape_press()
 229 {
 230   if(currentsector->player->is_dying() || end_sequence)
 231   {
 232     // Let the timers run out, we fast-forward them to force past a sequence
 233     if (end_sequence)
 234       end_sequence->stop();
 235
 236     currentsector->player->dying_timer.start(FLT_EPSILON);
 237     return;   // don't let the player open the menu, when he is dying
 238   }
 239
 240   if(level->on_menukey_script != "") {
 241     std::istringstream in(level->on_menukey_script);
 242     run_script(in, "OnMenuKeyScript");
 243   } else {
 244     toggle_pause();
 245   }
 246 }
 247
 248 void
 249 GameSession::toggle_pause()
 250 {
 251   // pause
 252   if (!game_pause && !MenuManager::instance().is_active())
 253   {
 254     speed_before_pause = ScreenManager::current()->get_speed();
 255     ScreenManager::current()->set_speed(0);
 256     MenuManager::instance().set_menu(MenuStorage::GAME_MENU);
 257     SoundManager::current()->pause_music();
 258     game_pause = true;
 259   }
 260
 261   // unpause is done in update() after the menu is processed
 262 }
 263
 264 void
 265 GameSession::abort_level()
 266 {
 267   MenuManager::instance().clear_menu_stack();
 268   ScreenManager::current()->pop_screen();
 269   currentsector->player->set_bonus(bonus_at_start);
 270   PlayerStatus *currentStatus = m_savegame.get_player_status();
 271   currentStatus->coins = coins_at_start;
 272   currentStatus->max_fire_bullets = max_fire_bullets_at_start;
 273   currentStatus->max_ice_bullets = max_ice_bullets_at_start;
 274 }
 275
 276 bool
 277 GameSession::is_active() const
 278 {
 279   return !game_pause && active;
 280 }
 281
 282 void
 283 GameSession::set_editmode(bool edit_mode_)
 284 {
 285   if (this->edit_mode == edit_mode_) return;
 286   this->edit_mode = edit_mode_;
 287
 288   currentsector->get_players()[0]->set_edit_mode(edit_mode_);
 289
 290   if (edit_mode_) {
 291
 292     // entering edit mode
 293
 294   } else {
 295
 296     // leaving edit mode
 297     restart_level();
 298
 299   }
 300 }
 301
 302 void
 303 GameSession::force_ghost_mode()
 304 {
 305   currentsector->get_players()[0]->set_ghost_mode(true);
 306 }
 307
 308 HSQUIRRELVM
 309 GameSession::run_script(std::istream& in, const std::string& sourcename)
 310 {
 311   using namespace scripting;
 312
 313   // garbage collect thread list
 314   for(ScriptList::iterator i = scripts.begin();
 315       i != scripts.end(); ) {
 316     HSQOBJECT& object = *i;
 317     HSQUIRRELVM vm = object_to_vm(object);
 318
 319     if(sq_getvmstate(vm) != SQ_VMSTATE_SUSPENDED) {
 320       sq_release(global_vm, &object);
 321       i = scripts.erase(i);
 322       continue;
 323     }
 324
 325     ++i;
 326   }
 327
 328   HSQOBJECT object = create_thread(global_vm);
 329   scripts.push_back(object);
 330
 331   HSQUIRRELVM vm = object_to_vm(object);
 332
 333   compile_and_run(vm, in, sourcename);
 334
 335   return vm;
 336 }
 337
 338 void
 339 GameSession::process_events()
 340 {
 341   // playback a demo?
 342   if(playback_demo_stream != 0) {
 343     demo_controller->update();
 344     char left = false;
 345     char right = false;
 346     char up = false;
 347     char down = false;
 348     char jump = false;
 349     char action = false;
 350     playback_demo_stream->get(left);
 351     playback_demo_stream->get(right);
 352     playback_demo_stream->get(up);
 353     playback_demo_stream->get(down);
 354     playback_demo_stream->get(jump);
 355     playback_demo_stream->get(action);
 356     demo_controller->press(Controller::LEFT, left);
 357     demo_controller->press(Controller::RIGHT, right);
 358     demo_controller->press(Controller::UP, up);
 359     demo_controller->press(Controller::DOWN, down);
 360     demo_controller->press(Controller::JUMP, jump);
 361     demo_controller->press(Controller::ACTION, action);
 362   }
 363
 364   // save input for demo?
 365   if(capture_demo_stream != 0) {
 366     Controller *controller = InputManager::current()->get_controller();
 367     capture_demo_stream ->put(controller->hold(Controller::LEFT));
 368     capture_demo_stream ->put(controller->hold(Controller::RIGHT));
 369     capture_demo_stream ->put(controller->hold(Controller::UP));
 370     capture_demo_stream ->put(controller->hold(Controller::DOWN));
 371     capture_demo_stream ->put(controller->hold(Controller::JUMP));
 372     capture_demo_stream ->put(controller->hold(Controller::ACTION));
 373   }
 374 }
 375
 376 void
 377 GameSession::check_end_conditions()
 378 {
 379   Player* tux = currentsector->player;
 380
 381   /* End of level? */
 382   if(end_sequence && end_sequence->is_done()) {
 383     finish(true);
 384   } else if (!end_sequence && tux->is_dead()) {
 385     restart_level(true);
 386   }
 387 }
 388
 389 void
 390 GameSession::draw(DrawingContext& context)
 391 {
 392   currentsector->draw(context);
 393   drawstatus(context);
 394
 395   if(game_pause)
 396     draw_pause(context);
 397 }
 398
 399 void
 400 GameSession::draw_pause(DrawingContext& context)
 401 {
 402   context.draw_filled_rect(
 403     Vector(0,0), Vector(SCREEN_WIDTH, SCREEN_HEIGHT),
 404     Color(0.0f, 0.0f, 0.0f, .25f), LAYER_FOREGROUND1);
 405 }
 406
 407 void
 408 GameSession::setup()
 409 {
 410   if (currentsector == NULL)
 411     return;
 412
 413   if(currentsector != Sector::current()) {
 414     currentsector->activate(currentsector->player->get_pos());
 415   }
 416   currentsector->play_music(LEVEL_MUSIC);
 417
 418   int total_stats_to_be_collected = level->stats.total_coins + level->stats.total_badguys + level->stats.total_secrets;
 419   if ((!levelintro_shown) && (total_stats_to_be_collected > 0)) {
 420     levelintro_shown = true;
 421     active = false;
 422     ScreenManager::current()->push_screen(std::unique_ptr<Screen>(new LevelIntro(level.get(), best_level_statistics)));
 423   }
 424 }
 425
 426 void
 427 GameSession::leave()
 428 {
 429 }
 430
 431 void
 432 GameSession::update(float elapsed_time)
 433 {
 434   // Set active flag
 435   if(!active)
 436   {
 437     active = true;
 438   }
 439   // handle controller
 440   if(InputManager::current()->get_controller()->pressed(Controller::ESCAPE) ||
 441      InputManager::current()->get_controller()->pressed(Controller::START))
 442   {
 443     on_escape_press();
 444   }
 445
 446   if(InputManager::current()->get_controller()->pressed(Controller::CHEAT_MENU) &&
 447      g_config->developer_mode)
 448   {
 449     if (!MenuManager::instance().is_active())
 450     {
 451       game_pause = true;
 452       MenuManager::instance().set_menu(MenuStorage::CHEAT_MENU);
 453     }
 454   }
 455
 456   process_events();
 457
 458   // Unpause the game if the menu has been closed
 459   if (game_pause && !MenuManager::instance().is_active()) {
 460     ScreenManager::current()->set_speed(speed_before_pause);
 461     SoundManager::current()->resume_music();
 462     game_pause = false;
 463   }
 464
 465   check_end_conditions();
 466
 467   // respawning in new sector?
 468   if(newsector != "" && newspawnpoint != "") {
 469     Sector* sector = level->get_sector(newsector);
 470     if(sector == 0) {
 471       log_warning << "Sector '" << newsector << "' not found" << std::endl;
 472       sector = level->get_sector("main");
 473     }
 474     sector->activate(newspawnpoint);
 475     sector->play_music(LEVEL_MUSIC);
 476     currentsector = sector;
 477     //Keep persistent across sectors
 478     if(edit_mode)
 479       currentsector->get_players()[0]->set_edit_mode(edit_mode);
 480     newsector = "";
 481     newspawnpoint = "";
 482   }
 483
 484   // Update the world state and all objects in the world
 485   if(!game_pause) {
 486     // Update the world
 487     if (!end_sequence) {
 488       play_time += elapsed_time; //TODO: make sure we don't count cutscene time
 489       level->stats.time = play_time;
 490       currentsector->update(elapsed_time);
 491     } else {
 492       if (!end_sequence->is_tux_stopped()) {
 493         currentsector->update(elapsed_time);
 494       } else {
 495         end_sequence->update(elapsed_time);
 496       }
 497     }
 498   }
 499
 500   if(currentsector == NULL)
 501     return;
 502
 503   // update sounds
 504   if (currentsector->camera) SoundManager::current()->set_listener_position(currentsector->camera->get_center());
 505
 506   /* Handle music: */
 507   if (end_sequence)
 508     return;
 509
 510   if(currentsector->player->invincible_timer.started()) {
 511     if(currentsector->player->invincible_timer.get_timeleft() <=
 512        TUX_INVINCIBLE_TIME_WARNING) {
 513       currentsector->play_music(HERRING_WARNING_MUSIC);
 514     } else {
 515       currentsector->play_music(HERRING_MUSIC);
 516     }
 517   } else if(currentsector->get_music_type() != LEVEL_MUSIC) {
 518     currentsector->play_music(LEVEL_MUSIC);
 519   }
 520 }
 521
 522 void
 523 GameSession::finish(bool win)
 524 {
 525   using namespace worldmap;
 526
 527   if (edit_mode) {
 528     force_ghost_mode();
 529     return;
 530   }
 531
 532   if(win) {
 533     if(WorldMap::current())
 534     {
 535       WorldMap::current()->finished_level(level.get());
 536     }
 537
 538     if (LevelsetScreen::current())
 539     {
 540       LevelsetScreen::current()->finished_level(win);
 541     }
 542   }
 543
 544   ScreenManager::current()->pop_screen();
 545 }
 546
 547 void
 548 GameSession::respawn(const std::string& sector, const std::string& spawnpoint)
 549 {
 550   newsector = sector;
 551   newspawnpoint = spawnpoint;
 552 }
 553
 554 void
 555 GameSession::set_reset_point(const std::string& sector, const Vector& pos)
 556 {
 557   reset_sector = sector;
 558   reset_pos = pos;
 559 }
 560
 561 std::string
 562 GameSession::get_working_directory()
 563 {
 564   return FileSystem::dirname(levelfile);
 565 }
 566
 567 void
 568 GameSession::start_sequence(const std::string& sequencename)
 569 {
 570   // do not play sequences when in edit mode
 571   if (edit_mode) {
 572     force_ghost_mode();
 573     return;
 574   }
 575
 576   // handle special "stoptux" sequence
 577   if (sequencename == "stoptux") {
 578     if (!end_sequence) {
 579       log_warning << "Final target reached without an active end sequence" << std::endl;
 580       this->start_sequence("endsequence");
 581     }
 582     if (end_sequence) end_sequence->stop_tux();
 583     return;
 584   }
 585
 586   // abort if a sequence is already playing
 587   if (end_sequence)
 588     return;
 589
 590   if (sequencename == "endsequence") {
 591     if (currentsector->get_players()[0]->get_physic().get_velocity_x() < 0) {
 592       end_sequence = std::make_shared<EndSequenceWalkLeft>();
 593     } else {
 594       end_sequence = std::make_shared<EndSequenceWalkRight>();
 595     }
 596   } else if (sequencename == "fireworks") {
 597     end_sequence = std::make_shared<EndSequenceFireworks>();
 598   } else {
 599     log_warning << "Unknown sequence '" << sequencename << "'. Ignoring." << std::endl;
 600     return;
 601   }
 602
 603   /* slow down the game for end-sequence */
 604   ScreenManager::current()->set_speed(0.5f);
 605
 606   currentsector->add_object(end_sequence);
 607   end_sequence->start();
 608
 609   SoundManager::current()->play_music("music/leveldone.ogg", false);
 610   currentsector->player->set_winning();
 611
 612   // Stop all clocks.
 613   for(auto i = currentsector->gameobjects.begin();
 614       i != currentsector->gameobjects.end(); ++i)
 615   {
 616     GameObjectPtr obj = *i;
 617
 618     auto lt = std::dynamic_pointer_cast<LevelTime>(obj);
 619     if(lt)
 620       lt->stop();
 621   }
 622 }
 623
 624 /* (Status): */
 625 void
 626 GameSession::drawstatus(DrawingContext& context)
 627 {
 628   m_savegame.get_player_status()->draw(context);
 629
 630   // draw level stats while end_sequence is running
 631   if (end_sequence) {
 632     level->stats.draw_endseq_panel(context, best_level_statistics, statistics_backdrop);
 633   }
 634 }
 635
 636 /* EOF */