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           player_status.reset();
 154           Menu::set_current(main_menu);
 155         }
 156     }
 157 }
 158
 159 void draw_background()
 160 {
 161   /* Draw the title background: */
 162
 163   bkg_title->draw_bg();
 164 }
 165
 166 void draw_demo(GameSession* session, double frame_ratio)
 167 {
 168   World::set_current(session->get_world());
 169   //World* world  = session->get_world();
 170   Level* plevel = session->get_level();
 171   Player* tux = session->get_world()->get_tux();
 172
 173   session->get_world()->play_music(LEVEL_MUSIC);
 174
 175   /* FIXME:
 176   // update particle systems
 177   std::vector<ParticleSystem*>::iterator p;
 178   for(p = particle_systems.begin(); p != particle_systems.end(); ++p)
 179     {
 180       (*p)->simulate(frame_ratio);
 181     }
 182
 183   // Draw particle systems (background)
 184   for(p = particle_systems.begin(); p != particle_systems.end(); ++p)
 185     {
 186       (*p)->draw(scroll_x, 0, 0);
 187     }
 188   */
 189
 190   // Draw interactive tiles:
 191   for (int y = 0; y < 15; ++y)
 192     {
 193       for (int x = 0; x < 21; ++x)
 194         {
 195           Tile::draw(32*x - fmodf(scroll_x, 32), y * 32,
 196                      plevel->ia_tiles[(int)y][(int)x + (int)(scroll_x / 32)]);
 197         }
 198     }
 199
 200   global_frame_counter++;
 201   tux->key_event((SDLKey) keymap.right,DOWN);
 202
 203   if(random_timer.check())
 204     {
 205       if(walking)
 206         tux->key_event((SDLKey) keymap.jump,UP);
 207       else
 208         tux->key_event((SDLKey) keymap.jump,DOWN);
 209     }
 210   else
 211     {
 212       random_timer.start(rand() % 3000 + 3000);
 213       walking = !walking;
 214     }
 215
 216   // Wrap around at the end of the level back to the beginnig
 217   if(plevel->width * 32 - 320 < tux->base.x)
 218     {
 219       tux->base.x = tux->base.x - (plevel->width * 32 - 640);
 220       scroll_x = tux->base.x - 320;
 221     }
 222
 223   float last_tux_x_pos = tux->base.x;
 224   tux->action(frame_ratio);
 225
 226 #if 0 // disabled for now, since with the new jump code we easily get deadlocks
 227   // Jump if tux stays in the same position for one loop, ie. if he is
 228   // stuck behind a wall
 229   if (last_tux_x_pos == tux->base.x)
 230     walking = false;
 231 #endif
 232
 233   tux->draw();
 234 }
 235
 236 /* --- TITLE SCREEN --- */
 237 void title(void)
 238 {
 239   random_timer.init(true);
 240
 241   walking = true;
 242
 243   st_pause_ticks_init();
 244
 245   GameSession session(datadir + "/levels/misc/menu.stl", 0, ST_GL_DEMO_GAME);
 246
 247   clearscreen(0, 0, 0);
 248   updatescreen();
 249
 250   /* Load images: */
 251   bkg_title = new Surface(datadir + "/images/title/background.jpg", IGNORE_ALPHA);
 252   logo = new Surface(datadir + "/images/title/logo.png", USE_ALPHA);
 253   img_choose_subset = new Surface(datadir + "/images/status/choose-level-subset.png", USE_ALPHA);
 254
 255   /* --- Main title loop: --- */
 256   frame = 0;
 257
 258   /* Draw the title background: */
 259   bkg_title->draw_bg();
 260
 261   update_time = st_get_ticks();
 262   random_timer.start(rand() % 2000 + 2000);
 263
 264   Menu::set_current(main_menu);
 265   while (Menu::current())
 266     {
 267       // if we spent to much time on a menu entry
 268       if( (update_time - last_update_time) > 1000)
 269         update_time = last_update_time = st_get_ticks();
 270
 271       // Calculate the movement-factor
 272       double frame_ratio = ((double)(update_time-last_update_time))/((double)FRAME_RATE);
 273       if(frame_ratio > 1.5) /* Quick hack to correct the unprecise CPU clocks a little bit. */
 274         frame_ratio = 1.5 + (frame_ratio - 1.5) * 0.85;
 275       /* Lower the frame_ratio that Tux doesn't jump to hectically throught the demo. */
 276       frame_ratio /= 2;
 277
 278       SDL_Event event;
 279       while (SDL_PollEvent(&event))
 280         {
 281           if (Menu::current())
 282             {
 283               Menu::current()->event(event);
 284             }
 285          // FIXME: QUIT signal should be handled more generic, not locally
 286           if (event.type == SDL_QUIT)
 287             Menu::set_current(0);
 288         }
 289
 290       /* Draw the background: */
 291       draw_background();
 292       draw_demo(&session, frame_ratio);
 293
 294       if (Menu::current() == main_menu)
 295         logo->draw( 160, 30);
 296
 297       white_small_text->draw(" SuperTux " VERSION "\n"
 298                              "Copyright (c) 2003 SuperTux Devel Team\n"
 299                              "This game comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
 300                              "are welcome to redistribute it under certain conditions; see the file COPYING\n"
 301                              "for details.\n",
 302                              0, 420, 0);
 303
 304       /* Don't draw menu, if quit is true */
 305       Menu* menu = Menu::current();
 306       if(menu)
 307         {
 308           menu->draw();
 309           menu->action();
 310
 311           if(menu == main_menu)
 312             {
 313               switch (main_menu->check())
 314                 {
 315                 case MNID_STARTGAME:
 316                   // Start Game, ie. goto the slots menu
 317                   update_load_save_game_menu(load_game_menu);
 318                   break;
 319                 case MNID_CONTRIB:
 320                   // Contrib Menu
 321                   puts("Entering contrib menu");
 322                   generate_contrib_menu();
 323                   break;
 324                 case MNID_LEVELEDITOR:
 325                   leveleditor(1);
 326                   Menu::set_current(main_menu);
 327                   break;
 328                 case MNID_CREDITS:
 329                   display_text_file("CREDITS", bkg_title, SCROLL_SPEED_CREDITS);
 330                   Menu::set_current(main_menu);
 331                   break;
 332                 case MNID_QUITMAINMENU:
 333                   Menu::set_current(0);
 334                   break;
 335                 }
 336             }
 337           else if(menu == options_menu)
 338             {
 339               process_options_menu();
 340             }
 341           else if(menu == load_game_menu)
 342             {
 343               if(event.key.keysym.sym == SDLK_DELETE)
 344                 {
 345                 int slot = menu->get_active_item_id();
 346                 char str[1024];
 347                 sprintf(str,"Are you sure you want to delete slot %d?", slot);
 348
 349                 draw_background();
 350
 351                 if(confirm_dialog(str))
 352                   {
 353                   sprintf(str,"%s/slot%d.stsg", st_save_dir, slot);
 354                   printf("Removing: %s\n",str);
 355                   remove(str);
 356                   }
 357
 358                 update_load_save_game_menu(load_game_menu);
 359                 update_time = st_get_ticks();
 360                 }
 361               else if (process_load_game_menu())
 362                 {
 363                   // FIXME: shouldn't be needed if GameSession doesn't relay on global variables
 364                   // reset tux
 365                   scroll_x = 0;
 366                   //titletux.level_begin();
 367                   update_time = st_get_ticks();
 368                 }
 369             }
 370           else if(menu == contrib_menu)
 371             {
 372               check_contrib_menu();
 373             }
 374           else if (menu == contrib_subset_menu)
 375             {
 376               check_contrib_subset_menu();
 377             }
 378         }
 379
 380       mouse_cursor->draw();
 381
 382       flipscreen();
 383
 384       /* Set the time of the last update and the time of the current update */
 385       last_update_time = update_time;
 386       update_time = st_get_ticks();
 387
 388       /* Pause: */
 389       frame++;
 390       SDL_Delay(25);
 391     }
 392   /* Free surfaces: */
 393
 394   free_contrib_menu();
 395   delete bkg_title;
 396   delete logo;
 397   delete img_choose_subset;
 398 }
 399
 400 // EOF //
 401