src/title.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
   5 //  Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
   6 //
   7 //  This program is free software; you can redistribute it and/or
   8 //  modify it under the terms of the GNU General Public License
   9 //  as published by the Free Software Foundation; either version 2
  10 //  of the License, or (at your option) any later version.
  11 //
  12 //  This program is distributed in the hope that it will be useful,
  13 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 //  GNU General Public License for more details.
  16 //
  17 //  You should have received a copy of the GNU General Public License
  18 //  along with this program; if not, write to the Free Software
  19 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 //  02111-1307, USA.
  21
  22 #include <iostream>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <SDL.h>
  29 #include <SDL_image.h>
  30
  31 #ifndef WIN32
  32 #include <sys/types.h>
  33 #include <ctype.h>
  34 #endif
  35
  36 #include "defines.h"
  37 #include "globals.h"
  38 #include "title.h"
  39 #include "screen.h"
  40 #include "high_scores.h"
  41 #include "menu.h"
  42 #include "texture.h"
  43 #include "timer.h"
  44 #include "setup.h"
  45 #include "level.h"
  46 #include "gameloop.h"
  47 #include "leveleditor.h"
  48 #include "scene.h"
  49 #include "player.h"
  50 #include "math.h"
  51 #include "tile.h"
  52 #include "resources.h"
  53
  54 static Surface* bkg_title;
  55 static Surface* logo;
  56 static Surface* img_choose_subset;
  57
  58 static bool walking;
  59 static Timer random_timer;
  60
  61 static int frame;
  62 static unsigned int last_update_time;
  63 static unsigned int update_time;
  64
  65 std::vector<LevelSubset*> contrib_subsets;
  66 std::string current_contrib_subset;
  67
  68 void free_contrib_menu()
  69 {
  70   for(std::vector<LevelSubset*>::iterator i = contrib_subsets.begin();
  71       i != contrib_subsets.end(); ++i)
  72     delete *i;
  73
  74   contrib_subsets.clear();
  75   contrib_menu->clear();
  76 }
  77
  78 void generate_contrib_menu()
  79 {
  80   string_list_type level_subsets = dsubdirs("/levels", "info");
  81
  82   free_contrib_menu();
  83
  84   contrib_menu->additem(MN_LABEL,"Contrib Levels",0,0);
  85   contrib_menu->additem(MN_HL,"",0,0);
  86
  87   for (int i = 0; i < level_subsets.num_items; ++i)
  88     {
  89       LevelSubset* subset = new LevelSubset();
  90       subset->load(level_subsets.item[i]);
  91       contrib_menu->additem(MN_GOTO, subset->title.c_str(), i,
  92           contrib_subset_menu, i+1);
  93       contrib_subsets.push_back(subset);
  94     }
  95
  96   contrib_menu->additem(MN_HL,"",0,0);
  97   contrib_menu->additem(MN_BACK,"Back",0,0);
  98
  99   string_list_free(&level_subsets);
 100 }
 101
 102 void check_contrib_menu()
 103 {
 104   static int current_subset = -1;
 105
 106   int index = contrib_menu->check();
 107   if (index != -1)
 108     {
 109       index -= 1;
 110       if (index >= 0 && index <= int(contrib_subsets.size()))
 111         {
 112           if (current_subset != index)
 113             {
 114               current_subset = index;
 115               // FIXME: This shouln't be busy looping
 116               LevelSubset& subset = * (contrib_subsets[index]);
 117
 118               current_contrib_subset = subset.name;
 119
 120               std::cout << "Updating the contrib subset menu..." << subset.levels << std::endl;
 121
 122               contrib_subset_menu->clear();
 123
 124               contrib_subset_menu->additem(MN_LABEL, subset.title, 0,0);
 125               contrib_subset_menu->additem(MN_HL,"",0,0);
 126               for (int i = 1; i <= subset.levels; ++i)
 127                 {
 128                   Level level;
 129                   level.load(subset.name, i);
 130                   contrib_subset_menu->additem(MN_ACTION, level.name, 0, 0, i);
 131                 }
 132               contrib_subset_menu->additem(MN_HL,"",0,0);
 133               contrib_subset_menu->additem(MN_BACK, "Back", 0, 0);
 134             }
 135         }
 136       else
 137         {
 138           // Back button
 139         }
 140     }
 141 }
 142
 143 void check_contrib_subset_menu()
 144 {
 145   int index = contrib_subset_menu->check();
 146   if (index != -1)
 147     {
 148       if (contrib_subset_menu->get_item_by_id(index).kind == MN_ACTION)
 149         {
 150           std::cout << "Sarting level: " << index << std::endl;
 151           GameSession session(current_contrib_subset, index, ST_GL_PLAY);
 152           session.run();
 153           Menu::set_current(main_menu);
 154         }
 155     }
 156 }
 157
 158 void draw_background()
 159 {
 160   /* Draw the title background: */
 161
 162   bkg_title->draw_bg();
 163 }
 164
 165 void draw_demo(GameSession* session, double frame_ratio)
 166 {
 167   World::set_current(session->get_world());
 168   //World* world  = session->get_world();
 169   Level* plevel = session->get_level();
 170   Player* tux = session->get_world()->get_tux();
 171
 172   session->get_world()->play_music(LEVEL_MUSIC);
 173
 174   /* FIXME:
 175   // update particle systems
 176   std::vector<ParticleSystem*>::iterator p;
 177   for(p = particle_systems.begin(); p != particle_systems.end(); ++p)
 178     {
 179       (*p)->simulate(frame_ratio);
 180     }
 181
 182   // Draw particle systems (background)
 183   for(p = particle_systems.begin(); p != particle_systems.end(); ++p)
 184     {
 185       (*p)->draw(scroll_x, 0, 0);
 186     }
 187   */
 188
 189   // Draw interactive tiles:
 190   for (int y = 0; y < 15; ++y)
 191     {
 192       for (int x = 0; x < 21; ++x)
 193         {
 194           Tile::draw(32*x - fmodf(scroll_x, 32), y * 32,
 195                      plevel->ia_tiles[(int)y][(int)x + (int)(scroll_x / 32)]);
 196         }
 197     }
 198
 199   global_frame_counter++;
 200   tux->key_event((SDLKey) keymap.right,DOWN);
 201
 202   if(random_timer.check())
 203     {
 204       if(walking)
 205         tux->key_event((SDLKey) keymap.jump,UP);
 206       else
 207         tux->key_event((SDLKey) keymap.jump,DOWN);
 208     }
 209   else
 210     {
 211       random_timer.start(rand() % 3000 + 3000);
 212       walking = !walking;
 213     }
 214
 215   // Wrap around at the end of the level back to the beginnig
 216   if(plevel->width * 32 - 320 < tux->base.x)
 217     {
 218       tux->base.x = tux->base.x - (plevel->width * 32 - 640);
 219       scroll_x = tux->base.x - 320;
 220     }
 221
 222   float last_tux_x_pos = tux->base.x;
 223   tux->action(frame_ratio);
 224
 225   // Jump if tux stays in the same position for one loop, ie. if he is
 226   // stuck behind a wall
 227   if (last_tux_x_pos == tux->base.x)
 228     walking = false;
 229
 230   tux->draw();
 231 }
 232
 233 /* --- TITLE SCREEN --- */
 234 void title(void)
 235 {
 236   random_timer.init(true);
 237
 238   walking = true;
 239
 240   st_pause_ticks_init();
 241
 242   GameSession session(datadir + "/levels/misc/menu.stl", 0, ST_GL_DEMO_GAME);
 243
 244   clearscreen(0, 0, 0);
 245   updatescreen();
 246
 247   /* Load images: */
 248   bkg_title = new Surface(datadir + "/images/title/background.jpg", IGNORE_ALPHA);
 249   logo = new Surface(datadir + "/images/title/logo.png", USE_ALPHA);
 250   img_choose_subset = new Surface(datadir + "/images/status/choose-level-subset.png", USE_ALPHA);
 251
 252   /* --- Main title loop: --- */
 253   frame = 0;
 254
 255   /* Draw the title background: */
 256   bkg_title->draw_bg();
 257
 258   update_time = st_get_ticks();
 259   random_timer.start(rand() % 2000 + 2000);
 260
 261   Menu::set_current(main_menu);
 262   while (Menu::current())
 263     {
 264       // if we spent to much time on a menu entry
 265       if( (update_time - last_update_time) > 1000)
 266         update_time = last_update_time = st_get_ticks();
 267
 268       // Calculate the movement-factor
 269       double frame_ratio = ((double)(update_time-last_update_time))/((double)FRAME_RATE);
 270       if(frame_ratio > 1.5) /* Quick hack to correct the unprecise CPU clocks a little bit. */
 271         frame_ratio = 1.5 + (frame_ratio - 1.5) * 0.85;
 272       /* Lower the frame_ratio that Tux doesn't jump to hectically throught the demo. */
 273       frame_ratio /= 2;
 274
 275       SDL_Event event;
 276       while (SDL_PollEvent(&event))
 277         {
 278           if (Menu::current())
 279             {
 280               Menu::current()->event(event);
 281             }
 282          // FIXME: QUIT signal should be handled more generic, not locally
 283           if (event.type == SDL_QUIT)
 284             Menu::set_current(0);
 285         }
 286
 287       /* Draw the background: */
 288       draw_background();
 289       draw_demo(&session, frame_ratio);
 290
 291       if (Menu::current() == main_menu)
 292         logo->draw( 160, 30);
 293
 294       white_small_text->draw(" SuperTux " VERSION "\n"
 295                              "Copyright (c) 2003 SuperTux Devel Team\n"
 296                              "This game comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
 297                              "are welcome to redistribute it under certain conditions; see the file COPYING\n"
 298                              "for details.\n",
 299                              0, 420, 0);
 300
 301       /* Don't draw menu, if quit is true */
 302       Menu* menu = Menu::current();
 303       if(menu)
 304         {
 305           menu->draw();
 306           menu->action();
 307
 308           if(menu == main_menu)
 309             {
 310               switch (main_menu->check())
 311                 {
 312                 case MNID_STARTGAME:
 313                   // Start Game, ie. goto the slots menu
 314                   update_load_save_game_menu(load_game_menu);
 315                   break;
 316                 case MNID_CONTRIB:
 317                   // Contrib Menu
 318                   puts("Entering contrib menu");
 319                   generate_contrib_menu();
 320                   break;
 321                 case MNID_LEVELEDITOR:
 322                   leveleditor(1);
 323                   Menu::set_current(main_menu);
 324                   break;
 325                 case MNID_CREDITS:
 326                   display_text_file("CREDITS", bkg_title, SCROLL_SPEED_CREDITS);
 327                   Menu::set_current(main_menu);
 328                   break;
 329                 case MNID_QUITMAINMENU:
 330                   Menu::set_current(0);
 331                   break;
 332                 }
 333             }
 334           else if(menu == options_menu)
 335             {
 336               process_options_menu();
 337             }
 338           else if(menu == load_game_menu)
 339             {
 340               if(event.key.keysym.sym == SDLK_DELETE)
 341                 {
 342                 int slot = menu->get_active_item_id();
 343                 char str[1024];
 344                 sprintf(str,"Are you sure you want to delete slot %d?", slot);
 345
 346                 draw_background();
 347
 348                 if(confirm_dialog(str))
 349                   {
 350                   sprintf(str,"%s/slot%d.stsg", st_save_dir, slot);
 351                   printf("Removing: %s\n",str);
 352                   remove(str);
 353                   }
 354
 355                 update_load_save_game_menu(load_game_menu);
 356                 update_time = st_get_ticks();
 357                 }
 358               else if (process_load_game_menu())
 359                 {
 360                   // FIXME: shouldn't be needed if GameSession doesn't relay on global variables
 361                   // reset tux
 362                   scroll_x = 0;
 363                   //titletux.level_begin();
 364                   update_time = st_get_ticks();
 365                 }
 366             }
 367           else if(menu == contrib_menu)
 368             {
 369               check_contrib_menu();
 370             }
 371           else if (menu == contrib_subset_menu)
 372             {
 373               check_contrib_subset_menu();
 374             }
 375         }
 376
 377       mouse_cursor->draw();
 378
 379       flipscreen();
 380
 381       /* Set the time of the last update and the time of the current update */
 382       last_update_time = update_time;
 383       update_time = st_get_ticks();
 384
 385       /* Pause: */
 386       frame++;
 387       SDL_Delay(25);
 388     }
 389   /* Free surfaces: */
 390
 391   free_contrib_menu();
 392   delete bkg_title;
 393   delete logo;
 394   delete img_choose_subset;
 395 }
 396
 397 // EOF //
 398