src/leveleditor.c

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