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