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