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