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