rnd-20020519-1-src
[rocksndiamonds.git] / src / main.c
index 92e8b38a1e20514c004175fbe370ec0de64ede82..a7cc5858fdb9bff09810f9ccb682b1b1bf13062a 100644 (file)
@@ -1,14 +1,14 @@
 /***********************************************************
-*  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
+* Rocks'n'Diamonds -- McDuffin Strikes Back!               *
 *----------------------------------------------------------*
-*  (c) 1995-98 Artsoft Entertainment                       *
-*              Holger Schemel                              *
-*              Oststrasse 11a                              *
-*              33604 Bielefeld                             *
-*              phone: ++49 +521 290471                     *
-*              email: aeglos@valinor.owl.de                *
+* (c) 1995-2001 Artsoft Entertainment                      *
+*               Holger Schemel                             *
+*               Detmolder Strasse 189                      *
+*               33604 Bielefeld                            *
+*               Germany                                    *
+*               e-mail: info@artsoft.org                   *
 *----------------------------------------------------------*
-*  main.c                                                  *
+* main.c                                                   *
 ***********************************************************/
 
 #include "libgame/libgame.h"
 #include "init.h"
 #include "game.h"
 #include "events.h"
-#include "joystick.h"
 
-#if defined(PLATFORM_MSDOS)
-#include <fcntl.h>
-#endif
-
-#if 0
-DrawWindow     window = None;
-DrawBuffer     backbuffer;
-GC             gc;
-#endif
-
-GC             clip_gc[NUM_BITMAPS], tile_clip_gc;
-Bitmap         pix[NUM_BITMAPS];
-Bitmap         pix_masked[NUM_BITMAPS], tile_masked[NUM_TILES];
-Pixmap         clipmask[NUM_BITMAPS], tile_clipmask[NUM_TILES];
-
-DrawBuffer     drawto, drawto_field, fieldbuffer;
-#if 0
-Colormap       cmap;
-#endif
-
-#if 0
-char          *sound_device_name = AUDIO_DEVICE;
-#endif
-
-int            joystick_device = 0;
-char          *joystick_device_name[MAX_PLAYERS] =
-{
-  DEV_JOYSTICK_0,
-  DEV_JOYSTICK_1,
-  DEV_JOYSTICK_2,
-  DEV_JOYSTICK_3
-};
-
-char          *program_name = NULL;
+GC             tile_clip_gc;
+Bitmap        *pix[NUM_BITMAPS];
+Pixmap         tile_clipmask[NUM_TILES];
+DrawBuffer     *fieldbuffer;
+DrawBuffer     *drawto_field;
 
 int            game_status = MAINMENU;
 boolean                level_editor_test_game = FALSE;
 boolean                network_playing = FALSE;
-int            button_status = MB_NOT_PRESSED;
-boolean                motion_status = FALSE;
-int            key_joystick_mapping = 0;
-int            global_joystick_status = JOYSTICK_STATUS;
-int            joystick_status = JOYSTICK_STATUS;
 
