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