src/editor.c

   1 /***********************************************************
   2 *  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
   3 *----------------------------------------------------------*
   4 *  ©1995 Artsoft Development                               *
   5 *        Holger Schemel                                    *
   6 *        33659 Bielefeld-Senne                             *
   7 *        Telefon: (0521) 493245                            *
   8 *        eMail: aeglos@valinor.owl.de                      *
   9 *               aeglos@uni-paderborn.de                    *
  10 *               q99492@pbhrzx.uni-paderborn.de             *
  11 *----------------------------------------------------------*
  12 *  editor.c                                                *
  13 ***********************************************************/
  14
  15 #include "editor.h"
  16 #include "screens.h"
  17 #include "tools.h"
  18 #include "misc.h"
  19 #include "buttons.h"
  20 #include "files.h"
  21
  22 static int level_xpos,level_ypos;
  23 static BOOL edit_mode;
  24 static BOOL name_typing;
  25 static int new_element1 = EL_MAUERWERK;
  26 static int new_element2 = EL_LEERRAUM;
  27 static int new_element3 = EL_ERDREICH;
  28
  29 int element_shift;
  30 int editor_element[] =
  31 {
  32   EL_SPIELFIGUR,
  33   EL_LEERRAUM,
  34   EL_ERDREICH,
  35   EL_FELSBROCKEN,
  36
  37   EL_BETON,
  38   EL_MAUERWERK,
  39   EL_FELSBODEN,
  40   EL_SIEB_LEER,
  41
  42   EL_EDELSTEIN,
  43   EL_DIAMANT,
  44   EL_KOKOSNUSS,
  45   EL_BOMBE,
  46
  47   EL_MORAST_LEER,
  48   EL_MORAST_VOLL,
  49   EL_AUSGANG_ZU,
  50   EL_AUSGANG_AUF,
  51
  52   EL_KAEFER,
  53   EL_FLIEGER,
  54   EL_MAMPFER,
  55   EL_ZOMBIE,
  56
  57   EL_PACMAN,
  58   EL_DYNAMIT_AUS,
  59   EL_DYNAMIT,
  60   EL_ABLENK_AUS,
  61
  62   EL_BADEWANNE1,
  63   EL_SALZSAEURE,
  64   EL_BADEWANNE2,
  65   EL_BADEWANNE,
  66
  67   EL_BADEWANNE3,
  68   EL_BADEWANNE4,
  69   EL_BADEWANNE5,
  70   EL_UNSICHTBAR,
  71
  72   EL_TROPFEN,
  73   EL_AMOEBE_TOT,
  74   EL_AMOEBE_NASS,
  75   EL_AMOEBE_NORM,
  76
  77   EL_AMOEBE_VOLL,
  78
  79 /*
  80   EL_LIFE,
  81 */
  82   EL_LIFE_ASYNC,
  83
  84   EL_ERZ_EDEL,
  85   EL_ERZ_DIAM,
  86
  87   EL_ZEIT_VOLL,
  88   EL_ZEIT_LEER,
  89   EL_BIRNE_AUS,
  90   EL_BIRNE_EIN,
  91
  92   EL_SCHLUESSEL1,
  93   EL_SCHLUESSEL2,
  94   EL_SCHLUESSEL3,
  95   EL_SCHLUESSEL4,
  96
  97   EL_PFORTE1,
  98   EL_PFORTE2,
  99   EL_PFORTE3,
 100   EL_PFORTE4,
 101
 102   EL_PFORTE1X,
 103   EL_PFORTE2X,
 104   EL_PFORTE3X,
 105   EL_PFORTE4X,
 106
 107   EL_KAEFER_R,
 108   EL_KAEFER_O,
 109   EL_KAEFER_L,
 110   EL_KAEFER_U,
 111
 112   EL_FLIEGER_R,
 113   EL_FLIEGER_O,
 114   EL_FLIEGER_L,
 115   EL_FLIEGER_U,
 116
 117   EL_PACMAN_R,
 118   EL_PACMAN_O,
 119   EL_PACMAN_L,
 120   EL_PACMAN_U,
 121
 122   EL_CHAR_AUSRUF,
 123   EL_CHAR_ZOLL,
 124   EL_CHAR_DOLLAR,
 125   EL_CHAR_PROZ,
 126
 127   EL_CHAR_APOSTR,
 128   EL_CHAR_KLAMM1,
 129   EL_CHAR_KLAMM2,
 130   EL_CHAR_PLUS,
 131
 132   EL_CHAR_KOMMA,
 133   EL_CHAR_MINUS,
 134   EL_CHAR_PUNKT,
 135   EL_CHAR_SLASH,
 136
 137   EL_CHAR_0 + 0,
 138   EL_CHAR_0 + 1,
 139   EL_CHAR_0 + 2,
 140   EL_CHAR_0 + 3,
 141
 142   EL_CHAR_0 + 4,
 143   EL_CHAR_0 + 5,
 144   EL_CHAR_0 + 6,
 145   EL_CHAR_0 + 7,
 146
 147   EL_CHAR_0 + 8,
 148   EL_CHAR_0 + 9,
 149   EL_CHAR_DOPPEL,
 150   EL_CHAR_SEMIKL,
 151
 152   EL_CHAR_LT,
 153   EL_CHAR_GLEICH,
 154   EL_CHAR_GT,
 155   EL_CHAR_FRAGE,
 156
 157   EL_CHAR_AT,
 158   EL_CHAR_A + 0,
 159   EL_CHAR_A + 1,
 160   EL_CHAR_A + 2,
 161
 162   EL_CHAR_A + 3,
 163   EL_CHAR_A + 4,
 164   EL_CHAR_A + 5,
 165   EL_CHAR_A + 6,
 166
 167   EL_CHAR_A + 7,
 168   EL_CHAR_A + 8,
 169   EL_CHAR_A + 9,
 170   EL_CHAR_A + 10,
 171
 172   EL_CHAR_A + 11,
 173   EL_CHAR_A + 12,
 174   EL_CHAR_A + 13,
 175   EL_CHAR_A + 14,
 176
 177   EL_CHAR_A + 15,
 178   EL_CHAR_A + 16,
 179   EL_CHAR_A + 17,
 180   EL_CHAR_A + 18,
 181
 182   EL_CHAR_A + 19,
 183   EL_CHAR_A + 20,
 184   EL_CHAR_A + 21,
 185   EL_CHAR_A + 22,
 186
 187   EL_CHAR_A + 23,
 188   EL_CHAR_A + 24,
 189   EL_CHAR_A + 25,
 190   EL_CHAR_AE,
 191
 192   EL_CHAR_OE,
 193   EL_CHAR_UE,
 194   EL_CHAR_COPY
 195 };
 196 int elements_in_list = sizeof(editor_element)/sizeof(int);
 197
 198 void DrawLevelEd()
 199 {
 200   int i, graphic;
 201
 202   level_xpos=-1;
 203   level_ypos=-1;
 204   edit_mode = TRUE;
 205   name_typing = FALSE;
 206   element_shift = 0;
 207
 208   CloseDoor(DOOR_CLOSE_2);
 209
 210   DrawMiniLevel(level_xpos,level_ypos);
 211   FadeToFront();
 212
 213   XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 214             DOOR_GFX_PAGEX6,DOOR_GFX_PAGEY1,
 215             DXSIZE,DYSIZE,
 216             DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1);
 217   XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 218             DOOR_GFX_PAGEX6+ED_BUTTON_ELEM_XPOS,
 219             DOOR_GFX_PAGEY1+ED_BUTTON_ELEM_YPOS,
 220             4*ED_BUTTON_ELEM_XSIZE,5*ED_BUTTON_ELEM_YSIZE,
 221             DOOR_GFX_PAGEX1+ED_BUTTON_ELEM_XPOS,
 222             DOOR_GFX_PAGEY1+ED_BUTTON_EUP_Y2POS);
 223
 224   for(i=0;i<MAX_ELEM_X*MAX_ELEM_Y;i++)
 225   {
 226     if (i < elements_in_list)
 227       graphic = el2gfx(editor_element[i]);
 228     else
 229       graphic = GFX_LEERRAUM;
 230
 231     DrawMiniGraphicExtHiRes(pix[PIX_DB_DOOR],gc,
 232                             DOOR_GFX_PAGEX1+ED_BUTTON_ELEM_XPOS+3 +
 233                             (i%MAX_ELEM_X)*ED_BUTTON_ELEM_XSIZE,
 234                             DOOR_GFX_PAGEY1+ED_BUTTON_ELEM_YPOS+3 +
 235                             (i/MAX_ELEM_X)*ED_BUTTON_ELEM_YSIZE,
 236                             graphic);
 237   }
 238
 239   DrawMiniGraphicExtHiRes(pix[PIX_DB_DOOR],gc,
 240                           DOOR_GFX_PAGEX1+ED_WIN_MB_LEFT_XPOS,
 241                           DOOR_GFX_PAGEY1+ED_WIN_MB_LEFT_YPOS,
 242                           el2gfx(new_element1));
 243   DrawMiniGraphicExtHiRes(pix[PIX_DB_DOOR],gc,
 244                           DOOR_GFX_PAGEX1+ED_WIN_MB_MIDDLE_XPOS,
 245                           DOOR_GFX_PAGEY1+ED_WIN_MB_MIDDLE_YPOS,
 246                           el2gfx(new_element2));
 247   DrawMiniGraphicExtHiRes(pix[PIX_DB_DOOR],gc,
 248                           DOOR_GFX_PAGEX1+ED_WIN_MB_RIGHT_XPOS,
 249                           DOOR_GFX_PAGEY1+ED_WIN_MB_RIGHT_YPOS,
 250                           el2gfx(new_element3));
 251   DrawTextExt(pix[PIX_DB_DOOR],gc,
 252               DOOR_GFX_PAGEX2+ED_WIN_LEVELNR_XPOS,
 253               DOOR_GFX_PAGEY1+ED_WIN_LEVELNR_YPOS,
 254               int2str(level_nr,2),FS_SMALL,FC_SPECIAL1);
 255   XCopyArea(display,pix[PIX_DB_DOOR],pix[PIX_DB_DOOR],gc,
 256             DOOR_GFX_PAGEX2+ED_WIN_LEVELNR_XPOS+3,
 257             DOOR_GFX_PAGEY1+ED_WIN_LEVELNR_YPOS,
 258             7,FONT3_YSIZE,
 259             DOOR_GFX_PAGEX1+ED_WIN_LEVELNR_XPOS,
 260             DOOR_GFX_PAGEY1+ED_WIN_LEVELNR_YPOS);
 261   XCopyArea(display,pix[PIX_DB_DOOR],pix[PIX_DB_DOOR],gc,
 262             DOOR_GFX_PAGEX2+ED_WIN_LEVELNR_XPOS+14,
 263             DOOR_GFX_PAGEY1+ED_WIN_LEVELNR_YPOS,
 264             7,FONT3_YSIZE,
 265             DOOR_GFX_PAGEX1+ED_WIN_LEVELNR_XPOS+9,
 266             DOOR_GFX_PAGEY1+ED_WIN_LEVELNR_YPOS);
 267
 268   XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 269             DOOR_GFX_PAGEX6,DOOR_GFX_PAGEY2,
 270             VXSIZE,VYSIZE,
 271             DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY2);
 272
 273   OpenDoor(DOOR_OPEN_1 | DOOR_OPEN_2);
 274 }
 275
 276 void DrawControlWindow()
 277 {
 278   int i,x,y;
 279
 280   ClearWindow();
 281
 282   /* Inhalt der Mampfer */
 283   DrawText(ED_COUNT_GADGET_XPOS+1,SY+6,
 284            "Contents of a smashed cruncher:",FS_SMALL,FC_YELLOW);
 285   for(i=0;i<4;i++) for(y=0;y<4;y++) for(x=0;x<4;x++)
 286   {
 287     DrawMiniElement(1+5*i+x,2+y,EL_ERDREICH);
 288     XFillRectangle(display,drawto,gc,
 289                    SX+(1+5*i)*MINI_TILEX+MINI_TILEX/2-1,
 290                    SY+(2)*MINI_TILEY+MINI_TILEY/2-1,
 291                    3*MINI_TILEX+2,3*MINI_TILEY+2);
 292   }
 293   XCopyArea(display,drawto,drawto,gc,
 294             SX+1*MINI_TILEX,SY+2*MINI_TILEY,
 295             4*5*MINI_TILEX,5*MINI_TILEY,
 296             SX+1*MINI_TILEX-MINI_TILEX/2,SY+2*MINI_TILEY-MINI_TILEY/2);
 297   for(i=0;i<4;i++)
 298   {
 299     for(y=0;y<3;y++) for(x=0;x<3;x++)
 300       DrawMiniElement(1+5*i+x,2+y,level.mampfer_inhalt[i][x][y]);
 301
 302     DrawText(SX+MINI_TILEX+(5*i+1)*MINI_TILEX+1,
 303              SY+2*MINI_TILEY+(4)*MINI_TILEY-4,
 304              int2str(i+1,1),FS_SMALL,FC_YELLOW);
 305   }
 306
 307   /* Inhalt der Amöbe */
 308   for(y=0;y<2;y++) for(x=0;x<2;x++)
 309   {
 310     DrawMiniElement(29+x,26+y,EL_ERDREICH);
 311     XFillRectangle(display,drawto,gc,
 312                    SX+29*MINI_TILEX+MINI_TILEX/2-1,
 313                    SY+26*MINI_TILEY+MINI_TILEY/2-1,
 314                    MINI_TILEX+2,MINI_TILEY+2);
 315   }
 316   XCopyArea(display,drawto,drawto,gc,
 317             SX+29*MINI_TILEX,SY+26*MINI_TILEY,
 318             3*MINI_TILEX,3*MINI_TILEY,
 319             SX+29*MINI_TILEX-MINI_TILEX/2,SY+26*MINI_TILEY-MINI_TILEY/2);
 320   DrawMiniElement(29,26,level.amoebe_inhalt);
 321
 322   for(i=0;i<11+3+2;i++)
 323   {
 324     XCopyArea(display,pix[PIX_DOOR],drawto,gc,
 325               DOOR_GFX_PAGEX4+ED_BUTTON_MINUS_XPOS,
 326               DOOR_GFX_PAGEY1+ED_BUTTON_MINUS_YPOS,
 327               DXSIZE-4,ED_BUTTON_MINUS_YSIZE,
 328               ED_COUNT_GADGET_XPOS,
 329               ED_COUNT_GADGET_YPOS+i*ED_COUNT_GADGET_YSIZE);
 330
 331     if (i<11)
 332       DrawText(ED_COUNT_VALUE_XPOS,
 333                ED_COUNT_VALUE_YPOS+i*ED_COUNT_GADGET_YSIZE,
 334                int2str(level.score[i],3),FS_SMALL,FC_YELLOW);
 335     else if (i==11)
 336       DrawText(ED_COUNT_VALUE_XPOS,
 337                ED_COUNT_VALUE_YPOS+11*ED_COUNT_GADGET_YSIZE,
 338                int2str(level.tempo_amoebe,3),FS_SMALL,FC_YELLOW);
 339     else if (i==12)
 340       DrawText(ED_COUNT_VALUE_XPOS,
 341                ED_COUNT_VALUE_YPOS+12*ED_COUNT_GADGET_YSIZE,
 342                int2str(level.dauer_sieb,3),FS_SMALL,FC_YELLOW);
 343     else if (i==13)
 344       DrawText(ED_COUNT_VALUE_XPOS,
 345                ED_COUNT_VALUE_YPOS+13*ED_COUNT_GADGET_YSIZE,
 346                int2str(level.dauer_ablenk,3),FS_SMALL,FC_YELLOW);
 347     else if (i==14)
 348       DrawText(ED_COUNT_VALUE_XPOS,
 349                ED_COUNT_VALUE_YPOS+14*ED_COUNT_GADGET_YSIZE,
 350                int2str(level.edelsteine,3),FS_SMALL,FC_YELLOW);
 351     else if (i==15)
 352       DrawText(ED_COUNT_VALUE_XPOS,
 353                ED_COUNT_VALUE_YPOS+15*ED_COUNT_GADGET_YSIZE,
 354                int2str(level.time,3),FS_SMALL,FC_YELLOW);
 355   }
 356
 357   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+0*ED_COUNT_TEXT_YSIZE,
 358            "Score for Emerald",FS_SMALL,FC_YELLOW);
 359   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+1*ED_COUNT_TEXT_YSIZE,
 360            "Score for Diamond",FS_SMALL,FC_YELLOW);
 361   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+2*ED_COUNT_TEXT_YSIZE,
 362            "Score for smashing a Bug",FS_SMALL,FC_YELLOW);
 363   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+3*ED_COUNT_TEXT_YSIZE,
 364            "Score for smashing a Spaceship",FS_SMALL,FC_YELLOW);
 365   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+4*ED_COUNT_TEXT_YSIZE,
 366            "Score for smashing a Cruncher",FS_SMALL,FC_YELLOW);
 367   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+5*ED_COUNT_TEXT_YSIZE,
 368            "Score for smashing an Alien",FS_SMALL,FC_YELLOW);
 369   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+6*ED_COUNT_TEXT_YSIZE,
 370            "Score for smashing a Pacman",FS_SMALL,FC_YELLOW);
 371   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+7*ED_COUNT_TEXT_YSIZE,
 372            "Score for cracking a nut",FS_SMALL,FC_YELLOW);
 373   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+8*ED_COUNT_TEXT_YSIZE,
 374            "Score for dynamite",FS_SMALL,FC_YELLOW);
 375   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+9*ED_COUNT_TEXT_YSIZE,
 376            "Score for key",FS_SMALL,FC_YELLOW);
 377   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+10*ED_COUNT_TEXT_YSIZE,
 378            "Score for each 10 seconds left",FS_SMALL,FC_YELLOW);
 379   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+11*ED_COUNT_TEXT_YSIZE,
 380            "Speed of the amoeba / Content",FS_SMALL,FC_YELLOW);
 381   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+12*ED_COUNT_TEXT_YSIZE,
 382            "Time for magic wall",FS_SMALL,FC_YELLOW);
 383   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+13*ED_COUNT_TEXT_YSIZE,
 384            "Time for wheel",FS_SMALL,FC_YELLOW);
 385   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+14*ED_COUNT_TEXT_YSIZE,
 386            "Emeralds needed in this level",FS_SMALL,FC_YELLOW);
 387   DrawText(ED_COUNT_TEXT_XPOS,ED_COUNT_TEXT_YPOS+15*ED_COUNT_TEXT_YSIZE,
 388            "Time available for this level",FS_SMALL,FC_YELLOW);
 389
 390   XCopyArea(display,pix[PIX_DOOR],drawto,gc,
 391             DOOR_GFX_PAGEX4+ED_WIN_COUNT_XPOS,
 392             DOOR_GFX_PAGEY1+ED_WIN_COUNT_YPOS,
 393             ED_WIN_COUNT_XSIZE,ED_WIN_COUNT_YSIZE,
 394             ED_COUNT_GADGET_XPOS,
 395             ED_COUNT_GADGET_YPOS+16*ED_COUNT_GADGET_YSIZE);
 396   for(i=1;i<31;i++)
 397     XCopyArea(display,pix[PIX_DOOR],drawto,gc,
 398               DOOR_GFX_PAGEX4+ED_WIN_COUNT_XPOS+3+2*FONT2_XSIZE,
 399               DOOR_GFX_PAGEY1+ED_WIN_COUNT_YPOS,
 400               ED_WIN_COUNT_XSIZE-3-2*FONT2_XSIZE,ED_WIN_COUNT_YSIZE,
 401               ED_COUNT_GADGET_XPOS+3+i*FONT2_XSIZE,
 402               ED_COUNT_GADGET_YPOS+16*ED_COUNT_GADGET_YSIZE);
 403   DrawText(ED_COUNT_GADGET_XPOS+5,
 404            ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 405            level.name,FS_SMALL,FC_YELLOW);
 406   DrawText(ED_COUNT_GADGET_XPOS+(30+3)*FONT2_XSIZE-5,
 407            ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 408            "Title",FS_SMALL,FC_YELLOW);
 409
 410   DrawText(ED_SIZE_GADGET_XPOS,ED_SIZE_GADGET_YPOS-18,
 411            "Playfield size:",FS_SMALL,FC_YELLOW);
 412   XCopyArea(display,pix[PIX_DOOR],drawto,gc,
 413             DOOR_GFX_PAGEX4+ED_BUTTON_MINUS_XPOS,
 414             DOOR_GFX_PAGEY1+ED_BUTTON_MINUS_YPOS,
 415             DXSIZE-4,ED_BUTTON_MINUS_YSIZE,
 416             ED_SIZE_GADGET_XPOS,
 417             ED_SIZE_GADGET_YPOS+0*ED_COUNT_GADGET_YSIZE);
 418   XCopyArea(display,pix[PIX_DOOR],drawto,gc,
 419             DOOR_GFX_PAGEX4+ED_BUTTON_MINUS_XPOS,
 420             DOOR_GFX_PAGEY1+ED_BUTTON_MINUS_YPOS,
 421             DXSIZE-4,ED_BUTTON_MINUS_YSIZE,
 422             ED_SIZE_GADGET_XPOS,
 423             ED_SIZE_GADGET_YPOS+1*ED_COUNT_GADGET_YSIZE);
 424   DrawText(ED_SIZE_TEXT_XPOS,ED_SIZE_TEXT_YPOS+0*ED_SIZE_TEXT_YSIZE,
 425            "Width",FS_SMALL,FC_YELLOW);
 426   DrawText(ED_SIZE_TEXT_XPOS,ED_SIZE_TEXT_YPOS+1*ED_SIZE_TEXT_YSIZE,
 427            "Height",FS_SMALL,FC_YELLOW);
 428   DrawText(ED_SIZE_VALUE_XPOS,ED_SIZE_VALUE_YPOS+0*ED_SIZE_GADGET_YSIZE,
 429            int2str(level.fieldx,3),FS_SMALL,FC_YELLOW);
 430   DrawText(ED_SIZE_VALUE_XPOS,ED_SIZE_VALUE_YPOS+1*ED_SIZE_GADGET_YSIZE,
 431            int2str(level.fieldy,3),FS_SMALL,FC_YELLOW);
 432 }
 433
 434 void ScrollMiniLevel(int from_x, int from_y, int scroll)
 435 {
 436   int x,y;
 437   int dx = (scroll==ED_SCROLL_LEFT ? -1 : scroll==ED_SCROLL_RIGHT ? 1 : 0);
 438   int dy = (scroll==ED_SCROLL_UP   ? -1 : scroll==ED_SCROLL_DOWN  ? 1 : 0);
 439
 440   XCopyArea(display,drawto,drawto,gc,
 441             SX+MINI_TILEX*(dx==-1),SY+MINI_TILEY*(dy==-1),
 442             SXSIZE-MINI_TILEX*ABS(dx),SYSIZE-MINI_TILEY*ABS(dy),
 443             SX+MINI_TILEX*(dx==+1),SY+MINI_TILEY*(dy==+1));
 444   if (dx)
 445   {
 446     x = (dx==1 ? 0 : 2*SCR_FIELDX-1);
 447     for(y=0;y<2*SCR_FIELDY;y++)
 448       DrawMiniElementOrWall(x,y,from_x,from_y);
 449   }
 450   else if (dy)
 451   {
 452     y = (dy==1 ? 0 : 2*SCR_FIELDY-1);
 453     for(x=0;x<2*SCR_FIELDX;x++)
 454       DrawMiniElementOrWall(x,y,from_x,from_y);
 455   }
 456
 457   redraw_mask |= REDRAW_FIELD;
 458   BackToFront();
 459 }
 460
 461 void AdjustLevelScrollPosition()
 462 {
 463   if (level_xpos<-1)
 464     level_xpos = -1;
 465   if (level_xpos>lev_fieldx-2*SCR_FIELDX+1)
 466     level_xpos = lev_fieldx-2*SCR_FIELDX+1;
 467   if (lev_fieldx<2*SCR_FIELDX-2)
 468     level_xpos = -1;
 469
 470   if (level_ypos<-1)
 471     level_ypos = -1;
 472   if (level_ypos>lev_fieldy-2*SCR_FIELDY+1)
 473     level_ypos = lev_fieldy-2*SCR_FIELDY+1;
 474   if (lev_fieldy<2*SCR_FIELDY-2)
 475     level_ypos = -1;
 476 }
 477
 478 void FloodFill(int from_x, int from_y, int fill_element)
 479 {
 480   int i,x,y;
 481   int old_element;
 482   static int check[4][2] = { -1,0, 0,-1, 1,0, 0,1 };
 483   static int safety = 0;
 484
 485   safety++;
 486
 487   if (safety>lev_fieldx*lev_fieldy)
 488   {
 489     fprintf(stderr,"Something went wrong in 'FloodFill()'. Please debug.\n");
 490     exit(-1);
 491   }
 492
 493   old_element = Feld[from_x][from_y];
 494   Feld[from_x][from_y] = fill_element;
 495
 496   for(i=0;i<4;i++)
 497   {
 498     x = from_x+check[i][0];
 499     y = from_y+check[i][1];
 500
 501     if (IN_LEV_FIELD(x,y) && Feld[x][y]==old_element)
 502       FloodFill(x,y,fill_element);
 503   }
 504
 505   safety--;
 506 }
 507
 508 void LevelEd(int mx, int my, int button)
 509 {
 510   static int last_button = 0;
 511   static int in_field_pressed = FALSE;
 512   static BOOL use_floodfill = FALSE;
 513   int x = (mx-SX)/MINI_TILEX;
 514   int y = (my-SY)/MINI_TILEY;
 515
 516   if (use_floodfill)            /********** FLOOD FILL **********/
 517   {
 518     if (button)
 519     {
 520       if (mx>=SX && mx<SX+SXSIZE && my>=SY && my<SY+SYSIZE)
 521       {
 522         int from_x, from_y;
 523         int fill_element;
 524
 525         if (x>lev_fieldx || y>lev_fieldy ||
 526             (x==0 && level_xpos<0) ||
 527             (x==2*SCR_FIELDX-1 && level_xpos>lev_fieldx-2*SCR_FIELDX) ||
 528             (y==0 && level_ypos<0) ||
 529             (y==2*SCR_FIELDY-1 && level_ypos>lev_fieldy-2*SCR_FIELDY))
 530           return;
 531
 532         from_x = x+level_xpos;
 533         from_y = y+level_ypos;
 534         fill_element = (button==1 ? new_element1 :
 535                         button==2 ? new_element2 :
 536                         button==3 ? new_element3 : 0);
 537
 538         FloodFill(from_x,from_y,fill_element);
 539         DrawMiniLevel(level_xpos,level_ypos);
 540       }
 541
 542       use_floodfill = FALSE;
 543       CloseDoor(DOOR_CLOSE_1);
 544       OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
 545     }
 546     return;
 547   }
 548   else                          /********** EDIT/CTRL-FENSTER **********/
 549   {
 550     int choice = CheckElemButtons(mx,my,button);
 551     int elem_pos = choice-ED_BUTTON_ELEM;
 552
 553     switch(choice)
 554     {
 555       case ED_BUTTON_EUP:
 556       case ED_BUTTON_EDOWN:
 557         if ((choice==ED_BUTTON_EUP && element_shift>0) ||
 558             (choice==ED_BUTTON_EDOWN &&
 559              element_shift<elements_in_list-MAX_ELEM_X*MAX_ELEM_Y))
 560         {
 561           int i, step;
 562
 563           step = (button==1 ? MAX_ELEM_X : button==2 ? 5*MAX_ELEM_X :
 564                   elements_in_list);
 565           element_shift += (choice==ED_BUTTON_EUP ? -step : step);
 566           if (element_shift<0)
 567             element_shift = 0;
 568           if (element_shift>elements_in_list-MAX_ELEM_X*MAX_ELEM_Y)
 569             element_shift = elements_in_list-MAX_ELEM_X*MAX_ELEM_Y;
 570           if (element_shift % MAX_ELEM_X)
 571             element_shift += MAX_ELEM_X-(element_shift % MAX_ELEM_X);
 572
 573           for(i=0;i<MAX_ELEM_X*MAX_ELEM_Y;i++)
 574             DrawElemButton(i+2,ED_BUTTON_RELEASED);
 575           BackToFront();
 576           Delay(100000);
 577         }
 578         break;
 579       default:
 580         if (elem_pos>=0 && elem_pos<MAX_ELEM_X*MAX_ELEM_Y)
 581         {
 582           int new_element;
 583
 584           if (elem_pos+element_shift < elements_in_list)
 585             new_element = editor_element[elem_pos+element_shift];
 586           else
 587             new_element = EL_LEERRAUM;
 588
 589           if (last_button==1)
 590             new_element1 = new_element;
 591           else if (last_button==2)
 592             new_element2 = new_element;
 593           else if (last_button==3)
 594             new_element3 = new_element;
 595
 596           DrawMiniGraphicExtHiRes(drawto,gc,
 597                                   DX+ED_WIN_MB_LEFT_XPOS,
 598                                   DY+ED_WIN_MB_LEFT_YPOS,
 599                                   el2gfx(new_element1));
 600           DrawMiniGraphicExtHiRes(drawto,gc,
 601                                   DX+ED_WIN_MB_MIDDLE_XPOS,
 602                                   DY+ED_WIN_MB_MIDDLE_YPOS,
 603                                   el2gfx(new_element2));
 604           DrawMiniGraphicExtHiRes(drawto,gc,
 605                                   DX+ED_WIN_MB_RIGHT_XPOS,
 606                                   DY+ED_WIN_MB_RIGHT_YPOS,
 607                                   el2gfx(new_element3));
 608           redraw_mask |= REDRAW_DOOR_1;
 609         }
 610         break;
 611     }
 612
 613     if (edit_mode)              /********** EDIT-FENSTER **********/
 614     {
 615       switch(CheckEditButtons(mx,my,button))
 616       {
 617         case ED_BUTTON_CTRL:
 618           CloseDoor(DOOR_CLOSE_2);
 619           DrawControlWindow();
 620           XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 621                     DOOR_GFX_PAGEX4,DOOR_GFX_PAGEY1+80,
 622                     VXSIZE,VYSIZE,
 623                     DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY2);
 624           OpenDoor(DOOR_OPEN_2);
 625           edit_mode = FALSE;
 626           break;
 627         case ED_BUTTON_FILL:
 628           AreYouSure("Caution ! Flood fill mode ! Choose area !",AYS_OPEN);
 629           use_floodfill = TRUE;
 630           return;
 631           break;
 632         case ED_BUTTON_LEFT:
 633           if (level_xpos>=0)
 634           {
 635             if (lev_fieldx<2*SCR_FIELDX-2)
 636               break;
 637
 638             level_xpos -= (button==1 ? 1 : button==2 ? 5 : lev_fieldx);
 639             if (level_xpos<-1)
 640               level_xpos = -1;
 641             if (button==1)
 642               ScrollMiniLevel(level_xpos,level_ypos,ED_SCROLL_RIGHT);
 643             else
 644               DrawMiniLevel(level_xpos,level_ypos);
 645             BackToFront();
 646             Delay(100000);
 647           }
 648           break;
 649         case ED_BUTTON_RIGHT:
 650           if (level_xpos<=lev_fieldx-2*SCR_FIELDX)
 651           {
 652             if (lev_fieldx<2*SCR_FIELDX-2)
 653               break;
 654
 655             level_xpos += (button==1 ? 1 : button==2 ? 5 : lev_fieldx);
 656             if (level_xpos>lev_fieldx-2*SCR_FIELDX+1)
 657               level_xpos = lev_fieldx-2*SCR_FIELDX+1;
 658             if (button==1)
 659               ScrollMiniLevel(level_xpos,level_ypos,ED_SCROLL_LEFT);
 660             else
 661               DrawMiniLevel(level_xpos,level_ypos);
 662             BackToFront();
 663             Delay(100000);
 664           }
 665           break;
 666         case ED_BUTTON_UP:
 667           if (level_ypos>=0)
 668           {
 669             if (lev_fieldy<2*SCR_FIELDY-2)
 670               break;
 671
 672             level_ypos -= (button==1 ? 1 : button==2 ? 5 : lev_fieldy);
 673             if (level_ypos<-1)
 674               level_ypos = -1;
 675             if (button==1)
 676               ScrollMiniLevel(level_xpos,level_ypos,ED_SCROLL_DOWN);
 677             else
 678               DrawMiniLevel(level_xpos,level_ypos);
 679             BackToFront();
 680             Delay(100000);
 681           }
 682           break;
 683         case ED_BUTTON_DOWN:
 684           if (level_ypos<=lev_fieldy-2*SCR_FIELDY)
 685           {
 686             if (lev_fieldy<2*SCR_FIELDY-2)
 687               break;
 688
 689             level_ypos += (button==1 ? 1 : button==2 ? 5 : lev_fieldy);
 690             if (level_ypos>lev_fieldy-2*SCR_FIELDY+1)
 691               level_ypos = lev_fieldy-2*SCR_FIELDY+1;
 692             if (button==1)
 693               ScrollMiniLevel(level_xpos,level_ypos,ED_SCROLL_UP);
 694             else
 695               DrawMiniLevel(level_xpos,level_ypos);
 696             BackToFront();
 697             Delay(100000);
 698           }
 699           break;
 700         default:
 701           break;
 702       }
 703
 704       if (mx>=SX && mx<SX+SXSIZE && my>=SY && my<SY+SYSIZE)
 705       {
 706         int new_element;
 707
 708         if (button && !motion_status)
 709           in_field_pressed = TRUE;
 710
 711         if (!button || !in_field_pressed || button<1 || button>3 ||
 712             (y==0 && level_ypos<0) ||
 713             (y==2*SCR_FIELDY-1 && level_ypos>lev_fieldy-2*SCR_FIELDY) ||
 714             (x==0 && level_xpos<0) ||
 715             (x==2*SCR_FIELDX-1 && level_xpos>lev_fieldx-2*SCR_FIELDX) ||
 716             x>lev_fieldx || y>lev_fieldy)
 717           return;
 718
 719         new_element = (button==1 ? new_element1 :
 720                        button==2 ? new_element2 :
 721                        button==3 ? new_element3 : 0);
 722
 723         if (new_element != Feld[x+level_xpos][y+level_ypos])
 724         {
 725           if (new_element==EL_SPIELFIGUR) /* Jeder nur EINE Figur bitte... */
 726           {
 727             int x,y;
 728
 729             for(x=0;x<lev_fieldx;x++) for(y=0;y<lev_fieldy;y++)
 730             {
 731               if (Feld[x][y]==EL_SPIELFIGUR || Feld[x][y]==EL_SPIELER1)
 732               {
 733                 Feld[x][y] = EL_LEERRAUM;
 734                 if (x-level_xpos>=0 && x-level_xpos<2*SCR_FIELDX &&
 735                     y-level_ypos>=0 && y-level_ypos<2*SCR_FIELDY)
 736                   DrawMiniElement(x-level_xpos,y-level_ypos,EL_LEERRAUM);
 737               }
 738             }
 739           }
 740
 741           Feld[x+level_xpos][y+level_ypos] = new_element;
 742           DrawMiniElement(x,y,new_element);
 743         }
 744       }
 745       else if (!motion_status)  /* Mauszeiger nicht im Level-Feld */
 746         in_field_pressed = FALSE;
 747     }
 748     else                        /********** KONTROLL-FENSTER **********/
 749     {
 750       static long choice_delay = 0;
 751       int choice = CheckCountButtons(mx,my,button);
 752       int step = (button==1 ? 1 : button==2 ? 5 : button==3 ? 10 : 0);
 753
 754       if (choice>=0 && choice<36 && DelayReached(&choice_delay,10))
 755       {
 756         if (!(choice % 2))
 757           step = -step;
 758
 759         choice /= 2;
 760
 761         if (choice<11)
 762         {
 763           level.score[choice] += step;
 764           if (level.score[choice]<0)
 765             level.score[choice] = 0;
 766           else if (level.score[choice]>255)
 767             level.score[choice] = 255;
 768         }
 769         else if (choice==11)
 770         {
 771           level.tempo_amoebe += step;
 772           if (level.tempo_amoebe<0)
 773             level.tempo_amoebe = 0;
 774           else if (level.tempo_amoebe>255)
 775             level.tempo_amoebe = 255;
 776         }
 777         else if (choice==12)
 778         {
 779           level.dauer_sieb += step;
 780           if (level.dauer_sieb<0)
 781             level.dauer_sieb = 0;
 782           else if (level.dauer_sieb>255)
 783             level.dauer_sieb = 255;
 784         }
 785         else if (choice==13)
 786         {
 787           level.dauer_ablenk += step;
 788           if (level.dauer_ablenk<0)
 789             level.dauer_ablenk = 0;
 790           else if (level.dauer_ablenk>255)
 791             level.dauer_ablenk = 255;
 792         }
 793         else if (choice==14)
 794         {
 795           level.edelsteine += step;
 796           if (level.edelsteine<0)
 797             level.edelsteine = 0;
 798           else if (level.edelsteine>999)
 799             level.edelsteine = 999;
 800         }
 801         else if (choice==15)
 802         {
 803           level.time += step;
 804           if (level.time<0)
 805             level.time = 0;
 806           else if (level.time>999)
 807             level.time = 999;
 808         }
 809         else if (choice==16)
 810         {
 811           lev_fieldx += step;
 812           if (lev_fieldx<MIN_LEV_FIELDX)
 813             lev_fieldx = MIN_LEV_FIELDX;
 814           else if (lev_fieldx>MAX_LEV_FIELDX)
 815             lev_fieldx = MAX_LEV_FIELDX;
 816           level.fieldx = lev_fieldx;
 817         }
 818         else if (choice==17)
 819         {
 820           lev_fieldy += step;
 821           if (lev_fieldy<MIN_LEV_FIELDY)
 822             lev_fieldy = MIN_LEV_FIELDY;
 823           else if (lev_fieldy>MAX_LEV_FIELDY)
 824             lev_fieldy = MAX_LEV_FIELDY;
 825           level.fieldy = lev_fieldy;
 826         }
 827
 828         if (choice<11)
 829           DrawText(ED_COUNT_VALUE_XPOS,
 830                    ED_COUNT_VALUE_YPOS+choice*ED_COUNT_GADGET_YSIZE,
 831                    int2str(level.score[choice],3),FS_SMALL,FC_YELLOW);
 832         else if (choice==11)
 833           DrawText(ED_COUNT_VALUE_XPOS,
 834                    ED_COUNT_VALUE_YPOS+11*ED_COUNT_GADGET_YSIZE,
 835                    int2str(level.tempo_amoebe,3),FS_SMALL,FC_YELLOW);
 836         else if (choice==12)
 837           DrawText(ED_COUNT_VALUE_XPOS,
 838                    ED_COUNT_VALUE_YPOS+12*ED_COUNT_GADGET_YSIZE,
 839                    int2str(level.dauer_sieb,3),FS_SMALL,FC_YELLOW);
 840         else if (choice==13)
 841           DrawText(ED_COUNT_VALUE_XPOS,
 842                    ED_COUNT_VALUE_YPOS+13*ED_COUNT_GADGET_YSIZE,
 843                    int2str(level.dauer_ablenk,3),FS_SMALL,FC_YELLOW);
 844         else if (choice==14)
 845           DrawText(ED_COUNT_VALUE_XPOS,
 846                    ED_COUNT_VALUE_YPOS+14*ED_COUNT_GADGET_YSIZE,
 847                    int2str(level.edelsteine,3),FS_SMALL,FC_YELLOW);
 848         else if (choice==15)
 849           DrawText(ED_COUNT_VALUE_XPOS,
 850                    ED_COUNT_VALUE_YPOS+15*ED_COUNT_GADGET_YSIZE,
 851                    int2str(level.time,3),FS_SMALL,FC_YELLOW);
 852         else if (choice==16)
 853           DrawText(ED_SIZE_VALUE_XPOS,
 854                    ED_SIZE_VALUE_YPOS+0*ED_SIZE_GADGET_YSIZE,
 855                    int2str(level.fieldx,3),FS_SMALL,FC_YELLOW);
 856         else if (choice==17)
 857           DrawText(ED_SIZE_VALUE_XPOS,
 858                    ED_SIZE_VALUE_YPOS+1*ED_SIZE_GADGET_YSIZE,
 859                    int2str(level.fieldy,3),FS_SMALL,FC_YELLOW);
 860
 861         redraw_mask &= ~REDRAW_FIELD;
 862         if (choice<16)
 863           XCopyArea(display,drawto,window,gc,
 864                     ED_COUNT_VALUE_XPOS,
 865                     ED_COUNT_VALUE_YPOS+choice*ED_COUNT_GADGET_YSIZE,
 866                     3*FONT2_XSIZE,FONT2_YSIZE,
 867                     ED_COUNT_VALUE_XPOS,
 868                     ED_COUNT_VALUE_YPOS+choice*ED_COUNT_GADGET_YSIZE);
 869         else
 870           XCopyArea(display,drawto,window,gc,
 871                     ED_SIZE_VALUE_XPOS,
 872                     ED_SIZE_VALUE_YPOS+(choice-16)*ED_SIZE_GADGET_YSIZE,
 873                     3*FONT2_XSIZE,FONT2_YSIZE,
 874                     ED_SIZE_VALUE_XPOS,
 875                     ED_SIZE_VALUE_YPOS+(choice-16)*ED_SIZE_GADGET_YSIZE);
 876         XFlush(display);
 877       }
 878
 879       switch(CheckCtrlButtons(mx,my,button))
 880       {
 881         case ED_BUTTON_EDIT:
 882           CloseDoor(DOOR_CLOSE_2);
 883           AdjustLevelScrollPosition();
 884           DrawMiniLevel(level_xpos,level_ypos);
 885           XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 886                     DOOR_GFX_PAGEX6,DOOR_GFX_PAGEY2,
 887                     VXSIZE,VYSIZE,
 888                     DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY2);
 889           OpenDoor(DOOR_OPEN_2);
 890           edit_mode = TRUE;
 891           break;
 892         case ED_BUTTON_CLEAR:
 893           if (AreYouSure("Are you sure to clear this level ?",AYS_ASK))
 894           {
 895             for(x=0;x<MAX_LEV_FIELDX;x++)
 896               for(y=0;y<MAX_LEV_FIELDY;y++)
 897                 Feld[x][y] = EL_ERDREICH;
 898             DrawMiniLevel(level_xpos,level_ypos);
 899           }
 900           break;
 901         case ED_BUTTON_UNDO:
 902           if (AreYouSure("Exit without saving ?",AYS_ASK | AYS_STAY_OPEN))
 903           {
 904             CloseDoor(DOOR_CLOSE_BOTH);
 905             game_status=MAINMENU;
 906             DrawMainMenu();
 907           }
 908           else
 909           {
 910             CloseDoor(DOOR_CLOSE_1);
 911             OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
 912           }
 913           break;
 914         case ED_BUTTON_EXIT:
 915           {
 916             int figur_vorhanden = FALSE;
 917             for(y=0;y<lev_fieldy;y++)
 918               for(x=0;x<lev_fieldx;x++)
 919                 if (Feld[x][y]==EL_SPIELFIGUR || Feld[x][y]==EL_SPIELER1)
 920                   figur_vorhanden = TRUE;
 921
 922             if (!figur_vorhanden)
 923               AreYouSure("No Level without Gregor Mc Duffin please !",
 924                          AYS_CONFIRM);
 925             else
 926             {
 927               if (AreYouSure("Save this level and kill the old ?",
 928                              AYS_ASK | AYS_STAY_OPEN))
 929               {
 930                 for(x=0;x<lev_fieldx;x++)
 931                   for(y=0;y<lev_fieldy;y++)
 932                     Ur[x][y]=Feld[x][y];
 933                 SaveLevel(level_nr);
 934               }
 935               CloseDoor(DOOR_CLOSE_BOTH);
 936               game_status=MAINMENU;
 937               DrawMainMenu();
 938             }
 939           }
 940           break;
 941         default:
 942           break;
 943       }
 944
 945       if (mx>=ED_COUNT_GADGET_XPOS &&
 946           mx<ED_COUNT_GADGET_XPOS+31*FONT2_XSIZE+10 &&
 947           my>=ED_COUNT_GADGET_YPOS+16*ED_COUNT_GADGET_YSIZE &&
 948           my<ED_COUNT_GADGET_YPOS+16*ED_COUNT_GADGET_YSIZE+ED_WIN_COUNT_YSIZE)
 949       {
 950         if (!name_typing)
 951         {
 952           name_typing = TRUE;
 953           DrawText(ED_COUNT_GADGET_XPOS+5,
 954                    ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 955                    level.name,FS_SMALL,FC_GREEN);
 956           DrawText(ED_COUNT_GADGET_XPOS+5+strlen(level.name)*FONT2_XSIZE,
 957                    ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 958                    "<",FS_SMALL,FC_RED);
 959         }
 960       }
 961       else
 962       {
 963         if (name_typing)
 964         {
 965           name_typing = FALSE;
 966           DrawText(ED_COUNT_GADGET_XPOS+5,
 967                    ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 968                    level.name,FS_SMALL,FC_YELLOW);
 969           DrawText(ED_COUNT_GADGET_XPOS+5+strlen(level.name)*FONT2_XSIZE,
 970                    ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
 971                    " ",FS_SMALL,FC_RED);
 972         }
 973       }
 974
 975       if (mx>=SX+29*MINI_TILEX && mx<SX+30*MINI_TILEX &&
 976           my>=SY+26*MINI_TILEY && my<SY+27*MINI_TILEY)
 977       {
 978         int new_element;
 979
 980         if (!button || button<1 || button>3)
 981           return;
 982
 983         new_element = (button==1 ? new_element1 :
 984                        button==2 ? new_element2 :
 985                        button==3 ? new_element3 : 0);
 986
 987         if (new_element != level.amoebe_inhalt)
 988         {
 989           level.amoebe_inhalt = new_element;
 990           DrawMiniElement(29,26,new_element);
 991         }
 992       }
 993
 994       if (mx>=SX+1*MINI_TILEX && mx<SX+(1+4*5)*MINI_TILEX &&
 995           my>=SY+2*MINI_TILEY && my<SY+(2+3)*MINI_TILEY)
 996       {
 997         int x = (mx-SX-1*MINI_TILEX)/MINI_TILEX;
 998         int y = (my-SY-2*MINI_TILEY)/MINI_TILEY;
 999         int i = x/5;
1000         int new_element;
1001
1002         x = x-i*5;
1003         if (i>=0 && i<43 && x>=0 && x<3 && y>=0 && y<3)
1004         {
1005           if (button && !motion_status)
1006             in_field_pressed = TRUE;
1007
1008           if (!button || !in_field_pressed || button<1 || button>3)
1009             return;
1010
1011           new_element = (button==1 ? new_element1 :
1012                          button==2 ? new_element2 :
1013                          button==3 ? new_element3 : 0);
1014
1015           if (new_element != level.mampfer_inhalt[i][x][y])
1016           {
1017             level.mampfer_inhalt[i][x][y] = new_element;
1018             DrawMiniElement(1+5*i+x,2+y,new_element);
1019           }
1020         }
1021         else if (!motion_status)/* Mauszeiger nicht im Cruncher-Feld */
1022           in_field_pressed = FALSE;
1023       }
1024       else if (!motion_status)  /* Mauszeiger nicht im Cruncher-Feld */
1025         in_field_pressed = FALSE;
1026     }
1027   }
1028
1029   last_button = button;
1030
1031   BackToFront();
1032 }
1033
1034 void LevelNameTyping(KeySym key)
1035 {
1036   unsigned char ascii = 0;
1037   int len = strlen(level.name);
1038
1039   if (!name_typing)
1040     return;
1041
1042   if (key>=XK_A && key<=XK_Z)
1043     ascii = 'A'+(char)(key-XK_A);
1044   else if (key>=XK_a && key<=XK_z)
1045     ascii = 'a'+(char)(key-XK_a);
1046   else if (key>=XK_0 && key<=XK_9)
1047     ascii = '0'+(char)(key-XK_0);
1048 #ifdef XK_LATIN1
1049   else if (key>=XK_space && key<=XK_at)
1050     ascii = ' '+(char)(key-XK_space);
1051   else if (key==XK_Adiaeresis)
1052     ascii = 'Ä';
1053   else if (key==XK_Odiaeresis)
1054     ascii = 'Ö';
1055   else if (key==XK_Udiaeresis)
1056     ascii = 'Ü';
1057   else if (key==XK_adiaeresis)
1058     ascii = 'ä';
1059   else if (key==XK_odiaeresis)
1060     ascii = 'ö';
1061   else if (key==XK_udiaeresis)
1062     ascii = 'ü';
1063   else if (key==XK_underscore)
1064     ascii = '_';
1065 #endif
1066
1067   if (ascii && len<MAX_LEVNAMLEN-2)
1068   {
1069     level.name[len] = ascii;
1070     level.name[len+1] = 0;
1071     len++;
1072
1073     DrawTextExt(drawto,gc,
1074                 ED_COUNT_GADGET_XPOS+5,
1075                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1076                 level.name,FS_SMALL,FC_GREEN);
1077     DrawTextExt(window,gc,
1078                 ED_COUNT_GADGET_XPOS+5,
1079                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1080                 level.name,FS_SMALL,FC_GREEN);
1081     DrawTextExt(drawto,gc,
1082                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1083                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1084                 "<",FS_SMALL,FC_RED);
1085     DrawTextExt(window,gc,
1086                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1087                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1088                 "<",FS_SMALL,FC_RED);
1089   }
1090   else if (key==XK_Delete && len>0)
1091   {
1092     level.name[len-1] = 0;
1093     len--;
1094
1095     DrawTextExt(drawto,gc,
1096                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1097                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1098                 "< ",FS_SMALL,FC_GREEN);
1099     DrawTextExt(window,gc,
1100                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1101                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1102                 "< ",FS_SMALL,FC_GREEN);
1103   }
1104   else if (key==XK_Return)
1105   {
1106     DrawTextExt(drawto,gc,
1107                 ED_COUNT_GADGET_XPOS+5,
1108                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1109                 level.name,FS_SMALL,FC_YELLOW);
1110     DrawTextExt(window,gc,
1111                 ED_COUNT_GADGET_XPOS+5,
1112                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1113                 level.name,FS_SMALL,FC_YELLOW);
1114     DrawTextExt(drawto,gc,
1115                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1116                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1117                 " ",FS_SMALL,FC_YELLOW);
1118     DrawTextExt(window,gc,
1119                 ED_COUNT_GADGET_XPOS+5+len*FONT2_XSIZE,
1120                 ED_COUNT_TEXT_YPOS+16*ED_COUNT_TEXT_YSIZE,
1121                 " ",FS_SMALL,FC_YELLOW);
1122
1123     name_typing = FALSE;
1124   }
1125 }