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