-#if 0
-boolean                fullscreen_available = FULLSCREEN_STATUS;
-boolean                fullscreen_enabled = FALSE;
-#endif
+int            key_joystick_mapping = 0;
 
 boolean                redraw[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
 int            redraw_x1 = 0, redraw_y1 = 0;
-int            redraw_mask;
-int            redraw_tiles;
 
 short          Feld[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 short          Ur[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
@@ -86,10 +46,10 @@ boolean             Stop[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 short          JustStopped[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 short          AmoebaNr[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 short          AmoebaCnt[MAX_NUM_AMOEBA], AmoebaCnt2[MAX_NUM_AMOEBA];
+short          ExplodeField[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 unsigned long  Elementeigenschaften1[MAX_ELEMENTS];
 unsigned long  Elementeigenschaften2[MAX_ELEMENTS];
 
-int            level_nr;
 int            lev_fieldx,lev_fieldy, scroll_x,scroll_y;
 
 int            FX = SX, FY = SY, ScrollStepSize;
@@ -104,114 +64,274 @@ int              SBY_Upper, SBY_Lower;
 int            ZX,ZY, ExitX,ExitY;
 int            AllPlayersGone;
 
-#if 0
-int            FrameCounter;
-#endif
-
 int            TimeFrames, TimePlayed, TimeLeft;
 
 boolean                network_player_action_received = FALSE;
 
-struct LevelDirInfo    *leveldir_first = NULL, *leveldir_current = NULL;
 struct LevelInfo       level;
 struct PlayerInfo      stored_player[MAX_PLAYERS], *local_player = NULL;
 struct HiScore         highscore[MAX_SCORE_ENTRIES];
-struct SampleInfo      Sound[NUM_SOUNDS];
 struct TapeInfo                tape;
-
-#if 0
-struct OptionInfo      options;
-#endif
-
 struct SetupInfo       setup;
 struct GameInfo                game;
-
-#if 0
-struct VideoSystemInfo video;
-struct AudioSystemInfo audio;
-#endif
-
 struct GlobalInfo      global;
 
-/* data needed for playing sounds */
+/* filenames of sound effects */
 char *sound_name[NUM_SOUNDS] =
 {
-  "alchemy",
-  "amoebe",
-  "antigrav",
-  "autsch",
-  "blurb",
-  "bong",
-  "buing",
-  "chase",
-  "czardasz",
-  "deng",
-  "fuel",
-  "gong",
-  "halloffame",
-  "holz",
-  "hui",
-  "kabumm",
-  "kink",
-  "klapper",
-  "kling",
-  "klopf",
-  "klumpf",
-  "knack",
-  "knurk",
-  "krach",
-  "lachen",
-  "laser",
-  "miep",
-  "network",
-  "njam",
-  "oeffnen",
-  "pling",
-  "pong",
-  "pusch",
-  "quiek",
-  "quirk",
-  "rhythmloop",
-  "roaaar",
-  "roehr",
-  "rumms",
-  "schlopp",
-  "schlurf",
-  "schrff",
-  "schwirr",
-  "sirr",
-  "slurp",
-  "sproing",
-  "twilight",
-  "tyger",
-  "voyager",
-  "warnton",
-  "whoosh",
-  "zisch",
-  "base",
-  "infotron",
-  "zonkdown",
-  "zonkpush",
-  "bug",
-  "boom",
-  "booom",
-  "exit",
-  "empty",
-  "gate"
+  "amoebe.wav",
+  "antigrav.wav",
+  "autsch.wav",
+  "blurb.wav",
+  "bong.wav",
+  "buing.wav",
+  "deng.wav",
+  "fuel.wav",
+  "gong.wav",
+  "halloffame.wav",
+  "holz.wav",
+  "hui.wav",
+  "kabumm.wav",
+  "kink.wav",
+  "klapper.wav",
+  "kling.wav",
+  "klopf.wav",
+  "klumpf.wav",
+  "knack.wav",
+  "knurk.wav",
+  "krach.wav",
+  "lachen.wav",
+  "laser.wav",
+  "miep.wav",
+  "njam.wav",
+  "oeffnen.wav",
+  "pling.wav",
+  "pong.wav",
+  "pusch.wav",
+  "quiek.wav",
+  "quirk.wav",
+  "rhythmloop.wav",
+  "roaaar.wav",
+  "roehr.wav",
+  "rumms.wav",
+  "schlopp.wav",
+  "schlurf.wav",
+  "schrff.wav",
+  "schwirr.wav",
+  "sirr.wav",
+  "slurp.wav",
+  "sproing.wav",
+  "warnton.wav",
+  "whoosh.wav",
+  "zisch.wav",
+  "base.wav",
+  "infotron.wav",
+  "zonkdown.wav",
+  "zonkpush.wav",
+  "bug.wav",
+  "boom.wav",
+  "booom.wav",
+  "exit.wav",
+  "empty.wav",
+  "gate.wav"
 };
 
-/* background music */
-int background_loop[] =
+struct SoundEffectInfo sound_effects[] =
 {
-  SND_ALCHEMY,
-  SND_CHASE,
-  SND_NETWORK,
-  SND_CZARDASZ,
-  SND_TYGER,
-  SND_VOYAGER,
-  SND_TWILIGHT
+  /* sounds for Boulder Dash style elements and actions */
+  { "bd_empty_space.digging",          "empty.wav"             },
+  { "bd_sand.digging",                 "schlurf.wav"           },
+  { "bd_diamond.collecting",           "pong.wav"              },
+  { "bd_diamond.impact",               "pling.wav"             },
+  { "bd_rock.pushing",                 "pusch.wav"             },
+  { "bd_rock.impact",                  "klopf.wav"             },
+  { "bd_magic_wall.activating",                "quirk.wav"             },
+  { "bd_magic_wall.changing",          "quirk.wav"             },
+  { "bd_magic_wall.running",           "miep.wav"              },
+  { "bd_amoeba.growing",               "amoebe.wav"            },
+  { "bd_amoeba.turning_to_gem",                "pling.wav"             },
+  { "bd_amoeba.turning_to_rock",       "klopf.wav"             },
+  { "bd_butterfly.moving",             "klapper.wav"           },
+  { "bd_firefly.moving",               "roehr.wav"             },
+  { "bd_exit.entering",                        "buing.wav"             },
+
+  /* sounds for Supaplex style elements and actions */
+  { "sp_empty_space.digging",          "empty.wav"             },
+  { "sp_base.digging",                 "base.wav"              },
+  { "sp_buggy_base.digging",           "base.wav"              },
+  { "sp_buggy_base.activating",                "bug.wav"               },
+  { "sp_infotron.collecting",          "infotron.wav"          },
+  { "sp_infotron.impact",              "pling.wav"             },
+  { "sp_zonk.pushing",                 "zonkpush.wav"          },
+  { "sp_zonk.impact",                  "zonkdown.wav"          },
+  { "sp_disk_red.collecting",          "infotron.wav"          },
+  { "sp_disk_orange.pushing",          "zonkpush.wav"          },
+  { "sp_disk_yellow.pushing",          "pusch.wav"             },
+  { "sp_port.passing",                 "gate.wav"              },
+  { "sp_exit.entering",                        "exit.wav"              },
+  { "sp_element.exploding",            "booom.wav"             },
+  { "sp_sniksnak.moving",              SND_FILE_UNDEFINED      },
+  { "sp_electron.moving",              SND_FILE_UNDEFINED      },
+  { "sp_terminal.activating",          SND_FILE_UNDEFINED      },
+
+  /* sounds for Sokoban style elements and actions */
+  { "sokoban_object.pushing",          "pusch.wav"             },
+  { "sokoban_field.filling",           "deng.wav"              },
+  { "sokoban_field.clearing",          SND_FILE_UNDEFINED      },
+  { "sokoban_game.solving",            "buing.wav"             },
+
+  /* sounds for Emerald Mine style elements and actions */
+  { "empty_space.digging",             "empty.wav"             },
+  { "sand.digging",                    "schlurf.wav"           },
+  { "emerald.collecting",              "pong.wav"              },
+  { "emerald.impact",                  "pling.wav"             },
+  { "diamond.collecting",              "pong.wav"              },
+  { "diamond.impact",                  "pling.wav"             },
+  { "diamond.breaking",                        "quirk.wav"             },
+  { "rock.pushing",                    "pusch.wav"             },
+  { "rock.impact",                     "klopf.wav"             },
+  { "bomb.pushing",                    "pusch.wav"             },
+  { "nut.pushing",                     "knurk.wav"             },
+  { "nut.cracking",                    "knack.wav"             },
+  { "nut.impact",                      "klumpf.wav"            },
+  { "dynamite.collecting",             "pong.wav"              },
+  { "dynamite.placing",                        "deng.wav"              },
+  { "dynamite.burning",                        "zisch.wav"             },
+  { "key.collecting",                  "pong.wav"              },
+  { "gate.passing",                    "gate.wav"              },
+  { "bug.moving",                      "klapper.wav"           },
+  { "spaceship.moving",                        "roehr.wav"             },
+  { "yamyam.moving",                   SND_FILE_UNDEFINED      },
+  { "yamyam.waiting",                  "njam.wav"              },
+  { "yamyam.eating_diamond",           SND_FILE_UNDEFINED      },
+  { "robot.moving",                    "schlurf.wav"           },
+  { "robot_wheel.activating",          "deng.wav"              },
+  { "robot_wheel.running",             "miep.wav"              },
+  { "magic_wall.activating",           "quirk.wav"             },
+  { "magic_wall.changing",             "quirk.wav"             },
+  { "magic_wall.running",              "miep.wav"              },
+  { "amoeba.growing",                  "amoebe.wav"            },
+  { "amoeba.dropping",                 SND_FILE_UNDEFINED      },
+  { "acid.splashing",                  "blurb.wav"             },
+  { "quicksand.filling",               SND_FILE_UNDEFINED      },
+  { "quicksand.slipping_through",      SND_FILE_UNDEFINED      },
+  { "quicksand.emptying",              SND_FILE_UNDEFINED      },
+  { "exit.opening",                    "oeffnen.wav"           },
+  { "exit.entering",                   "buing.wav"             },
+
+  /* sounds for Emerald Mine Club style elements and actions */
+  { "balloon.moving",                  SND_FILE_UNDEFINED      },
+  { "balloon.pushing",                 "schlurf.wav"           },
+  { "spring.moving",                   SND_FILE_UNDEFINED      },
+  { "spring.pushing",                  "pusch.wav"             },
+  { "spring.impact",                   "klopf.wav"             },
+  { "wall.growing",                    SND_FILE_UNDEFINED      },
+
+  /* sounds for Diamond Caves style elements and actions */
+  { "pearl.collecting",                        "pong.wav"              },
+  { "pearl.breaking",                  "knack.wav"             },
+  { "pearl.impact",                    "pling.wav"             },
+  { "crystal.collecting",              "pong.wav"              },
+  { "crystal.impact",                  "pling.wav"             },
+  { "envelope.collecting",             "pong.wav"              },
+  { "sand_invisible.digging",          "schlurf.wav"           },
+  { "shield_passive.collecting",       "pong.wav"              },
+  { "shield_passive.activated",                SND_FILE_UNDEFINED      },
+  { "shield_active.collecting",                "pong.wav"              },
+  { "shield_active.activated",         SND_FILE_UNDEFINED      },
+  { "extra_time.collecting",           "gong.wav"              },
+  { "mole.moving",                     SND_FILE_UNDEFINED      },
+  { "mole.eating_amoeba",              "blurb.wav"             },
+  { "switchgate_switch.activating",    SND_FILE_UNDEFINED      },
+  { "switchgate.opening",              "oeffnen.wav"           },
+  { "switchgate.closing",              "oeffnen.wav"           },
+  { "switchgate.passing",              "gate.wav"              },
+  { "timegate_wheel.activating",       "deng.wav"              },
+  { "timegate_wheel.running",          "miep.wav"              },
+  { "timegate.opening",                        "oeffnen.wav"           },
+  { "timegate.closing",                        "oeffnen.wav"           },
+  { "timegate.passing",                        "gate.wav"              },
+  { "conveyor_belt_switch.activating", SND_FILE_UNDEFINED      },
+  { "conveyor_belt.running",           SND_FILE_UNDEFINED      },
+  { "light_switch.activating",         SND_FILE_UNDEFINED      },
+  { "light_switch.deactivating",       SND_FILE_UNDEFINED      },
+
+  /* sounds for DX Boulderdash style elements and actions */
+  { "dx_bomb.pushing",                 "pusch.wav"             },
+  { "trap_inactive.digging",           "schlurf.wav"           },
+  { "trap.activating",                 SND_FILE_UNDEFINED      },
+
+  /* sounds for Rocks'n'Diamonds style elements and actions */
+  { "amoeba.turning_to_gem",           "pling.wav"             },
+  { "amoeba.turning_to_rock",          "klopf.wav"             },
+  { "speed_pill.collecting",           "pong.wav"              },
+  { "dynabomb_nr.collecting",          "pong.wav"              },
+  { "dynabomb_sz.collecting",          "pong.wav"              },
+  { "dynabomb_xl.collecting",          "pong.wav"              },
+  { "dynabomb.placing",                        "deng.wav"              },
+  { "dynabomb.burning",                        "zisch.wav"             },
+  { "satellite.moving",                        SND_FILE_UNDEFINED      },
+  { "satellite.pushing",               "pusch.wav"             },
+  { "lamp.activating",                 "deng.wav"              },
+  { "lamp.deactivating",               "deng.wav"              },
+  { "time_orb_full.collecting",                "gong.wav"              },
+  { "time_orb_full.impact",            "deng.wav"              },
+  { "time_orb_empty.pushing",          "pusch.wav"             },
+  { "time_orb_empty.impact",           "deng.wav"              },
+  { "gameoflife.growing",              "amoebe.wav"            },
+  { "biomaze.growing",                 "amoebe.wav"            },
+  { "pacman.moving",                   SND_FILE_UNDEFINED      },
+  { "pacman.eating_amoeba",            SND_FILE_UNDEFINED      },
+  { "dark_yamyam.moving",              SND_FILE_UNDEFINED      },
+  { "dark_yamyam.waiting",             "njam.wav"              },
+  { "dark_yamyam.eating_any",          SND_FILE_UNDEFINED      },
+  { "penguin.moving",                  SND_FILE_UNDEFINED      },
+  { "penguin.entering_exit",           "buing.wav"             },
+  { "pig.moving",                      SND_FILE_UNDEFINED      },
+  { "pig.eating_gem",                  SND_FILE_UNDEFINED      },
+  { "dragon.moving",                   SND_FILE_UNDEFINED      },
+  { "dragon.breathing_fire",           SND_FILE_UNDEFINED      },
+
+  /* sounds for generic elements and actions */
+  { "player.dying",                    "autsch.wav"            },
+  { "element.exploding",               "roaaar.wav"            },
+
+  /* sounds for other game actions */
+  { "game.starting",                   SND_FILE_UNDEFINED      },
+  { "game.running_out_of_time",                "gong.wav"              },
+  { "game.leveltime_bonus",            "sirr.wav"              },
+  { "game.losing",                     "lachen.wav"            },
+  { "game.winning",                    SND_FILE_UNDEFINED      },
+
+  /* sounds for other non-game actions */
+  { "menu.door_opening",               "oeffnen.wav"           },
+  { "menu.door_closing",               "oeffnen.wav"           },
+  { "menu.hall_of_fame",               "halloffame.wav"        },
+  { "menu.info_screen",                        "rhythmloop.wav"        },
+
+#if 0
+  { "[not used]",                      "antigrav.wav"          },
+  { "[not used]",                      "bong.wav"              },
+  { "[not used]",                      "fuel.wav"              },
+  { "[not used]",                      "holz.wav"              },
+  { "[not used]",                      "hui.wav"               },
+  { "[not used]",                      "kabumm.wav"            },
+  { "[not used]",                      "kink.wav"              },
+  { "[not used]",                      "kling.wav"             },
+  { "[not used]",                      "krach.wav"             },
+  { "[not used]",                      "laser.wav"             },
+  { "[not used]",                      "quiek.wav"             },
+  { "[not used]",                      "rumms.wav"             },
+  { "[not used]",                      "schlopp.wav"           },
+  { "[not used]",                      "schrff.wav"            },
+  { "[not used]",                      "schwirr.wav"           },
+  { "[not used]",                      "slurp.wav"             },
+  { "[not used]",                      "sproing.wav"           },
+  { "[not used]",                      "warnton.wav"           },
+  { "[not used]",                      "whoosh.wav"            },
+  { "[not used]",                      "boom.wav"              },
+#endif
 };
-int num_bg_loops = sizeof(background_loop)/sizeof(int);
 
 char *element_info[] =
 {
@@ -323,7 +443,7 @@ char *element_info[] =
   "normal wall (BD style)",
   "rock (BD style)",
   "open exit",
-  "unknown",
+  "black orb bomb",
   "amoeba",
   "mole",                                      /* 110 */
   "penguin",
@@ -334,7 +454,7 @@ char *element_info[] =
   "arrow down",
   "pig",
   "fire breathing dragon",
-  "unknown",
+  "red key (EM style)",
   "letter ' '",                                        /* 120 */
   "letter '!'",
   "letter '\"'",
@@ -418,13 +538,13 @@ char *element_info[] =
   "growing wall (horizontal)",                 /* 200 */
   "growing wall (vertical)",
   "growing wall (all directions)",
-  "unused",
-  "unused",
-  "unused",
-  "unused",
-  "unused",
-  "unused",
-  "unused",
+  "red door (EM style)",
+  "yellow door (EM style)",
+  "green door (EM style)",
+  "blue door (EM style)",
+  "yellow key (EM style)",
+  "green key (EM style)",
+  "blue key (EM style)",
   "empty space",                               /* 210 */
   "zonk",
   "base",
@@ -465,10 +585,10 @@ char *element_info[] =
   "hardware",
   "chip (upper half)",
   "chip (lower half)",
-  "unknown",                                   /* 250 */
-  "unknown",
-  "unknown",
-  "unknown",
+  "gray door (EM style, red key)",             /* 250 */
+  "gray door (EM style, yellow key)",
+  "gray door (EM style, green key)",
+  "gray door (EM style, blue key)",
   "unknown",
   "unknown",
 
@@ -585,406 +705,18 @@ char *element_info[] =
 int num_element_info = sizeof(element_info)/sizeof(char *);
 
 
-
-/* +-----------------------------------------------------------------------+ */
-/* | SDL TEST STUFF                                                        | */
-/* +-----------------------------------------------------------------------+ */
-
-#if defined(TARGET_SDL)
-
-SDL_Surface *sdl_screen, *sdl_image_tmp, *sdl_image, *sdl_image_masked;
-SDL_Surface *sdl_image2_tmp, *sdl_image2, *sdl_image2_masked;
-
-void TEST_SDL_BLIT_RECT(int x, int y)
-{
-  SDL_Rect rect_src, rect_dst;
-
-  SDLCopyArea(pix_masked[PIX_HEROES], window,
-             8 * TILEX, 8 * TILEY, TILEX, TILEY, x, y);
-  return;
-
-  rect_src.x = 8 * TILEX;
-  rect_src.y = 8 * TILEY;
-  rect_src.w = TILEX;
-  rect_src.h = TILEY;
-
-  rect_dst.x = x;
-  rect_dst.y = y;
-  rect_dst.w = TILEX;
-  rect_dst.h = TILEY;
-
-  SDL_BlitSurface(sdl_image2_masked, &rect_src, sdl_screen, &rect_dst);
-  SDL_UpdateRect(sdl_screen, x, y, TILEX, TILEY);
-}
-
-void TEST_SDL_INIT_DISPLAY()
-{
-  SDL_Rect rect_src, rect_dst;
-
-  if (SDL_Init(SDL_INIT_VIDEO) < 0)
-  {
-    fprintf(stderr, "SDL_Init() failed: %s\n", SDL_GetError());
-    exit(1);
-  }
-
-  /* automatically cleanup SDL stuff after exit() */
-  atexit(SDL_Quit);
-
-  if ((sdl_screen = SDL_SetVideoMode(WIN_XSIZE, WIN_YSIZE, 16, SDL_HWSURFACE))
-      == NULL)
-  {
-    fprintf(stderr, "SDL_SetVideoMode() failed: %s\n", SDL_GetError());
-    exit(1);
-  }
-
-  SDL_WM_SetCaption(WINDOW_TITLE_STRING, WINDOW_TITLE_STRING);
-
-  if ((sdl_image_tmp = IMG_Load("graphics/RocksScreen.pcx")) == NULL)
-  {
-    fprintf(stderr, "IMG_Load() failed: %s\n", SDL_GetError());
-    exit(1);
-  }
-
-  sdl_image = SDL_DisplayFormat(sdl_image_tmp);
-
-  SDL_SetColorKey(sdl_image_tmp, SDL_SRCCOLORKEY,
-                 SDL_MapRGB(sdl_image_tmp->format, 0x00, 0x00, 0x00));
-  sdl_image_masked = SDL_DisplayFormat(sdl_image_tmp);
-
-  SDL_FreeSurface(sdl_image_tmp);
-
-  if ((sdl_image2_tmp = IMG_Load("graphics/RocksHeroes.pcx")) == NULL)
-  {
-    fprintf(stderr, "IMG_Load() failed: %s\n", SDL_GetError());
-    exit(1);
-  }
-
-  sdl_image2 = SDL_DisplayFormat(sdl_image2_tmp);
-  SDL_FreeSurface(sdl_image2_tmp);
-
-  sdl_image2_masked = SDL_DisplayFormat(sdl_image2);
-  SDL_SetColorKey(sdl_image2_masked, SDL_SRCCOLORKEY,
-                 SDL_MapRGB(sdl_image2_masked->format, 0x00, 0x00, 0x00));
-
-  rect_src.x = 0;
-  rect_src.y = 0;
-  rect_src.w = sdl_image->w;
-  rect_src.h = sdl_image->h;
-
-  rect_dst.x = 0;
-  rect_dst.y = 0;
-  rect_dst.w = sdl_image->w;
-  rect_dst.h = sdl_image->h;
-                                           
-  SDL_BlitSurface(sdl_image, &rect_src, sdl_screen, &rect_dst);
-
-  /*
-  SDL_UpdateRect(sdl_screen, 0, 0, WIN_XSIZE, WIN_YSIZE);
-  */
-  /*
-  SDL_UpdateRect(sdl_screen, 0, 0, 0, 0);
-  */
-  SDL_Flip(sdl_screen);
-
-  /*
-  SDL_Delay(5000);
-  */
-}
-
-void TEST_SDL_EVENT_LOOP()
-{
-  int quit_loop = 0;
-
-  SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
-
-  /*
-  while (!quit_loop && SDL_WaitEvent(&event) >=0)
-  */
-
-  while (!quit_loop)
-  {
-    SDL_Event event;
-
-    if (SDL_PollEvent(&event))
-    {
-      /* hier werden die Ereignisse behandelt */
-      switch(event.type)
-      {
-        case SDL_QUIT:
-       {
-         quit_loop = 1;
-         break;
-       }
-
-        case SDL_MOUSEBUTTONDOWN:
-       {
-         int x = event.button.x;
-         int y = event.button.y;
-
-         SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
-
-         TEST_SDL_BLIT_RECT(x, y);
-
-         printf("SDL_MOUSEBUTTONDOWN(%d, %d)\n", x, y);
-         break;
-       }
-
-        case SDL_MOUSEBUTTONUP:
-       {
-         int x = event.button.x;
-         int y = event.button.y;
-
-         SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
-
-         printf("SDL_MOUSEBUTTONUP(%d, %d)\n", x, y);
-         break;
-       }
-
-        case SDL_MOUSEMOTION:
-       {
-         int x = event.motion.x;
-         int y = event.motion.y;
-
-         TEST_SDL_BLIT_RECT(x, y);
-
-         printf("SDL_MOUSEMOTION(%d, %d)\n", x, y);
-         break;
-       }
-
-        default:
-         break;
-      }
-    }
-
-    if (!SDL_PollEvent(NULL))  /* delay only if no pending events */
-    {
-      printf("waiting...\n");
-      Delay(100);
-    }
-  }
-
-  SDL_FreeSurface(sdl_image);
-  SDL_Quit();
-}
-
-#define SCREEN_WIDTH   640
-#define SCREEN_HEIGHT  480
-
-void WatchJoysticks()
-{
-       SDL_Surface *screen;
-       const char *name;
-       int i, done;
-       SDL_Event event;
-       int x, y, draw;
-       SDL_Rect axis_area[2];
-       int joystick_nr = 0;
-       SDL_Joystick *joystick = Get_SDL_Joystick(joystick_nr);
-
-       /* Set a video mode to display joystick axis position */
-       screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 16, 0);
-       if ( screen == NULL ) {
-               fprintf(stderr, "Couldn't set video mode: %s\n",SDL_GetError());
-               return;
-       }
-
-       /* Print info about the joysticks we are watching */
-       for (i=0; i<2; i++)
-       {
-         joystick = Get_SDL_Joystick(i);
-
-         name = SDL_JoystickName(i);
-         printf("Watching joystick %d: (%s)\n", i,
-                name ? name : "Unknown Joystick");
-         printf("Joystick has %d axes, %d hats, %d balls, and %d buttons\n",
-                SDL_JoystickNumAxes(joystick),
-                SDL_JoystickNumHats(joystick),
-                SDL_JoystickNumBalls(joystick),
-                SDL_JoystickNumButtons(joystick));
-       }
-
-       /* Initialize drawing rectangles */
-       memset(axis_area, 0, (sizeof axis_area));
-       draw = 0;
-
-       /* Loop, getting joystick events! */
-       done = 0;
-       while ( ! done ) {
-               while ( SDL_PollEvent(&event) ) {
-                       switch (event.type) {
-                           case SDL_JOYAXISMOTION:
-                             joystick_nr = event.jaxis.which;
-                               printf("Joystick %d axis %d value: %d\n",
-                                      event.jaxis.which,
-                                      event.jaxis.axis,
-                                      event.jaxis.value);
-                               break;
-                           case SDL_JOYHATMOTION:
-                             joystick_nr = event.jaxis.which;
-                               printf("Joystick %d hat %d value:",
-                                      event.jhat.which,
-                                      event.jhat.hat);
-                               if ( event.jhat.value == SDL_HAT_CENTERED )
-                                       printf(" centered");
-                               if ( event.jhat.value & SDL_HAT_UP )
-                                       printf(" up");
-                               if ( event.jhat.value & SDL_HAT_RIGHT )
-                                       printf(" right");
-                               if ( event.jhat.value & SDL_HAT_DOWN )
-                                       printf(" down");
-                               if ( event.jhat.value & SDL_HAT_LEFT )
-                                       printf(" left");
-                               printf("\n");
-                               break;
-                           case SDL_JOYBALLMOTION:
-                             joystick_nr = event.jaxis.which;
-                               printf("Joystick %d ball %d delta: (%d,%d)\n",
-                                      event.jball.which,
-                                      event.jball.ball,
-                                      event.jball.xrel,
-                                      event.jball.yrel);
-                               break;
-                           case SDL_JOYBUTTONDOWN:
-                             joystick_nr = event.jaxis.which;
-                               printf("Joystick %d button %d down\n",
-                                      event.jbutton.which,
-                                      event.jbutton.button);
-                               break;
-                           case SDL_JOYBUTTONUP:
-                             joystick_nr = event.jaxis.which;
-                               printf("Joystick %d button %d up\n",
-                                      event.jbutton.which,
-                                      event.jbutton.button);
-                               break;
-                           case SDL_KEYDOWN:
-                               if ( event.key.keysym.sym != SDLK_ESCAPE ) {
-                                       break;
-                               }
-                               /* Fall through to signal quit */
-                           case SDL_QUIT:
-                               done = 1;
-                               break;
-                           default:
-                               break;
-                       }
-               }
-
-               joystick = Get_SDL_Joystick(joystick_nr);               
-
-               /* Update visual joystick state */
-               for ( i=0; i<SDL_JoystickNumButtons(joystick); ++i ) {
-                       SDL_Rect area;
-
-                       area.x = i*34;
-                       area.y = SCREEN_HEIGHT-34;
-                       area.w = 32;
-                       area.h = 32;
-                       if (SDL_JoystickGetButton(joystick, i) == SDL_PRESSED) {
-                               SDL_FillRect(screen, &area, 0xFFFF);
-                       } else {
-                               SDL_FillRect(screen, &area, 0x0000);
-                       }
-                       SDL_UpdateRects(screen, 1, &area);
-               }
-
-               /* Erase previous axes */
-               SDL_FillRect(screen, &axis_area[draw], 0x0000);
-
-               /* Draw the X/Y axis */
-               draw = !draw;
-               x = (((int)SDL_JoystickGetAxis(joystick, 0))+32768);
-               x *= SCREEN_WIDTH;
-               x /= 65535;
-               if ( x < 0 ) {
-                       x = 0;
-               } else
-               if ( x > (SCREEN_WIDTH-16) ) {
-                       x = SCREEN_WIDTH-16;
-               }
-               y = (((int)SDL_JoystickGetAxis(joystick, 1))+32768);
-               y *= SCREEN_HEIGHT;
-               y /= 65535;
-               if ( y < 0 ) {
-                       y = 0;
-               } else
-               if ( y > (SCREEN_HEIGHT-16) ) {
-                       y = SCREEN_HEIGHT-16;
-               }
-               axis_area[draw].x = (Sint16)x;
-               axis_area[draw].y = (Sint16)y;
-               axis_area[draw].w = 16;
-               axis_area[draw].h = 16;
-               SDL_FillRect(screen, &axis_area[draw], 0xFFFF);
-
-               SDL_UpdateRects(screen, 2, axis_area);
-       }
-}
-
-void TEST_SDL_JOYSTICK()
-{
-  const char *name;
-  int i;
-
-  /* Initialize SDL (Note: video is required to start event loop) */
-  if ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK) < 0 )
-  {
-    fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
-    exit(1);
-  }
-
-  /* Print information about the joysticks */
-  printf("There are %d joysticks attached\n", SDL_NumJoysticks());
-  for ( i=0; i<SDL_NumJoysticks(); ++i )
-  {
-    name = SDL_JoystickName(i);
-    printf("Joystick %d: %s\n",i,name ? name : "Unknown Joystick");
-  }
-
-  for (i=0; i<2; i++)
-  {
-    if (!Open_SDL_Joystick(i))
-      printf("Couldn't open joystick %d: %s\n", i, SDL_GetError());
-  }
-
-  WatchJoysticks();
-
-  for (i=0; i<2; i++)
-    Close_SDL_Joystick(i);
-
-  SDL_QuitSubSystem(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK);
-}
-
-#endif /* TARGET_SDL */
-
-/* +-----------------------------------------------------------------------+ */
-/* | SDL TEST STUFF                                                        | */
-/* +-----------------------------------------------------------------------+ */
-
-
+/* ========================================================================= */
+/* main()                                                                    */
+/* ========================================================================= */
 
 int main(int argc, char *argv[])
 {
-  program_name = (strrchr(argv[0],'/') ? strrchr(argv[0],'/') + 1 : argv[0]);
+  InitCommandName(argv[0]);
+  InitExitFunction(CloseAllAndExit);
+  InitPlatformDependantStuff();
 
-#if defined(PLATFORM_MSDOS)
-  _fmode = O_BINARY;
-#endif
-
-#if 1
   GetOptions(argv);
-  OpenAll(argc,argv);
-#endif
-
-#if 0
-#ifdef TARGET_SDL
-  /*
-  TEST_SDL_BLIT_RECT((WIN_XSIZE - TILEX)/2, (WIN_YSIZE - TILEY)/2);
-  TEST_SDL_EVENT_LOOP();
-  */
-  TEST_SDL_JOYSTICK();
-  exit(0);
-#endif
-#endif
+  OpenAll();
 
   EventLoop();
   CloseAllAndExit(0);