src/leveleditor.c

   1
   2 /***************************************************************************
   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 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  ***************************************************************************/
  10
  11 /*  December 28, 2003 - February 1st, 2004 */
  12
  13 /* leveleditor.c - A built-in level editor for SuperTux
  14  by Ricardo Cruz <rick2@aeiou.pt>                      */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20 #include <unistd.h>
  21 #include <SDL.h>
  22 #include <SDL_image.h>
  23 #include "leveleditor.h"
  24
  25 #include "screen.h"
  26 #include "defines.h"
  27 #include "globals.h"
  28 #include "setup.h"
  29 #include "menu.h"
  30 #include "level.h"
  31 #include "badguy.h"
  32 #include "scene.h"
  33 #include "button.h"
  34
  35 /* definitions to aid development */
  36 #define DONE_LEVELEDITOR 1
  37 #define DONE_QUIT        2
  38 #define DONE_CHANGELEVEL 3
  39
  40 /* definitions that affect gameplay */
  41 #define KEY_CURSOR_SPEED 32
  42 #define KEY_CURSOR_FASTSPEED 64
  43
  44 /* when pagedown/up pressed speed:*/
  45 #define PAGE_CURSOR_SPEED 13*32
  46
  47 #define MOUSE_LEFT_MARGIN 80
  48 #define MOUSE_RIGHT_MARGIN (560-32)
  49 /* right_margin should noticed that the cursor is 32 pixels,
  50    so it should subtract that value */
  51 #define MOUSE_POS_SPEED 20
  52
  53 /* look */
  54 #define SELECT_W 2 // size of the selections lines
  55 #define SELECT_CLR 0, 255, 0, 255  // lines color (R, G, B, A)
  56
  57 /* gameloop funcs declerations */
  58
  59 void loadshared(void);
  60 void unloadshared(void);
  61
  62 /* own declerations */
  63 /* crutial ones (main loop) */
  64 int le_init();
  65 void le_quit();
  66 void le_drawlevel();
  67 void le_drawinterface();
  68 void le_checkevents();
  69 void le_change(float x, float y, unsigned char c);
  70 void le_testlevel();
  71 void le_showhelp();
  72 void le_set_defaults(void);
  73 void le_activate_bad_guys(void);
  74 void le_new_subset(char *subset_name);
  75
  76 void le_highlight_selection();
  77 void apply_level_settings_menu();
  78
  79 /* leveleditor internals */
  80 static char **level_subsets;
  81 static int subsets_num;
  82 static int le_level_changed;  /* if changes, ask for saving, when quiting*/
  83 static int pos_x, cursor_x, cursor_y, cursor_tile, fire;
  84 static int le_level;
  85 static st_level* le_current_level;
  86 static st_subset le_level_subset;
  87 static int le_show_grid;
  88 static int le_frame;
  89 static texture_type le_selection;
  90 static int done;
  91 static char le_current_tile;
  92 static int le_mouse_pressed;
  93 static button_type le_save_level_bt;
  94 static button_type le_test_level_bt;
  95 static button_type le_next_level_bt;
  96 static button_type le_previous_level_bt;
  97 static button_type le_move_right_bt;
  98 static button_type le_move_left_bt;
  99 static button_type le_rubber_bt;
 100 static button_type le_select_mode_one_bt;
 101 static button_type le_select_mode_two_bt;
 102 static button_type le_bad_bsod_bt;
 103 static button_type le_settings_bt;
 104 static button_panel_type le_bt_panel;
 105 static menu_type leveleditor_menu;
 106 static menu_type subset_load_menu;
 107 static menu_type subset_new_menu;
 108 static menu_type subset_settings_menu;
 109 static menu_type level_settings_menu;
 110
 111 static square selection;
 112 static int le_selection_mode;
 113 static SDL_Event event;
 114
 115 void le_activate_bad_guys(void)
 116 {
 117   int x,y;
 118
 119   /* Activate bad guys: */
 120
 121   /* as oposed to the gameloop.c func, this one doesn't remove
 122   the badguys from tiles                                    */
 123
 124   for (y = 0; y < 15; ++y)
 125     for (x = 0; x < le_current_level->width; ++x)
 126       if (le_current_level->tiles[y][x] >= '0' && le_current_level->tiles[y][x] <= '9')
 127         add_bad_guy(x * 32, y * 32, le_current_level->tiles[y][x] - '0');
 128 }
 129
 130 void le_set_defaults()
 131 {
 132   if(le_current_level != NULL)
 133     {
 134       /* Set defaults: */
 135
 136       if(le_current_level->time_left == 0)
 137         le_current_level->time_left = 255;
 138     }
 139 }
 140
 141 /* FIXME: Needs to be implemented. It should ask the user for the level(file)name and then let him create a new level based on this. */
 142 void newlevel()
 143 {}
 144
 145 /* FIXME: It should let select the user a level, which is in the leveldirectory and then load it. */
 146 void selectlevel()
 147 {}
 148
 149 int leveleditor(int levelnb)
 150 {
 151   int last_time, now_time, i;
 152
 153   le_level = levelnb;
 154   if(le_init() != 0)
 155     return 1;
 156
 157   /* Clear screen: */
 158
 159   clearscreen(0, 0, 0);
 160   updatescreen();
 161
 162   while (SDL_PollEvent(&event))
 163   {}
 164
 165   while(YES)
 166     {
 167       last_time = SDL_GetTicks();
 168       le_frame++;
 169
 170       le_checkevents();
 171
 172       if(le_current_level != NULL)
 173         {
 174           /* making events results to be in order */
 175           if(pos_x < 0)
 176             pos_x = 0;
 177           if(pos_x > (le_current_level->width * 32) - screen->w)
 178             pos_x = (le_current_level->width * 32) - screen->w;
 179
 180           /* draw the level */
 181           le_drawlevel();
 182         }
 183       else
 184         clearscreen(0, 0, 0);
 185
 186       /* draw editor interface */
 187       le_drawinterface();
 188
 189       if(show_menu)
 190         {
 191           menu_process_current();
 192           if(current_menu == &leveleditor_menu)
 193             {
 194               switch (menu_check(&leveleditor_menu))
 195                 {
 196                 case 2:
 197                   show_menu = NO;
 198                   break;
 199                 case 7:
 200                   done = DONE_LEVELEDITOR;
 201                   break;
 202                 }
 203             }
 204           else if(current_menu == &level_settings_menu)
 205             {
 206               switch (menu_check(&level_settings_menu))
 207                 {
 208                 case 0:
 209                   break;
 210                 case 1:
 211                   show_menu = YES;
 212                   break;
 213                 case 4:
 214                   break;
 215                 case 13:
 216                   apply_level_settings_menu();
 217                   break;
 218                 }
 219             }
 220           else if(current_menu == &subset_load_menu)
 221             {
 222               switch (i = menu_check(&subset_load_menu))
 223                 {
 224                 case 0:
 225                   break;
 226                 default:
 227                   if(i != -1)
 228                     {
 229                       subset_load(&le_level_subset,level_subsets[i-2]);
 230                       leveleditor_menu.item[3].kind = MN_GOTO;
 231                       menu_item_change_input(&subset_settings_menu.item[2],le_level_subset.title);
 232                       menu_item_change_input(&subset_settings_menu.item[3],le_level_subset.description);
 233                       le_level = 1;
 234                       arrays_init();
 235                       loadshared();
 236                       le_current_level = (st_level*) malloc(sizeof(st_level));
 237                       if(level_load(le_current_level, le_level_subset.name, le_level) != 0)
 238                         {
 239                           le_quit();
 240                           return 1;
 241                         }
 242                       le_set_defaults();
 243                       level_load_gfx(le_current_level);
 244                       le_activate_bad_guys();
 245                       show_menu = YES;
 246                     }
 247                   break;
 248                 }
 249             }
 250           else if(current_menu == &subset_new_menu)
 251             {
 252               if(subset_new_menu.item[2].input[0] == '\0')
 253                 subset_new_menu.item[3].kind = MN_DEACTIVE;
 254               else
 255                 {
 256                   subset_new_menu.item[3].kind = MN_ACTION;
 257
 258                   switch (i = menu_check(&subset_new_menu))
 259                     {
 260                     case 3:
 261                       le_new_subset(subset_new_menu.item[2].input);
 262                       break;
 263                     }
 264                 }
 265             }
 266         }
 267
 268       if(done)
 269         {
 270           le_quit();
 271           return 0;
 272         }
 273
 274       if(done == DONE_QUIT)
 275         {
 276           le_quit();
 277           return 1;
 278         }
 279
 280       SDL_Delay(25);
 281       now_time = SDL_GetTicks();
 282       if (now_time < last_time + FPS)
 283         SDL_Delay(last_time + FPS - now_time);  /* delay some time */
 284
 285       flipscreen();
 286     }
 287
 288   return done;
 289 }
 290
 291 void le_default_level(st_level* plevel)
 292 {
 293   int i,y;
 294   strcpy(plevel->name,"UnNamed");
 295   strcpy(plevel->theme,"antarctica");
 296   strcpy(plevel->song_title,"Mortimers_chipdisko.mod");
 297   strcpy(plevel->bkgd_image,"arctis.png");
 298   plevel->width = 21;
 299   plevel->time_left = 100;
 300   plevel->gravity = 10.;
 301   plevel->bkgd_red = 0;
 302   plevel->bkgd_green = 0;
 303   plevel->bkgd_blue = 0;
 304
 305   for(i = 0; i < 15; ++i)
 306     {
 307       plevel->tiles[i] = (unsigned char*) malloc((plevel->width+1)*sizeof(unsigned char));
 308       plevel->tiles[i][plevel->width] = (unsigned char) '\0';
 309       for(y = 0; y < plevel->width; ++y)
 310         plevel->tiles[i][y] = (unsigned char) '.';
 311       plevel->tiles[i][plevel->width] = (unsigned char) '\0';
 312     }
 313 }
 314
 315 void le_new_subset(char *subset_name)
 316 {
 317   st_level new_lev;
 318   st_subset new_subset;
 319   new_subset.name = (char*) malloc((strlen(subset_name)+1)*sizeof(char));
 320   strcpy(new_subset.name,subset_name);
 321   new_subset.title = (char*) malloc((strlen("Unknown Title")+1)*sizeof(char));
 322   strcpy(new_subset.title,"Unknown Title");
 323   new_subset.description = (char*) malloc((strlen("No description so far.")+1)*sizeof(char));
 324   strcpy(new_subset.description,"No description so far.");
 325   subset_save(&new_subset);
 326   le_default_level(&new_lev);
 327   level_save(&new_lev,subset_name,1);
 328 }
 329
 330 int le_init()
 331 {
 332   int i;
 333   char str[80];
 334   level_subsets = NULL;
 335   level_subsets = dsubdirs("/levels", "info", &subsets_num);
 336
 337   le_show_grid = YES;
 338
 339   /*  level_changed = NO;*/
 340   fire = DOWN;
 341   done = 0;
 342   le_frame = 0; /* support for frames in some tiles, like waves and bad guys */
 343   le_level_changed = NO;
 344
 345   /*
 346     subset_load(&le_level_subset,"default");
 347     arrays_init();
 348     loadshared();
 349     le_set_defaults();
 350
 351
 352     if(level_load(&le_current_level, le_level_subset.name, le_level) != 0)
 353       {
 354         le_quit();
 355         return 1;
 356       }
 357     if(le_current_level.time_left == 0)
 358       le_current_level.time_left = 255;
 359
 360     level_load_gfx(&le_current_level);
 361       le_activate_bad_guys();
 362     */
 363   le_current_level = NULL;
 364
 365   le_current_tile = '.';
 366   le_mouse_pressed = NO;
 367
 368   texture_load(&le_selection,DATA_PREFIX "/images/leveleditor/select.png", USE_ALPHA);
 369
 370   /* Load buttons */
 371   button_load(&le_save_level_bt,"/images/icons/save.png","Save level", SDLK_F6,screen->w-64,32);
 372   button_load(&le_next_level_bt,"/images/icons/up.png","Next level", SDLK_PAGEUP,screen->w-64,0);
 373   button_load(&le_previous_level_bt,"/images/icons/down.png","Previous level",SDLK_PAGEDOWN,screen->w-32,0);
 374   button_load(&le_rubber_bt,"/images/icons/rubber.png","Rubber",SDLK_DELETE,screen->w-32,48);
 375   button_load(&le_select_mode_one_bt,"/images/icons/select-mode1.png","Select single tile",SDLK_F3,screen->w-64,48);
 376   button_load(&le_select_mode_two_bt,"/images/icons/select-mode2.png","Select multiple tiles",SDLK_F3,screen->w-64,64);
 377   button_load(&le_test_level_bt,"/images/icons/test-level.png","Test level",SDLK_F4,screen->w-64,screen->h - 64);
 378   button_load(&le_settings_bt,"/images/icons/settings.png","Level settings",SDLK_F5,screen->w-32,screen->h - 64);
 379   button_load(&le_move_left_bt,"/images/icons/left.png","Move left",SDLK_LEFT,0,0);
 380   button_load(&le_move_right_bt,"/images/icons/right.png","Move right",SDLK_RIGHT,screen->w-80,0);
 381   button_panel_init(&le_bt_panel, screen->w - 64,82, 64, 334);
 382
 383   menu_init(&leveleditor_menu);
 384   menu_additem(&leveleditor_menu,menu_item_create(MN_LABEL,"Level Editor Menu",0,0));
 385   menu_additem(&leveleditor_menu,menu_item_create(MN_HL,"",0,0));
 386   menu_additem(&leveleditor_menu,menu_item_create(MN_ACTION,"Return To Level Editor",0,0));
 387   menu_additem(&leveleditor_menu,menu_item_create(MN_DEACTIVE,"Level Subset Settings",0,&subset_settings_menu));
 388   menu_additem(&leveleditor_menu,menu_item_create(MN_GOTO,"Load Level Subset",0,&subset_load_menu));
 389   menu_additem(&leveleditor_menu,menu_item_create(MN_GOTO,"New Level Subset",0,&subset_new_menu));
 390   menu_additem(&leveleditor_menu,menu_item_create(MN_HL,"",0,0));
 391   menu_additem(&leveleditor_menu,menu_item_create(MN_ACTION,"Quit Level Editor",0,0));
 392
 393   menu_reset();
 394   menu_set_current(&leveleditor_menu);
 395   show_menu = YES;
 396
 397   menu_init(&subset_load_menu);
 398   menu_additem(&subset_load_menu,menu_item_create(MN_LABEL,"Load Level Subset",0,0));
 399   menu_additem(&subset_load_menu,menu_item_create(MN_HL,"",0,0));
 400   for(i = 0; i < subsets_num; ++i)
 401     {
 402       menu_additem(&subset_load_menu,menu_item_create(MN_ACTION,level_subsets[i],0,0));
 403     }
 404   menu_additem(&subset_load_menu,menu_item_create(MN_HL,"",0,0));
 405   menu_additem(&subset_load_menu,menu_item_create(MN_BACK,"Back",0,0));
 406
 407   menu_init(&subset_new_menu);
 408   menu_additem(&subset_new_menu,menu_item_create(MN_LABEL,"New Level Subset",0,0));
 409   menu_additem(&subset_new_menu,menu_item_create(MN_HL,"",0,0));
 410   menu_additem(&subset_new_menu,menu_item_create(MN_TEXTFIELD,"Enter Name",0,0));
 411   menu_additem(&subset_new_menu,menu_item_create(MN_ACTION,"Create",0,0));
 412   menu_additem(&subset_new_menu,menu_item_create(MN_HL,"",0,0));
 413   menu_additem(&subset_new_menu,menu_item_create(MN_BACK,"Back",0,0));
 414
 415   menu_init(&subset_settings_menu);
 416   menu_additem(&subset_settings_menu,menu_item_create(MN_LABEL,"Level Subset Settings",0,0));
 417   menu_additem(&subset_settings_menu,menu_item_create(MN_HL,"",0,0));
 418   menu_additem(&subset_settings_menu,menu_item_create(MN_TEXTFIELD,"Title",0,0));
 419   menu_additem(&subset_settings_menu,menu_item_create(MN_TEXTFIELD,"Description",0,0));
 420   menu_additem(&subset_settings_menu,menu_item_create(MN_HL,"",0,0));
 421   menu_additem(&subset_settings_menu,menu_item_create(MN_ACTION,"Apply Changes",0,0));
 422   menu_additem(&subset_settings_menu,menu_item_create(MN_HL,"",0,0));
 423   menu_additem(&subset_settings_menu,menu_item_create(MN_BACK,"Back",0,0));
 424
 425   menu_init(&level_settings_menu);
 426   level_settings_menu.arrange_left = YES;
 427   menu_additem(&level_settings_menu,menu_item_create(MN_LABEL,"Level Settings",0,0));
 428   menu_additem(&level_settings_menu,menu_item_create(MN_HL,"",0,0));
 429   menu_additem(&level_settings_menu,menu_item_create(MN_TEXTFIELD,"Name:",0,0));
 430   menu_additem(&level_settings_menu,menu_item_create(MN_STRINGSELECT,"Theme:",0,0));
 431   menu_additem(&level_settings_menu,menu_item_create(MN_STRINGSELECT,"Song:",0,0));
 432   menu_additem(&level_settings_menu,menu_item_create(MN_STRINGSELECT,"Background:",0,0));
 433   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Length: ",0,0));
 434   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Time:   ",0,0));
 435   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Gravity:",0,0));
 436   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Red:    ",0,0));
 437   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Green:  ",0,0));
 438   menu_additem(&level_settings_menu,menu_item_create(MN_NUMFIELD,"Blue:   ",0,0));
 439   menu_additem(&level_settings_menu,menu_item_create(MN_HL,"",0,0));
 440   menu_additem(&level_settings_menu,menu_item_create(MN_ACTION,"Apply Changes",0,0));
 441   /*menu_additem(&level_settings_menu,menu_item_create(MN_GOTO,"Load Game",0,&load_game_menu));
 442   menu_additem(&level_settings_menu,menu_item_create(MN_GOTO,"Options",0,&options_menu));
 443   menu_additem(&level_settings_menu,menu_item_create(MN_ACTION,"Level editor",0,0));
 444   menu_additem(&level_settings_menu,menu_item_create(MN_ACTION,"Quit",0,0));*/
 445
 446   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 447
 448   return 0;
 449 }
 450
 451 void update_level_settings_menu()
 452 {
 453   char str[80];
 454
 455   menu_item_change_input(&level_settings_menu.item[2], le_current_level->name);
 456   sprintf(str,"%d",le_current_level->width);
 457   menu_item_change_input(&level_settings_menu.item[6], str);
 458   sprintf(str,"%d",le_current_level->time_left);
 459   menu_item_change_input(&level_settings_menu.item[7], str);
 460   sprintf(str,"%2.0f",le_current_level->gravity);
 461   menu_item_change_input(&level_settings_menu.item[8], str);
 462   sprintf(str,"%d",le_current_level->bkgd_red);
 463   menu_item_change_input(&level_settings_menu.item[9], str);
 464   sprintf(str,"%d",le_current_level->bkgd_green);
 465   menu_item_change_input(&level_settings_menu.item[10], str);
 466   sprintf(str,"%d",le_current_level->bkgd_blue);
 467   menu_item_change_input(&level_settings_menu.item[11], str);
 468 }
 469
 470 void apply_level_settings_menu()
 471 {
 472   int i,y,j;
 473   strcpy(le_current_level->name,level_settings_menu.item[2].input);
 474
 475   i = le_current_level->width;
 476   le_current_level->width = atoi(level_settings_menu.item[6].input);
 477   if(le_current_level->width < i)
 478     {
 479       if(le_current_level->width < 21)
 480         le_current_level->width = 21;
 481       for(y = 0; y < 15; ++y)
 482         {
 483           le_current_level->tiles[y] = (unsigned char*) realloc(le_current_level->tiles[y],(le_current_level->width+1)*sizeof(unsigned char));
 484           le_current_level->tiles[y][le_current_level->width] = (unsigned char) '\0';
 485         }
 486     }
 487   else if(le_current_level->width > i)
 488     {
 489       for(y = 0; y < 15; ++y)
 490         {
 491           le_current_level->tiles[y] = (unsigned char*) realloc(le_current_level->tiles[y],(le_current_level->width+1)*sizeof(unsigned char));
 492           for(j = 0; j < le_current_level->width - i; ++j)
 493             le_current_level->tiles[y][i+j] = (unsigned char) '.';
 494           le_current_level->tiles[y][le_current_level->width] = (unsigned char) '\0';
 495         }
 496     }
 497   le_current_level->time_left = atoi(level_settings_menu.item[7].input);
 498   le_current_level->gravity = atof(level_settings_menu.item[8].input);
 499   le_current_level->bkgd_red = atoi(level_settings_menu.item[9].input);
 500   le_current_level->bkgd_green = atoi(level_settings_menu.item[10].input);
 501   le_current_level->bkgd_blue = atoi(level_settings_menu.item[11].input);
 502 }
 503
 504 void le_goto_level(int levelnb)
 505 {
 506   arrays_free();
 507   arrays_init();
 508
 509   level_free(le_current_level);
 510   if(level_load(le_current_level, le_level_subset.name, levelnb) != 0)
 511     {
 512       level_load(le_current_level, le_level_subset.name, le_level);
 513     }
 514   else
 515     {
 516       le_level = levelnb;
 517     }
 518
 519   le_set_defaults();
 520
 521   level_free_gfx();
 522   level_load_gfx(le_current_level);
 523
 524   le_activate_bad_guys();
 525 }
 526
 527 void le_quit(void)
 528 {
 529   /*if(level_changed == YES)
 530     if(askforsaving() == CANCEL)
 531       return;*/ //FIXME
 532
 533   SDL_EnableKeyRepeat(0, 0);    // disables key repeating
 534
 535   button_free(&le_test_level_bt);
 536   texture_free(&le_selection);
 537   menu_free(&leveleditor_menu);
 538
 539   if(le_current_level != NULL)
 540     {
 541       level_free_gfx();
 542       level_free(le_current_level);
 543       unloadshared();
 544       arrays_free();
 545     }
 546 }
 547
 548 void le_drawinterface()
 549 {
 550   int x,y;
 551   char str[80];
 552
 553   if(le_current_level != NULL)
 554     {
 555       /* draw a grid (if selected) */
 556       if(le_show_grid)
 557         {
 558           for(x = 0; x < 19; x++)
 559             fillrect(x*32 - ((int)pos_x % 32), 0, 1, screen->h, 225, 225, 225,255);
 560           for(y = 0; y < 15; y++)
 561             fillrect(0, y*32, screen->w - 32, 1, 225, 225, 225,255);
 562         }
 563     }
 564
 565   if(le_selection_mode == CURSOR)
 566     texture_draw(&le_selection, cursor_x - pos_x, cursor_y, NO_UPDATE);
 567   else if(le_selection_mode == SQUARE)
 568     {
 569       int w, h;
 570       le_highlight_selection();
 571       /* draw current selection */
 572       w = selection.x2 - selection.x1;
 573       h = selection.y2 - selection.y1;
 574       fillrect(selection.x1 - pos_x, selection.y1, w, SELECT_W, SELECT_CLR);
 575       fillrect(selection.x1 - pos_x + w, selection.y1, SELECT_W, h, SELECT_CLR);
 576       fillrect(selection.x1 - pos_x, selection.y1 + h, w, SELECT_W, SELECT_CLR);
 577       fillrect(selection.x1 - pos_x, selection.y1, SELECT_W, h, SELECT_CLR);
 578     }
 579
 580
 581   /* draw button bar */
 582   fillrect(screen->w - 64, 0, 64, screen->h, 50, 50, 50,255);
 583   drawshape(19 * 32, 14 * 32, le_current_tile);
 584
 585   if(le_current_level != NULL)
 586     {
 587       button_draw(&le_save_level_bt);
 588       button_draw(&le_test_level_bt);
 589       button_draw(&le_next_level_bt);
 590       button_draw(&le_previous_level_bt);
 591       button_draw(&le_rubber_bt);
 592       button_draw(&le_select_mode_one_bt);
 593       button_draw(&le_select_mode_two_bt);
 594       button_draw(&le_bad_bsod_bt);
 595       button_draw(&le_settings_bt);
 596       button_draw(&le_move_right_bt);
 597       button_draw(&le_move_left_bt);
 598       button_panel_draw(&le_bt_panel);
 599
 600       sprintf(str, "%d/%d", le_level,le_level_subset.levels);
 601       text_drawf(&white_text, str, -8, 16, A_RIGHT, A_NONE, 1, NO_UPDATE);
 602
 603       text_draw(&white_small_text, "F1 for Help", 10, 430, 1, NO_UPDATE);
 604     }
 605   else
 606     {
 607       if(show_menu == NO)
 608         text_draw(&white_small_text, "No Level Subset loaded - Press ESC and choose one in the menu", 10, 430, 1, NO_UPDATE);
 609       else
 610         text_draw(&white_small_text, "No Level Subset loaded", 10, 430, 1, NO_UPDATE);
 611     }
 612
 613 }
 614
 615 void le_drawlevel()
 616 {
 617   int y,x,i,s;
 618   static char str[LEVEL_NAME_MAX];
 619
 620   /* Draw the real background */
 621   if(le_current_level->bkgd_image[0] != '\0')
 622     {
 623       s = pos_x / 30;
 624       texture_draw_part(&img_bkgd,s,0,0,0,img_bkgd.w - s - 32, img_bkgd.h, NO_UPDATE);
 625       texture_draw_part(&img_bkgd,0,0,screen->w - s - 32 ,0,s,img_bkgd.h, NO_UPDATE);
 626     }
 627   else
 628     {
 629       clearscreen(le_current_level->bkgd_red, le_current_level->bkgd_green, le_current_level->bkgd_blue);
 630     }
 631
 632   /*       clearscreen(current_level.bkgd_red, current_level.bkgd_green, current_level.bkgd_blue); */
 633
 634   for (y = 0; y < 15; ++y)
 635     for (x = 0; x < 20; ++x)
 636       {
 637         drawshape(x * 32 - ((int)pos_x % 32), y * 32, le_current_level->tiles[y][x + (int)(pos_x / 32)]);
 638
 639         /* draw whats inside stuff when cursor is selecting those */
 640         /* (draw them all the time - is this the right behaviour?) */
 641         switch(le_current_level->tiles[y][x + (int)(pos_x/32)])
 642           {
 643           case 'B':
 644             texture_draw(&img_mints, x * 32 - ((int)pos_x % 32), y*32, NO_UPDATE);
 645             break;
 646           case '!':
 647             texture_draw(&img_golden_herring, x * 32 - ((int)pos_x % 32), y*32, NO_UPDATE);
 648             break;
 649           case 'x':
 650           case 'y':
 651           case 'A':
 652             texture_draw(&img_distro[(frame / 5) % 4], x * 32 - ((int)pos_x % 32), y*32, NO_UPDATE);
 653             break;
 654           default:
 655             break;
 656           }
 657       }
 658
 659   /* Draw the Bad guys: */
 660   for (i = 0; i < num_bad_guys; ++i)
 661     {
 662       if(bad_guys[i].base.alive == NO)
 663         continue;
 664       /* to support frames: img_bsod_left[(frame / 5) % 4] */
 665       if(bad_guys[i].kind == BAD_BSOD)
 666         texture_draw(&img_bsod_left[(le_frame / 5) % 4], bad_guys[i].base.x - pos_x, bad_guys[i].base.y, NO_UPDATE);
 667       else if(bad_guys[i].kind == BAD_LAPTOP)
 668         texture_draw(&img_laptop_left[(le_frame / 5) % 3], bad_guys[i].base.x - pos_x, bad_guys[i].base.y, NO_UPDATE);
 669       else if (bad_guys[i].kind == BAD_MONEY)
 670         texture_draw(&img_money_left[(le_frame / 5) % 2], bad_guys[i].base.x - pos_x, bad_guys[i].base.y, NO_UPDATE);
 671     }
 672
 673
 674   /* Draw the player: */
 675   /* for now, the position is fixed at (0, 240) */
 676   texture_draw(&tux_right[(frame / 5) % 3], 0 - pos_x, 240, NO_UPDATE);
 677 }
 678
 679 void le_checkevents()
 680 {
 681   SDLKey key;
 682   SDLMod keymod;
 683   int x,y;
 684
 685   keymod = SDL_GetModState();
 686
 687   while(SDL_PollEvent(&event))
 688     {
 689       /* testing SDL_KEYDOWN, SDL_KEYUP and SDL_QUIT events*/
 690       if(event.type == SDL_KEYDOWN || ((event.type == SDL_MOUSEBUTTONDOWN || SDL_MOUSEMOTION) && (event.motion.x > 0 && event.motion.x < screen->w - 64 &&
 691                                        event.motion.y > 0 && event.motion.y < screen->h)))
 692         {
 693
 694           switch(event.type)
 695             {
 696             case SDL_KEYDOWN:   // key pressed
 697               key = event.key.keysym.sym;
 698               if(show_menu)
 699                 {
 700                   menu_event(&event.key.keysym);
 701                   if(key == SDLK_ESCAPE)
 702                     {
 703                       show_menu = NO;
 704                       menu_set_current(&leveleditor_menu);
 705                     }
 706                   break;
 707                 }
 708               switch(key)
 709                 {
 710                 case SDLK_ESCAPE:
 711                   if(!show_menu)
 712                     show_menu = YES;
 713                   else
 714                     show_menu = NO;
 715                   break;
 716                 case SDLK_LEFT:
 717                   if(fire == DOWN)
 718                     cursor_x -= KEY_CURSOR_SPEED;
 719                   else
 720                     cursor_x -= KEY_CURSOR_FASTSPEED;
 721
 722                   if(cursor_x < pos_x + MOUSE_LEFT_MARGIN)
 723                     pos_x = cursor_x - MOUSE_LEFT_MARGIN;
 724
 725                   break;
 726                 case SDLK_RIGHT:
 727                   if(fire == DOWN)
 728                     cursor_x += KEY_CURSOR_SPEED;
 729                   else
 730                     cursor_x += KEY_CURSOR_FASTSPEED;
 731
 732                   if(cursor_x > pos_x + MOUSE_RIGHT_MARGIN-32)
 733                     pos_x = cursor_x - MOUSE_RIGHT_MARGIN+32;
 734
 735                   break;
 736                 case SDLK_UP:
 737                   if(fire == DOWN)
 738                     cursor_y -= KEY_CURSOR_SPEED;
 739                   else
 740                     cursor_y -= KEY_CURSOR_FASTSPEED;
 741
 742                   if(cursor_y < 0)
 743                     cursor_y = 0;
 744                   break;
 745                 case SDLK_DOWN:
 746                   if(fire == DOWN)
 747                     cursor_y += KEY_CURSOR_SPEED;
 748                   else
 749                     cursor_y += KEY_CURSOR_FASTSPEED;
 750
 751                   if(cursor_y > screen->h-32)
 752                     cursor_y = screen->h-32;
 753                   break;
 754                 case SDLK_LCTRL:
 755                   fire =UP;
 756                   break;
 757                 case SDLK_F1:
 758                   le_showhelp();
 759                   break;
 760                 case SDLK_HOME:
 761                   cursor_x = 0;
 762                   pos_x = cursor_x;
 763                   break;
 764                 case SDLK_END:
 765                   cursor_x = (le_current_level->width * 32) - 32;
 766                   pos_x = cursor_x;
 767                   break;
 768                 case SDLK_PAGEUP:
 769                   cursor_x -= PAGE_CURSOR_SPEED;
 770
 771                   if(cursor_x < pos_x + MOUSE_LEFT_MARGIN)
 772                     pos_x = cursor_x - MOUSE_LEFT_MARGIN;
 773
 774                   break;
 775                 case SDLK_PAGEDOWN:
 776                   cursor_x += PAGE_CURSOR_SPEED;
 777
 778                   if(cursor_x > pos_x + MOUSE_RIGHT_MARGIN-32)
 779                     pos_x = cursor_x - MOUSE_RIGHT_MARGIN+32;
 780
 781                   break;
 782                 case SDLK_F9:
 783                   le_show_grid = !le_show_grid;
 784                   break;
 785                 case SDLK_PERIOD:
 786                   le_change(cursor_x, cursor_y, '.');
 787                   break;
 788                 case SDLK_a:
 789                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 790                     le_current_tile = 'A';
 791                   else
 792                     le_current_tile = 'a';
 793                   break;
 794                 case SDLK_b:
 795                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 796                     le_change(cursor_x, cursor_y, 'B');
 797                   break;
 798                 case SDLK_c:
 799                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 800                     le_change(cursor_x, cursor_y, 'C');
 801                   else
 802                     le_change(cursor_x, cursor_y, 'c');
 803                   break;
 804                 case SDLK_d:
 805                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 806                     le_change(cursor_x, cursor_y, 'D');
 807                   else
 808                     le_change(cursor_x, cursor_y, 'd');
 809                   break;
 810                 case SDLK_e:
 811                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 812                     le_change(cursor_x, cursor_y, 'E');
 813                   else
 814                     le_change(cursor_x, cursor_y, 'e');
 815                   break;
 816                 case SDLK_f:
 817                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 818                     le_change(cursor_x, cursor_y, 'F');
 819                   else
 820                     le_change(cursor_x, cursor_y, 'f');
 821                   break;
 822                 case SDLK_g:
 823                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 824                     le_change(cursor_x, cursor_y, 'G');
 825                   else
 826                     le_change(cursor_x, cursor_y, 'g');
 827                   break;
 828                 case SDLK_h:
 829                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 830                     le_change(cursor_x, cursor_y, 'H');
 831                   else
 832                     le_change(cursor_x, cursor_y, 'h');
 833                   break;
 834                 case SDLK_i:
 835                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 836                     le_change(cursor_x, cursor_y, 'I');
 837                   else
 838                     le_change(cursor_x, cursor_y, 'i');
 839                   break;
 840                 case SDLK_j:
 841                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 842                     le_change(cursor_x, cursor_y, 'J');
 843                   else
 844                     le_change(cursor_x, cursor_y, 'j');
 845                   break;
 846                 case SDLK_x:
 847                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 848                     le_change(cursor_x, cursor_y, 'X');
 849                   else
 850                     le_change(cursor_x, cursor_y, 'x');
 851                   break;
 852                 case SDLK_y:
 853                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 854                     le_change(cursor_x, cursor_y, 'Y');
 855                   else
 856                     le_change(cursor_x, cursor_y, 'y');
 857                   break;
 858                 case SDLK_LEFTBRACKET:
 859                   le_change(cursor_x, cursor_y, '[');
 860                   break;
 861                 case SDLK_RIGHTBRACKET:
 862                   le_change(cursor_x, cursor_y, ']');
 863                   break;
 864                 case SDLK_HASH:
 865                 case SDLK_3:
 866                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 867                     le_change(cursor_x, cursor_y, '#');
 868                   break;
 869                 case SDLK_DOLLAR:
 870                 case SDLK_4:
 871                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 872                     le_change(cursor_x, cursor_y, '$');
 873                   break;
 874                 case SDLK_BACKSLASH:
 875                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 876                     le_change(cursor_x, cursor_y, '|');
 877                   else
 878                     le_change(cursor_x, cursor_y, '\\');
 879                   break;
 880                 case SDLK_CARET:
 881                   le_change(cursor_x, cursor_y, '^');
 882                   break;
 883                 case SDLK_AMPERSAND:
 884                 case SDLK_6:
 885                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 886                     le_change(cursor_x, cursor_y, '&');
 887                   break;
 888                 case SDLK_EQUALS:
 889                 case SDLK_0:
 890                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 891                     le_change(cursor_x, cursor_y, '=');
 892                   else          /* let's add a bad guy */
 893                     le_change(cursor_x, cursor_y, '0');
 894                   break;
 895                 case SDLK_1:
 896                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 897                     le_change(cursor_x, cursor_y, '!');
 898                   else          /* let's add a bad guy */
 899                     le_change(cursor_x, cursor_y, '1');
 900                   break;
 901                 case SDLK_2:
 902                   le_change(cursor_x, cursor_y, '2');
 903                   break;
 904                 case SDLK_PLUS:
 905                   if(keymod == KMOD_LSHIFT || keymod == KMOD_RSHIFT || keymod == KMOD_CAPS)
 906                     le_change(cursor_x, cursor_y, '*');
 907                   break;
 908                 default:
 909                   break;
 910                 }
 911               break;
 912             case SDL_KEYUP:     /* key released */
 913               switch(event.key.keysym.sym)
 914                 {
 915                 case SDLK_LCTRL:
 916                   fire = DOWN;
 917                   break;
 918                 default:
 919                   break;
 920                 }
 921               break;
 922             case SDL_MOUSEBUTTONDOWN:
 923               if(event.button.button == SDL_BUTTON_LEFT)
 924                 {
 925                   le_mouse_pressed = YES;
 926
 927                   selection.x1 = event.motion.x + pos_x;
 928                   selection.y1 = event.motion.y;
 929                   selection.x2 = event.motion.x + pos_x;
 930                   selection.y2 = event.motion.y;
 931                 }
 932               break;
 933             case SDL_MOUSEBUTTONUP:
 934               if(event.button.button == SDL_BUTTON_LEFT)
 935                 {
 936                   le_mouse_pressed = NO;
 937                 }
 938               break;
 939             case SDL_MOUSEMOTION:
 940               if(!show_menu)
 941                 {
 942                   x = event.motion.x;
 943                   y = event.motion.y;
 944
 945                   cursor_x = ((int)(pos_x + x) / 32) * 32;
 946                   cursor_y = ((int) y / 32) * 32;
 947
 948                   if(le_mouse_pressed == YES)
 949                     {
 950                       selection.x2 = x + pos_x;
 951                       selection.y2 = y;
 952                     }
 953                 }
 954               break;
 955             case SDL_QUIT:      // window closed
 956               done = DONE_QUIT;
 957               break;
 958             default:
 959               break;
 960             }
 961         }
 962
 963
 964     }
 965
 966   if(le_current_level != NULL)
 967     {
 968       if(event.type == SDL_KEYDOWN || event.type == SDL_KEYUP || ((event.type == SDL_MOUSEBUTTONDOWN || SDL_MOUSEMOTION) && (event.motion.x > screen->w-64 && event.motion.x < screen->w &&
 969           event.motion.y > 0 && event.motion.y < screen->h)))
 970         {
 971           /* Check for button events */
 972           button_event(&le_test_level_bt,&event);
 973           if(button_get_state(&le_test_level_bt) == BN_CLICKED)
 974             le_testlevel();
 975           button_event(&le_save_level_bt,&event);
 976           if(button_get_state(&le_save_level_bt) == BN_CLICKED)
 977             level_save(le_current_level,le_level_subset.name,le_level);
 978           button_event(&le_next_level_bt,&event);
 979           if(button_get_state(&le_next_level_bt) == BN_CLICKED)
 980             {
 981               if(le_level < le_level_subset.levels)
 982                 le_goto_level(++le_level);
 983             }
 984           button_event(&le_previous_level_bt,&event);
 985           if(button_get_state(&le_previous_level_bt) == BN_CLICKED)
 986             {
 987               if(le_level > 1)
 988                 le_goto_level(--le_level);
 989             }
 990           button_event(&le_rubber_bt,&event);
 991           if(button_get_state(&le_rubber_bt) == BN_CLICKED)
 992             le_current_tile = '.';
 993           button_event(&le_select_mode_one_bt,&event);
 994           if(button_get_state(&le_select_mode_one_bt) == BN_CLICKED)
 995             le_selection_mode = CURSOR;
 996           button_event(&le_select_mode_two_bt,&event);
 997           if(button_get_state(&le_select_mode_two_bt) == BN_CLICKED)
 998             le_selection_mode = SQUARE;
 999           button_event(&le_bad_bsod_bt,&event);
1000           if(button_get_state(&le_bad_bsod_bt) == BN_CLICKED)
1001             le_current_tile = '0';
1002           button_event(&le_settings_bt,&event);
1003           if(button_get_state(&le_settings_bt) == BN_CLICKED)
1004             {
1005               if(show_menu == NO)
1006                 {
1007                   update_level_settings_menu();
1008                   menu_set_current(&level_settings_menu);
1009                   show_menu = YES;
1010                 }
1011               else
1012                 {
1013                   menu_set_current(&leveleditor_menu);
1014                   show_menu = NO;
1015                 }
1016             }
1017         }
1018     }
1019
1020   button_event(&le_move_left_bt,&event);
1021   if(button_get_state(&le_move_left_bt) == BN_PRESSED)
1022     {
1023       pos_x -= 192;
1024     }
1025   else if(button_get_state(&le_move_left_bt) == BN_HOVER)
1026     {
1027       pos_x -= 96;
1028     }
1029   button_event(&le_move_right_bt,&event);
1030   if(button_get_state(&le_move_right_bt) == BN_PRESSED)
1031     {
1032       pos_x += 192;
1033     }
1034   else if(button_get_state(&le_move_right_bt) == BN_HOVER)
1035     {
1036       pos_x += 96;
1037     }
1038
1039   if(le_mouse_pressed)
1040     {
1041       le_change(cursor_x, cursor_y, le_current_tile);
1042     }
1043
1044 }
1045
1046 void le_highlight_selection()
1047 {
1048   int x,y,i;
1049   int x1, x2, y1, y2;
1050
1051   if(selection.x1 < selection.x2)
1052     {
1053       x1 = selection.x1;
1054       x2 = selection.x2;
1055     }
1056   else
1057     {
1058       x1 = selection.x2;
1059       x2 = selection.x1;
1060     }
1061   if(selection.y1 < selection.y2)
1062     {
1063       y1 = selection.y1;
1064       y2 = selection.y2;
1065     }
1066   else
1067     {
1068       y1 = selection.y2;
1069       y2 = selection.y1;
1070     }
1071
1072   x1 /= 32;
1073   x2 /= 32;
1074   y1 /= 32;
1075   y2 /= 32;
1076
1077   fillrect(x1*32-pos_x, y1*32,32* (x2 - x1 + 1),32 * (y2 - y1 + 1),173,234,177,103);
1078 }
1079
1080 void le_change(float x, float y, unsigned char c)
1081 {
1082   if(le_current_level != NULL)
1083     {
1084       int xx,yy,i;
1085       int x1, x2, y1, y2;
1086
1087       /*  level_changed = YES; */
1088
1089       switch(le_selection_mode)
1090         {
1091         case CURSOR:
1092           level_change(le_current_level,x,y,c);
1093
1094           yy = ((int)y / 32);
1095           xx = ((int)x / 32);
1096
1097           /* if there is a bad guy over there, remove it */
1098           for(i = 0; i < num_bad_guys; ++i)
1099             if (bad_guys[i].base.alive)
1100               if(xx == bad_guys[i].base.x/32 && yy == bad_guys[i].base.y/32)
1101                 bad_guys[i].base.alive = NO;
1102
1103           if(c == '0')  /* if it's a bad guy */
1104             add_bad_guy(xx*32, yy*32, BAD_BSOD);
1105           else if(c == '1')
1106             add_bad_guy(xx*32, yy*32, BAD_LAPTOP);
1107           else if(c == '2')
1108             add_bad_guy(xx*32, yy*32, BAD_MONEY);
1109
1110           break;
1111         case SQUARE:
1112           if(selection.x1 < selection.x2)
1113             {
1114               x1 = selection.x1;
1115               x2 = selection.x2;
1116             }
1117           else
1118             {
1119               x1 = selection.x2;
1120               x2 = selection.x1;
1121             }
1122           if(selection.y1 < selection.y2)
1123             {
1124               y1 = selection.y1;
1125               y2 = selection.y2;
1126             }
1127           else
1128             {
1129               y1 = selection.y2;
1130               y2 = selection.y1;
1131             }
1132
1133           x1 /= 32;
1134           x2 /= 32;
1135           y1 /= 32;
1136           y2 /= 32;
1137
1138           /* if there is a bad guy over there, remove it */
1139           for(i = 0; i < num_bad_guys; ++i)
1140             if(bad_guys[i].base.alive)
1141               if(bad_guys[i].base.x/32 >= x1 && bad_guys[i].base.x/32 <= x2
1142                   && bad_guys[i].base.y/32 >= y1 && bad_guys[i].base.y/32 <= y2)
1143                 bad_guys[i].base.alive = NO;
1144
1145           for(xx = x1; xx <= x2; xx++)
1146             for(yy = y1; yy <= y2; yy++)
1147               {
1148                 level_change(le_current_level, xx*32, yy*32, c);
1149
1150                 if(c == '0')  // if it's a bad guy
1151                   add_bad_guy(xx*32, yy*32, BAD_BSOD);
1152                 else if(c == '1')
1153                   add_bad_guy(xx*32, yy*32, BAD_LAPTOP);
1154                 else if(c == '2')
1155                   add_bad_guy(xx*32, yy*32, BAD_MONEY);
1156               }
1157           break;
1158         default:
1159           break;
1160         }
1161     }
1162 }
1163
1164 void le_testlevel()
1165 {
1166   level_save(le_current_level,"test",le_level);
1167   gameloop("test",le_level, ST_GL_TEST);
1168   menu_set_current(&leveleditor_menu);
1169   arrays_init();
1170   level_load_gfx(le_current_level);
1171   loadshared();
1172   le_activate_bad_guys();
1173 }
1174
1175 void le_showhelp()
1176 {
1177   SDL_Event event;
1178   int i, done;
1179   char *text[] = {
1180                    "X/x - Brick0",
1181                    "Y/y - Brick1",
1182                    "A/B/! - Box full",
1183                    "a - Box empty",
1184                    "C-F - Cloud0",
1185                    "c-f - Cloud1",
1186                    "G-J - Bkgd0",
1187                    "g-j - Bkgd1",
1188                    "# - Solid0",
1189                    "[ - Solid1",
1190                    "= - Solid2",
1191                    "] - Solid3",
1192                    "$ - Distro",
1193                    "^ - Waves",
1194                    "* - Poletop",
1195                    "| - Pole",
1196                    "\\ - Flag",
1197                    "& - Water",
1198                    "0-2 - BadGuys",
1199                    "./Del - Remove tile",
1200                    "F9 - Show/Hide Grid",
1201                    "F3 - Change Selection Mode",
1202                    "Esc - Menu"};
1203
1204
1205   text_drawf(&blue_text, "- Help -", 0, 30, A_HMIDDLE, A_TOP, 2, NO_UPDATE);
1206   text_draw(&gold_text, "Keys:", 80, 60, 1, NO_UPDATE);
1207
1208   for(i = 0; i < sizeof(text)/sizeof(char *); i++)
1209     text_draw(&white_text, text[i], 40, 90+(i*16), 1, NO_UPDATE);
1210
1211   text_drawf(&gold_text, "Press Any Key to Continue", 0, 460, A_HMIDDLE, A_TOP, 1, NO_UPDATE);
1212
1213   flipscreen();
1214
1215   done = 0;
1216
1217   while(done == 0)
1218     while(SDL_PollEvent(&event))
1219       switch(event.type)
1220         {
1221         case SDL_MOUSEBUTTONDOWN:               // mouse pressed
1222         case SDL_KEYDOWN:               // key pressed
1223           done = 1;
1224           break;
1225         default:
1226           break;
1227         }
1228 }