src/init.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 *  init.c                                                  *
  13 ***********************************************************/
  14
  15 #include "init.h"
  16 #include "misc.h"
  17 #include "sound.h"
  18 #include "screens.h"
  19 #include "tools.h"
  20 #include "files.h"
  21 #include <signal.h>
  22
  23 static int sound_process_id = 0;
  24
  25 void OpenAll(int argc, char *argv[])
  26 {
  27   InitLevelAndPlayerInfo();
  28
  29   InitCounter();
  30   InitSound();
  31   InitSoundProcess();
  32   InitJoystick();
  33   InitRND(NEW_RANDOMIZE);
  34
  35   signal(SIGINT, CloseAll);
  36   signal(SIGTERM, CloseAll);
  37
  38   InitDisplay(argc, argv);
  39   InitWindow(argc, argv);
  40
  41   XMapWindow(display, window);
  42   XFlush(display);
  43
  44   InitGfx();
  45   InitElementProperties();
  46
  47   DrawMainMenu();
  48 }
  49
  50 void InitLevelAndPlayerInfo()
  51 {
  52   if (!LoadLevelInfo())                 /* global level info */
  53     CloseAll();
  54
  55   LoadPlayerInfo(PLAYER_SETUP);         /* global setup info */
  56   LoadPlayerInfo(PLAYER_LEVEL);         /* level specific info */
  57 }
  58
  59 void InitSound()
  60 {
  61   int i;
  62
  63   if (sound_status==SOUND_OFF)
  64     return;
  65
  66   if (access(sound_device_name,W_OK)<0)
  67   {
  68     fprintf(stderr,"%s: cannot access sound device - no sounds\n",progname);
  69     sound_status=SOUND_OFF;
  70     return;
  71   }
  72
  73   if ((sound_device=open(sound_device_name,O_WRONLY))<0)
  74   {
  75     fprintf(stderr,"%s: cannot open sound device - no sounds\n",progname);
  76     sound_status=SOUND_OFF;
  77     return;
  78   }
  79
  80   close(sound_device);
  81   sound_status=SOUND_AVAILABLE;
  82
  83 #ifdef VOXWARE
  84   sound_loops_allowed = TRUE;
  85   sound_loops_on = TRUE;
  86 #endif
  87
  88   for(i=0;i<NUM_SOUNDS;i++)
  89   {
  90     Sound[i].name = sound_name[i];
  91     if (!LoadSound(&Sound[i]))
  92     {
  93       sound_status=SOUND_OFF;
  94       return;
  95     }
  96   }
  97 }
  98
  99 void InitSoundProcess()
 100 {
 101   if (sound_status==SOUND_OFF)
 102     return;
 103
 104   if (pipe(sound_pipe)<0)
 105   {
 106     fprintf(stderr,"%s: cannot create pipe - no sounds\n",progname);
 107     sound_status=SOUND_OFF;
 108     return;
 109   }
 110
 111   if ((sound_process_id=fork())<0)
 112   {
 113     fprintf(stderr,"%s: cannot create child process - no sounds\n",progname);
 114     sound_status=SOUND_OFF;
 115     return;
 116   }
 117
 118   if (!sound_process_id)        /* we are child */
 119     SoundServer();
 120   else                          /* we are parent */
 121     close(sound_pipe[0]);       /* no reading from pipe needed */
 122 }
 123
 124 void InitJoystick()
 125 {
 126   if (global_joystick_status==JOYSTICK_OFF)
 127     return;
 128
 129   if (access(joystick_device_name[joystick_nr],R_OK)<0)
 130   {
 131     fprintf(stderr,"%s: cannot access joystick device '%s'\n",
 132             progname,joystick_device_name[joystick_nr]);
 133     joystick_status = JOYSTICK_OFF;
 134     return;
 135   }
 136
 137   if ((joystick_device=open(joystick_device_name[joystick_nr],O_RDONLY))<0)
 138   {
 139     fprintf(stderr,"%s: cannot open joystick device '%s'\n",
 140             progname,joystick_device_name[joystick_nr]);
 141     joystick_status = JOYSTICK_OFF;
 142     return;
 143   }
 144
 145   joystick_status = JOYSTICK_AVAILABLE;
 146   LoadJoystickData();
 147 }
 148
 149 void InitDisplay(int argc, char *argv[])
 150 {
 151   char *display_name = NULL;
 152   int i;
 153
 154   /* get X server to connect to, if given as an argument */
 155   for (i=1;i<argc-1;i++)
 156   {
 157     char *dispstr="-display";
 158     int len=MAX(strlen(dispstr),strlen(argv[i]));
 159
 160     if (len<4)
 161       continue;
 162     else if (!strncmp(argv[i],dispstr,len))
 163     {
 164       display_name=argv[i+1];
 165       break;
 166     }
 167   }
 168
 169   /* connect to X server */
 170   if (!(display=XOpenDisplay(display_name)))
 171   {
 172     fprintf(stderr,"%s: cannot connect to X server %s\n",
 173             progname, XDisplayName(display_name));
 174     exit(-1);
 175   }
 176
 177   screen = DefaultScreen(display);
 178   cmap   = DefaultColormap(display, screen);
 179   pen_fg = WhitePixel(display,screen);
 180   pen_bg = BlackPixel(display,screen);
 181 }
 182
 183 void InitWindow(int argc, char *argv[])
 184 {
 185   unsigned int border_width = 4;
 186   Pixmap icon_pixmap, iconmask_pixmap;
 187   unsigned int icon_width,icon_height;
 188   int icon_hot_x,icon_hot_y;
 189   char icon_filename[256];
 190   XSizeHints size_hints;
 191   XWMHints wm_hints;
 192   XClassHint class_hints;
 193   XTextProperty windowName, iconName;
 194   XGCValues gc_values;
 195   unsigned long gc_valuemask;
 196   char *window_name = WINDOWTITLE_STRING;
 197   char *icon_name = WINDOWTITLE_STRING;
 198   long window_event_mask;
 199   static struct PictureFile icon_pic =
 200   {
 201     "rocks_icon.xbm",
 202     "rocks_iconmask.xbm"
 203   };
 204
 205   width = WIN_XSIZE;
 206   height = WIN_YSIZE;
 207
 208   window = XCreateSimpleWindow(display, RootWindow(display, screen),
 209                             WIN_XPOS, WIN_YPOS, width, height, border_width,
 210                             pen_fg, pen_bg);
 211
 212   sprintf(icon_filename,"%s/%s",GFX_PATH,icon_pic.picture_filename);
 213   XReadBitmapFile(display,window,icon_filename,
 214                   &icon_width,&icon_height,
 215                   &icon_pixmap,&icon_hot_x,&icon_hot_y);
 216   if (!icon_pixmap)
 217   {
 218     fprintf(stderr, "%s: cannot read icon bitmap file '%s'.\n",
 219             progname,icon_filename);
 220     exit(-1);
 221   }
 222
 223   sprintf(icon_filename,"%s/%s",GFX_PATH,icon_pic.picturemask_filename);
 224   XReadBitmapFile(display,window,icon_filename,
 225                   &icon_width,&icon_height,
 226                   &iconmask_pixmap,&icon_hot_x,&icon_hot_y);
 227   if (!iconmask_pixmap)
 228   {
 229     fprintf(stderr, "%s: cannot read icon bitmap file '%s'.\n",
 230             progname,icon_filename);
 231     exit(-1);
 232   }
 233
 234   size_hints.flags = PSize | PMinSize | PMaxSize;
 235   size_hints.width  = size_hints.min_width  = size_hints.max_width  = width;
 236   size_hints.height = size_hints.min_height = size_hints.max_height = height;
 237
 238   if (!XStringListToTextProperty(&window_name, 1, &windowName))
 239   {
 240     fprintf(stderr, "%s: structure allocation for windowName failed.\n",
 241             progname);
 242     exit(-1);
 243   }
 244
 245   if (!XStringListToTextProperty(&icon_name, 1, &iconName))
 246   {
 247     fprintf(stderr, "%s: structure allocation for iconName failed.\n",
 248             progname);
 249     exit(-1);
 250   }
 251
 252   wm_hints.initial_state = NormalState;
 253   wm_hints.input = True;
 254   wm_hints.icon_pixmap = icon_pixmap;
 255   wm_hints.icon_mask = iconmask_pixmap;
 256   wm_hints.flags = StateHint | IconPixmapHint | IconMaskHint | InputHint;
 257
 258   class_hints.res_name = progname;
 259   class_hints.res_class = "Rocks'n'Diamonds";
 260
 261   XSetWMProperties(display, window, &windowName, &iconName,
 262                    argv, argc, &size_hints, &wm_hints,
 263                    &class_hints);
 264
 265   XFree(windowName.value);
 266   XFree(iconName.value);
 267
 268   /* Select event types wanted */
 269   window_event_mask = ExposureMask | StructureNotifyMask | FocusChangeMask |
 270                       ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
 271                       KeyPressMask | KeyReleaseMask;
 272   XSelectInput(display, window, window_event_mask);
 273
 274   /* create GC for drawing with window depth */
 275   gc_values.graphics_exposures = False;
 276   gc_values.foreground = pen_bg;
 277   gc_values.background = pen_bg;
 278   gc_valuemask = GCGraphicsExposures | GCForeground | GCBackground;
 279   gc = XCreateGC(display, window, gc_valuemask, &gc_values);
 280 }
 281
 282 void DrawInitText(char *text, int ypos, int color)
 283 {
 284   if (display && window && pix[PIX_SMALLFONT])
 285   {
 286     XFillRectangle(display,window,gc,0,ypos, WIN_XSIZE,FONT2_YSIZE);
 287     DrawTextExt(window,gc,(WIN_XSIZE-strlen(text)*FONT2_XSIZE)/2,
 288                 ypos,text,FS_SMALL,color);
 289     XFlush(display);
 290   }
 291 }
 292
 293 void InitGfx()
 294 {
 295   int i,j;
 296   XGCValues clip_gc_values;
 297   unsigned long clip_gc_valuemask;
 298   static struct PictureFile pic[NUM_PICTURES] =
 299   {
 300     { "RocksScreen.xpm",        "RocksScreenMaske.xbm" },
 301     { "RocksDoor.xpm",          "RocksDoorMaske.xbm" },
 302     { "RocksToons.xpm",         "RocksToonsMaske.xbm" },
 303     { "RocksFont.xpm",          NULL },
 304     { "RocksFont2.xpm",         NULL }
 305   };
 306
 307   LoadGfx(PIX_SMALLFONT,&pic[PIX_SMALLFONT]);
 308   DrawInitText(WINDOWTITLE_STRING,20,FC_YELLOW);
 309   DrawInitText(COPYRIGHT_STRING,50,FC_RED);
 310   DrawInitText("Loading graphics:",120,FC_GREEN);
 311
 312   for(i=0;i<NUM_PICTURES;i++)
 313     if (i!=PIX_SMALLFONT)
 314       LoadGfx(i,&pic[i]);
 315
 316   pix[PIX_DB_BACK] = XCreatePixmap(display, window,
 317                                    WIN_XSIZE,WIN_YSIZE,
 318                                    XDefaultDepth(display,screen));
 319   pix[PIX_DB_DOOR] = XCreatePixmap(display, window,
 320                                    3*DXSIZE,DYSIZE+VYSIZE,
 321                                    XDefaultDepth(display,screen));
 322
 323   if (!pix[PIX_DB_BACK] || !pix[PIX_DB_DOOR])
 324   {
 325     fprintf(stderr, "%s: cannot create additional Pixmaps!\n",progname);
 326     CloseAll();
 327     exit(-1);
 328   }
 329
 330   for(i=0;i<NUM_PIXMAPS;i++)
 331   {
 332     if (clipmask[i])
 333     {
 334       clip_gc_values.graphics_exposures = False;
 335       clip_gc_values.foreground = pen_fg;
 336       clip_gc_values.background = pen_bg;
 337       clip_gc_values.clip_mask = clipmask[i];
 338       clip_gc_valuemask =
 339         GCGraphicsExposures | GCForeground | GCBackground | GCClipMask;
 340       clip_gc[i] = XCreateGC(display,window,clip_gc_valuemask,&clip_gc_values);
 341     }
 342   }
 343
 344   drawto = drawto_field = backbuffer = pix[PIX_DB_BACK];
 345
 346   XCopyArea(display,pix[PIX_BACK],backbuffer,gc,
 347             0,0, WIN_XSIZE,WIN_YSIZE, 0,0);
 348   XFillRectangle(display,pix[PIX_DB_BACK],gc,
 349                  REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE);
 350   XFillRectangle(display,pix[PIX_DB_DOOR],gc,
 351                  0,0, 3*DXSIZE,DYSIZE+VYSIZE);
 352
 353   for(i=0;i<SCR_FIELDX;i++)
 354     for(j=0;j<SCR_FIELDY;j++)
 355       redraw[i][j]=0;
 356   redraw_tiles=0;
 357   redraw_mask=REDRAW_ALL;
 358 }
 359
 360 void LoadGfx(int pos, struct PictureFile *pic)
 361 {
 362   int xpm_err, xbm_err;
 363   unsigned int width,height;
 364   int hot_x,hot_y;
 365   char filename[256];
 366   Pixmap shapemask;
 367
 368   /* Grafik laden */
 369   if (pic->picture_filename)
 370   {
 371     DrawInitText(pic->picture_filename,150,FC_YELLOW);
 372     sprintf(filename,"%s/%s",GFX_PATH,pic->picture_filename);
 373
 374     xpm_att[pos].valuemask = XpmCloseness;
 375     xpm_att[pos].closeness = 20000;
 376     xpm_err = XpmReadFileToPixmap(display,window,filename,
 377                                   &pix[pos],&shapemask,&xpm_att[pos]);
 378     switch(xpm_err)
 379     {
 380       case XpmOpenFailed:
 381         fprintf(stderr,"Xpm file open failed on '%s' !\n",filename);
 382         CloseAll();
 383         exit(-1);
 384       case XpmFileInvalid:
 385         fprintf(stderr,"Invalid Xpm file '%s'!\n",filename);
 386         CloseAll();
 387         exit(-1);
 388       case XpmNoMemory:
 389         fprintf(stderr,"Not enough memory !\n");
 390         CloseAll();
 391         exit(1);
 392       case XpmColorFailed:
 393         fprintf(stderr,"Can`t get any colors...\n");
 394         CloseAll();
 395         exit(-1);
 396       default:
 397         break;
 398     }
 399
 400     if (!pix[pos])
 401     {
 402       fprintf(stderr, "%s: cannot read Xpm file '%s'.\n",
 403               progname,filename);
 404       CloseAll();
 405       exit(-1);
 406     }
 407   }
 408
 409   /* zugehörige Maske laden (wenn vorhanden) */
 410   if (pic->picturemask_filename)
 411   {
 412     DrawInitText(pic->picturemask_filename,150,FC_YELLOW);
 413     sprintf(filename,"%s/%s",GFX_PATH,pic->picturemask_filename);
 414
 415     xbm_err = XReadBitmapFile(display,window,filename,
 416                               &width,&height,&clipmask[pos],&hot_x,&hot_y);
 417     switch(xbm_err)
 418     {
 419       case BitmapSuccess:
 420         break;
 421       case BitmapOpenFailed:
 422         fprintf(stderr,"Bitmap file open failed on '%s' !\n",filename);
 423         CloseAll();
 424         exit(-1);
 425         break;
 426       case BitmapFileInvalid:
 427         fprintf(stderr,"Bitmap file invalid: '%s' !\n",filename);
 428         CloseAll();
 429         exit(-1);
 430         break;
 431       case BitmapNoMemory:
 432         fprintf(stderr,"No memory for file '%s' !\n",filename);
 433         CloseAll();
 434         exit(-1);
 435         break;
 436       default:
 437         break;
 438     }
 439
 440     if (!clipmask[pos])
 441     {
 442       fprintf(stderr, "%s: cannot read X11 bitmap file '%s'.\n",
 443               progname,filename);
 444       CloseAll();
 445       exit(-1);
 446     }
 447   }
 448 }
 449
 450 void InitElementProperties()
 451 {
 452   int i,j;
 453
 454   static int ep_amoebalive[] =
 455   {
 456     EL_AMOEBE_NASS,
 457     EL_AMOEBE_NORM,
 458     EL_AMOEBE_VOLL,
 459     EL_AMOEBE_BD
 460   };
 461   static int ep_amoebalive_num = sizeof(ep_amoebalive)/sizeof(int);
 462
 463   static int ep_amoeboid[] =
 464   {
 465     EL_AMOEBE_TOT,
 466     EL_AMOEBE_NASS,
 467     EL_AMOEBE_NORM,
 468     EL_AMOEBE_VOLL,
 469     EL_AMOEBE_BD
 470   };
 471   static int ep_amoeboid_num = sizeof(ep_amoeboid)/sizeof(int);
 472
 473   static int ep_badewannoid[] =
 474   {
 475     EL_BADEWANNE1,
 476     EL_BADEWANNE2,
 477     EL_BADEWANNE3,
 478     EL_BADEWANNE4,
 479     EL_BADEWANNE5
 480   };
 481   static int ep_badewannoid_num = sizeof(ep_badewannoid)/sizeof(int);
 482
 483   static int ep_schluessel[] =
 484   {
 485     EL_SCHLUESSEL1,
 486     EL_SCHLUESSEL2,
 487     EL_SCHLUESSEL3,
 488     EL_SCHLUESSEL4
 489   };
 490   static int ep_schluessel_num = sizeof(ep_schluessel)/sizeof(int);
 491
 492   static int ep_pforte[] =
 493   {
 494     EL_PFORTE1,
 495     EL_PFORTE2,
 496     EL_PFORTE3,
 497     EL_PFORTE4,
 498     EL_PFORTE1X,
 499     EL_PFORTE2X,
 500     EL_PFORTE3X,
 501     EL_PFORTE4X
 502   };
 503   static int ep_pforte_num = sizeof(ep_pforte)/sizeof(int);
 504
 505   static int ep_solid[] =
 506   {
 507     EL_BETON,
 508     EL_MAUERWERK,
 509     EL_MAUER_LEBT,
 510     EL_FELSBODEN,
 511     EL_AUSGANG_ZU,
 512     EL_AUSGANG_ACT,
 513     EL_AUSGANG_AUF,
 514     EL_AMOEBE_TOT,
 515     EL_AMOEBE_NASS,
 516     EL_AMOEBE_NORM,
 517     EL_AMOEBE_VOLL,
 518     EL_AMOEBE_BD,
 519     EL_MORAST_VOLL,
 520     EL_MORAST_LEER,
 521     EL_SIEB_VOLL,
 522     EL_SIEB_LEER,
 523     EL_SIEB_TOT,
 524     EL_SIEB2_VOLL,
 525     EL_SIEB2_LEER,
 526     EL_SIEB2_TOT,
 527     EL_LIFE,
 528     EL_LIFE_ASYNC,
 529     EL_BADEWANNE1,
 530     EL_BADEWANNE2,
 531     EL_BADEWANNE3,
 532     EL_BADEWANNE4,
 533     EL_BADEWANNE5
 534   };
 535   static int ep_solid_num = sizeof(ep_solid)/sizeof(int);
 536
 537   static int ep_massiv[] =
 538   {
 539     EL_BETON,
 540     EL_SALZSAEURE,
 541     EL_BADEWANNE1,
 542     EL_BADEWANNE2,
 543     EL_BADEWANNE3,
 544     EL_BADEWANNE4,
 545     EL_BADEWANNE5,
 546     EL_PFORTE1,
 547     EL_PFORTE2,
 548     EL_PFORTE3,
 549     EL_PFORTE4,
 550     EL_PFORTE1X,
 551     EL_PFORTE2X,
 552     EL_PFORTE3X,
 553     EL_PFORTE4X
 554   };
 555   static int ep_massiv_num = sizeof(ep_massiv)/sizeof(int);
 556
 557   static int ep_slippery[] =
 558   {
 559     EL_FELSBODEN,
 560     EL_FELSBROCKEN,
 561     EL_EDELSTEIN,
 562     EL_EDELSTEIN_BD,
 563     EL_EDELSTEIN_GELB,
 564     EL_EDELSTEIN_ROT,
 565     EL_EDELSTEIN_LILA,
 566     EL_DIAMANT,
 567     EL_BOMBE,
 568     EL_KOKOSNUSS,
 569     EL_ABLENK_EIN,
 570     EL_ABLENK_AUS,
 571     EL_ZEIT_VOLL,
 572     EL_ZEIT_LEER,
 573     EL_BIRNE_EIN,
 574     EL_BIRNE_AUS,
 575     EL_BADEWANNE1,
 576     EL_BADEWANNE2
 577   };
 578   static int ep_slippery_num = sizeof(ep_slippery)/sizeof(int);
 579
 580   static int ep_enemy[] =
 581   {
 582     EL_KAEFER,
 583     EL_FLIEGER,
 584     EL_BUTTERFLY,
 585     EL_FIREFLY,
 586     EL_MAMPFER,
 587     EL_MAMPFER2,
 588     EL_ZOMBIE,
 589     EL_PACMAN
 590   };
 591   static int ep_enemy_num = sizeof(ep_enemy)/sizeof(int);
 592
 593   static int ep_mauer[] =
 594   {
 595     EL_BETON,
 596     EL_PFORTE1,
 597     EL_PFORTE2,
 598     EL_PFORTE3,
 599     EL_PFORTE4,
 600     EL_PFORTE1X,
 601     EL_PFORTE2X,
 602     EL_PFORTE3X,
 603     EL_PFORTE4X,
 604     EL_AUSGANG_ZU,
 605     EL_AUSGANG_ACT,
 606     EL_AUSGANG_AUF,
 607     EL_MAUERWERK,
 608     EL_FELSBODEN,
 609     EL_MAUER_LEBT,
 610     EL_MAUERND
 611   };
 612   static int ep_mauer_num = sizeof(ep_mauer)/sizeof(int);
 613
 614   static int ep_can_fall[] =
 615   {
 616     EL_FELSBROCKEN,
 617     EL_EDELSTEIN,
 618     EL_EDELSTEIN_BD,
 619     EL_EDELSTEIN_GELB,
 620     EL_EDELSTEIN_ROT,
 621     EL_EDELSTEIN_LILA,
 622     EL_DIAMANT,
 623     EL_BOMBE,
 624     EL_KOKOSNUSS,
 625     EL_TROPFEN,
 626     EL_MORAST_VOLL,
 627     EL_SIEB_VOLL,
 628     EL_SIEB2_VOLL,
 629     EL_ZEIT_VOLL,
 630     EL_ZEIT_LEER
 631   };
 632   static int ep_can_fall_num = sizeof(ep_can_fall)/sizeof(int);
 633
 634   static int ep_can_smash[] =
 635   {
 636     EL_FELSBROCKEN,
 637     EL_EDELSTEIN,
 638     EL_EDELSTEIN_BD,
 639     EL_EDELSTEIN_GELB,
 640     EL_EDELSTEIN_ROT,
 641     EL_EDELSTEIN_LILA,
 642     EL_DIAMANT,
 643     EL_SCHLUESSEL1,
 644     EL_SCHLUESSEL2,
 645     EL_SCHLUESSEL3,
 646     EL_SCHLUESSEL4,
 647     EL_BOMBE,
 648     EL_KOKOSNUSS,
 649     EL_TROPFEN,
 650     EL_ZEIT_VOLL,
 651     EL_ZEIT_LEER
 652   };
 653   static int ep_can_smash_num = sizeof(ep_can_smash)/sizeof(int);
 654
 655   static int ep_can_change[] =
 656   {
 657     EL_FELSBROCKEN,
 658     EL_EDELSTEIN,
 659     EL_EDELSTEIN_BD,
 660     EL_EDELSTEIN_GELB,
 661     EL_EDELSTEIN_ROT,
 662     EL_EDELSTEIN_LILA,
 663     EL_DIAMANT
 664   };
 665   static int ep_can_change_num = sizeof(ep_can_change)/sizeof(int);
 666
 667   static int ep_can_move[] =
 668   {
 669     EL_KAEFER,
 670     EL_FLIEGER,
 671     EL_BUTTERFLY,
 672     EL_FIREFLY,
 673     EL_MAMPFER,
 674     EL_MAMPFER2,
 675     EL_ZOMBIE,
 676     EL_PACMAN
 677   };
 678   static int ep_can_move_num = sizeof(ep_can_move)/sizeof(int);
 679
 680   static int ep_could_move[] =
 681   {
 682     EL_KAEFER_R,
 683     EL_KAEFER_O,
 684     EL_KAEFER_L,
 685     EL_KAEFER_U,
 686     EL_FLIEGER_R,
 687     EL_FLIEGER_O,
 688     EL_FLIEGER_L,
 689     EL_FLIEGER_U,
 690     EL_BUTTERFLY_R,
 691     EL_BUTTERFLY_O,
 692     EL_BUTTERFLY_L,
 693     EL_BUTTERFLY_U,
 694     EL_FIREFLY_R,
 695     EL_FIREFLY_O,
 696     EL_FIREFLY_L,
 697     EL_FIREFLY_U,
 698     EL_PACMAN_R,
 699     EL_PACMAN_O,
 700     EL_PACMAN_L,
 701     EL_PACMAN_U
 702   };
 703   static int ep_could_move_num = sizeof(ep_could_move)/sizeof(int);
 704
 705   static int ep_dont_touch[] =
 706   {
 707     EL_KAEFER,
 708     EL_FLIEGER,
 709     EL_BUTTERFLY,
 710     EL_FIREFLY
 711   };
 712   static int ep_dont_touch_num = sizeof(ep_dont_touch)/sizeof(int);
 713
 714   static int ep_dont_go_to[] =
 715   {
 716     EL_KAEFER,
 717     EL_FLIEGER,
 718     EL_BUTTERFLY,
 719     EL_FIREFLY,
 720     EL_MAMPFER,
 721     EL_MAMPFER2,
 722     EL_ZOMBIE,
 723     EL_PACMAN,
 724     EL_TROPFEN,
 725     EL_SALZSAEURE
 726   };
 727   static int ep_dont_go_to_num = sizeof(ep_dont_go_to)/sizeof(int);
 728
 729   static int ep_mampf2[] =
 730   {
 731     EL_ERDREICH,
 732     EL_KAEFER,
 733     EL_FLIEGER,
 734     EL_BUTTERFLY,
 735     EL_FIREFLY,
 736     EL_MAMPFER,
 737     EL_ZOMBIE,
 738     EL_PACMAN,
 739     EL_TROPFEN,
 740     EL_AMOEBE_TOT,
 741     EL_AMOEBE_NASS,
 742     EL_AMOEBE_NORM,
 743     EL_AMOEBE_VOLL,
 744     EL_AMOEBE_BD,
 745     EL_EDELSTEIN,
 746     EL_EDELSTEIN_BD,
 747     EL_EDELSTEIN_GELB,
 748     EL_EDELSTEIN_ROT,
 749     EL_EDELSTEIN_LILA,
 750     EL_DIAMANT
 751   };
 752   static int ep_mampf2_num = sizeof(ep_mampf2)/sizeof(int);
 753
 754   static int ep_bd_element[] =
 755   {
 756     EL_LEERRAUM,
 757     EL_ERDREICH,
 758     EL_FELSBODEN,
 759     EL_FELSBROCKEN,
 760     EL_EDELSTEIN_BD,
 761     EL_SIEB2_LEER,
 762     EL_AUSGANG_ZU,
 763     EL_AUSGANG_AUF,
 764     EL_BETON,
 765     EL_SPIELFIGUR,
 766     EL_FIREFLY,
 767     EL_FIREFLY_1,
 768     EL_FIREFLY_2,
 769     EL_FIREFLY_3,
 770     EL_FIREFLY_4,
 771     EL_BUTTERFLY,
 772     EL_BUTTERFLY_1,
 773     EL_BUTTERFLY_2,
 774     EL_BUTTERFLY_3,
 775     EL_BUTTERFLY_4,
 776     EL_AMOEBE_BD,
 777     EL_CHAR_FRAGE
 778   };
 779   static int ep_bd_element_num = sizeof(ep_bd_element)/sizeof(int);
 780
 781   static int ep_sb_element[] =
 782   {
 783     EL_LEERRAUM,
 784     EL_BETON,
 785     EL_SOKOBAN_OBJEKT,
 786     EL_SOKOBAN_FELD_LEER,
 787     EL_SOKOBAN_FELD_VOLL,
 788     EL_SPIELFIGUR
 789   };
 790   static int ep_sb_element_num = sizeof(ep_sb_element)/sizeof(int);
 791
 792   static int ep_gem[] =
 793   {
 794     EL_EDELSTEIN,
 795     EL_EDELSTEIN_BD,
 796     EL_EDELSTEIN_GELB,
 797     EL_EDELSTEIN_ROT,
 798     EL_EDELSTEIN_LILA,
 799     EL_DIAMANT
 800   };
 801   static int ep_gem_num = sizeof(ep_gem)/sizeof(int);
 802
 803   static int ep_inactive[] =
 804   {
 805     EL_LEERRAUM,
 806     EL_ERDREICH,
 807     EL_MAUERWERK,
 808     EL_FELSBODEN,
 809     EL_SCHLUESSEL,
 810     EL_BETON,
 811     EL_AMOEBE_TOT,
 812     EL_MORAST_LEER,
 813     EL_BADEWANNE,
 814     EL_ABLENK_AUS,
 815     EL_SCHLUESSEL1,
 816     EL_SCHLUESSEL2,
 817     EL_SCHLUESSEL3,
 818     EL_SCHLUESSEL4,
 819     EL_PFORTE1,
 820     EL_PFORTE2,
 821     EL_PFORTE3,
 822     EL_PFORTE4,
 823     EL_PFORTE1X,
 824     EL_PFORTE2X,
 825     EL_PFORTE3X,
 826     EL_PFORTE4X,
 827     EL_DYNAMIT_AUS,
 828     EL_UNSICHTBAR,
 829     EL_BIRNE_AUS,
 830     EL_BIRNE_EIN,
 831     EL_ERZ_EDEL,
 832     EL_ERZ_DIAM,
 833     EL_ERZ_EDEL_BD,
 834     EL_ERZ_EDEL_GELB,
 835     EL_DYNABOMB_NR,
 836     EL_DYNABOMB_SZ,
 837     EL_DYNABOMB_XL,
 838     EL_SOKOBAN_OBJEKT,
 839     EL_SOKOBAN_FELD_LEER,
 840     EL_SOKOBAN_FELD_VOLL,
 841     EL_ERZ_EDEL_ROT,
 842     EL_ERZ_EDEL_LILA,
 843     EL_BADEWANNE1,
 844     EL_BADEWANNE2,
 845     EL_BADEWANNE3,
 846     EL_BADEWANNE4,
 847     EL_BADEWANNE5,
 848     EL_SIEB_TOT,
 849     EL_SIEB2_TOT,
 850     EL_AMOEBA2DIAM,
 851     EL_BLOCKED
 852   };
 853   static int ep_inactive_num = sizeof(ep_inactive)/sizeof(int);
 854
 855   static long ep_bit[] =
 856   {
 857     EP_BIT_AMOEBALIVE,
 858     EP_BIT_AMOEBOID,
 859     EP_BIT_BADEWANNOID,
 860     EP_BIT_SCHLUESSEL,
 861     EP_BIT_PFORTE,
 862     EP_BIT_SOLID,
 863     EP_BIT_MASSIV,
 864     EP_BIT_SLIPPERY,
 865     EP_BIT_ENEMY,
 866     EP_BIT_MAUER,
 867     EP_BIT_CAN_FALL,
 868     EP_BIT_CAN_SMASH,
 869     EP_BIT_CAN_CHANGE,
 870     EP_BIT_CAN_MOVE,
 871     EP_BIT_COULD_MOVE,
 872     EP_BIT_DONT_TOUCH,
 873     EP_BIT_DONT_GO_TO,
 874     EP_BIT_MAMPF2,
 875     EP_BIT_BD_ELEMENT,
 876     EP_BIT_SB_ELEMENT,
 877     EP_BIT_GEM,
 878     EP_BIT_INACTIVE
 879   };
 880   static int *ep_array[] =
 881   {
 882     ep_amoebalive,
 883     ep_amoeboid,
 884     ep_badewannoid,
 885     ep_schluessel,
 886     ep_pforte,
 887     ep_solid,
 888     ep_massiv,
 889     ep_slippery,
 890     ep_enemy,
 891     ep_mauer,
 892     ep_can_fall,
 893     ep_can_smash,
 894     ep_can_change,
 895     ep_can_move,
 896     ep_could_move,
 897     ep_dont_touch,
 898     ep_dont_go_to,
 899     ep_mampf2,
 900     ep_bd_element,
 901     ep_sb_element,
 902     ep_gem,
 903     ep_inactive
 904   };
 905   static int *ep_num[] =
 906   {
 907     &ep_amoebalive_num,
 908     &ep_amoeboid_num,
 909     &ep_badewannoid_num,
 910     &ep_schluessel_num,
 911     &ep_pforte_num,
 912     &ep_solid_num,
 913     &ep_massiv_num,
 914     &ep_slippery_num,
 915     &ep_enemy_num,
 916     &ep_mauer_num,
 917     &ep_can_fall_num,
 918     &ep_can_smash_num,
 919     &ep_can_change_num,
 920     &ep_can_move_num,
 921     &ep_could_move_num,
 922     &ep_dont_touch_num,
 923     &ep_dont_go_to_num,
 924     &ep_mampf2_num,
 925     &ep_bd_element_num,
 926     &ep_sb_element_num,
 927     &ep_gem_num,
 928     &ep_inactive_num
 929   };
 930   static int num_properties = sizeof(ep_num)/sizeof(int *);
 931
 932   for(i=0;i<MAX_ELEMENTS;i++)
 933     Elementeigenschaften[i] = 0;
 934
 935   for(i=0;i<num_properties;i++)
 936     for(j=0;j<*(ep_num[i]);j++)
 937       Elementeigenschaften[(ep_array[i])[j]] |= ep_bit[i];
 938   for(i=EL_CHAR_START;i<EL_CHAR_END;i++)
 939     Elementeigenschaften[i] |= (EP_BIT_CHAR | EP_BIT_INACTIVE);
 940 }
 941
 942 void CloseAll()
 943 {
 944   int i;
 945
 946   if (sound_process_id)
 947   {
 948     StopSounds();
 949     kill(sound_process_id, SIGTERM);
 950     FreeSounds(NUM_SOUNDS);
 951   }
 952
 953   for(i=0;i<NUM_PIXMAPS;i++)
 954   {
 955     if (pix[i])
 956     {
 957       if (i<NUM_PICTURES)       /* XPM pictures */
 958       {
 959         XFreeColors(display,DefaultColormap(display,screen),
 960                     xpm_att[i].pixels,xpm_att[i].npixels,0);
 961         XpmFreeAttributes(&xpm_att[i]);
 962       }
 963       XFreePixmap(display,pix[i]);
 964     }
 965     if (clipmask[i])
 966       XFreePixmap(display,clipmask[i]);
 967     if (clip_gc[i])
 968       XFreeGC(display, clip_gc[i]);
 969   }
 970
 971   if (gc)
 972     XFreeGC(display, gc);
 973   if (display)
 974     XCloseDisplay(display);
 975
 976   exit(0);
 977 }