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