projects / rocksndiamonds.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: ee9f14e)
updated various names of EM engine specific definitions
authorHolger Schemel <info@artsoft.org>
Sun, 19 Jan 2020 01:11:50 +0000 (02:11 +0100)
committerHolger Schemel <info@artsoft.org>
Tue, 19 May 2020 16:12:55 +0000 (18:12 +0200)
This is the first part of various code changes of the EM engine to
update the engine code to the 2009 version of the source code.

12 files changed:
src/files.c patch | blob | history
src/game.c patch | blob | history
src/game_em/convert.c patch | blob | history
src/game_em/emerald.h patch | blob | history
src/game_em/export.h patch | blob | history
src/game_em/input.c patch | blob | history
src/game_em/main_em.h patch | blob | history
src/game_em/synchro_1.c patch | blob | history
src/game_em/synchro_2.c patch | blob | history
src/game_em/synchro_3.c patch | blob | history
src/game_em/tab_generate.c patch | blob | history
src/tools.c patch | blob | history

diff --git a/src/files.c b/src/files.c
index 27aa3abebb574f85e55422e97104b127b6896c87..7224337dd1f7e4af61cf95a05450bef276fb05e3 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -3576,7 +3576,7 @@ static void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
   // first fill the complete playfield with the default border element
   for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
     for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
-      level_em->cave[x][y] = ZBORDER;
+      level_em->cave[x][y] = Zborder;
 
   if (BorderElement == EL_STEELWALL)
   {
diff --git a/src/game.c b/src/game.c
index 57771d75b866c7f4995fefb43eea95ad94830fd5..e281c12727d650b10176bb4b72431a3aa26d34ce 100644 (file)
--- a/src/game.c
+++ b/src/game.c
@@ -14708,71 +14708,71 @@ void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
 
   switch (sample)
   {
-    case SAMPLE_blank:
+    case SOUND_blank:
       PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
       break;
 
-    case SAMPLE_roll:
+    case SOUND_roll:
       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
       break;
 
-    case SAMPLE_stone:
+    case SOUND_stone:
       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
       break;
 
-    case SAMPLE_nut:
+    case SOUND_nut:
       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
       break;
 
-    case SAMPLE_crack:
+    case SOUND_crack:
       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
       break;
 
-    case SAMPLE_bug:
+    case SOUND_bug:
       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
       break;
 
-    case SAMPLE_tank:
+    case SOUND_tank:
       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
       break;
 
-    case SAMPLE_android_clone:
+    case SOUND_android_clone:
       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
       break;
 
-    case SAMPLE_android_move:
+    case SOUND_android_move:
       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
       break;
 
-    case SAMPLE_spring:
+    case SOUND_spring:
       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
       break;
 
-    case SAMPLE_slurp:
+    case SOUND_slurp:
       PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
       break;
 
-    case SAMPLE_eater:
+    case SOUND_eater:
       PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
       break;
 
-    case SAMPLE_eater_eat:
+    case SOUND_eater_eat:
       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
       break;
 
-    case SAMPLE_alien:
+    case SOUND_alien:
       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
       break;
 
-    case SAMPLE_collect:
+    case SOUND_collect:
       PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
       break;
 
-    case SAMPLE_diamond:
+    case SOUND_diamond:
       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
       break;
 
-    case SAMPLE_squash:
+    case SOUND_squash:
       // !!! CHECK THIS !!!
 #if 1
       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
@@ -14781,75 +14781,75 @@ void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
 #endif
       break;
 
-    case SAMPLE_wonderfall:
+    case SOUND_wonderfall:
       PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
       break;
 
-    case SAMPLE_drip:
+    case SOUND_drip:
       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
       break;
 
-    case SAMPLE_push:
+    case SOUND_push:
       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
       break;
 
-    case SAMPLE_dirt:
+    case SOUND_dirt:
       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
       break;
 
-    case SAMPLE_acid:
+    case SOUND_acid:
       PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
       break;
 
-    case SAMPLE_ball:
+    case SOUND_ball:
       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
       break;
 
-    case SAMPLE_grow:
+    case SOUND_slidewall:
       PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
       break;
 
-    case SAMPLE_wonder:
+    case SOUND_wonder:
       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
       break;
 
-    case SAMPLE_door:
+    case SOUND_door:
       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
       break;
 
-    case SAMPLE_exit_open:
+    case SOUND_exit_open:
       PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
       break;
 
-    case SAMPLE_exit_leave:
+    case SOUND_exit_leave:
       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
       break;
 
-    case SAMPLE_dynamite:
+    case SOUND_dynamite:
       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
       break;
 
-    case SAMPLE_tick:
+    case SOUND_tick:
       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
       break;
 
-    case SAMPLE_press:
+    case SOUND_press:
       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
       break;
 
-    case SAMPLE_wheel:
+    case SOUND_wheel:
       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
       break;
 
-    case SAMPLE_boom:
+    case SOUND_boom:
       PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
       break;
 
-    case SAMPLE_die:
+    case SOUND_die:
       PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
       break;
 
-    case SAMPLE_time:
+    case SOUND_time:
       PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
       break;
 
diff --git a/src/game_em/convert.c b/src/game_em/convert.c
index d61e33eec5db472f1f55df60d9bad4b77221fe8b..d8157a695b748d521fb34d5969d7fa8a6a5a6fdc 100644 (file)
--- a/src/game_em/convert.c
+++ b/src/game_em/convert.c
@@ -523,13 +523,13 @@ static unsigned short remap_emerald[256] =
 {
   Xstone,              Xstone,         Xdiamond,       Xdiamond,
   Xalien,              Xalien,         Xblank,         Xblank,
-  Xtank_n,             Xtank_e,        Xtank_s,        Xtank_w,
-  Xtank_gon,           Xtank_goe,      Xtank_gos,      Xtank_gow,
+  Xtank_1_n,           Xtank_1_e,      Xtank_1_s,      Xtank_1_w,
+  Xtank_2_n,           Xtank_2_e,      Xtank_2_s,      Xtank_2_w,
 
   Xbomb,               Xbomb,          Xemerald,       Xemerald,
-  Xbug_n,              Xbug_e,         Xbug_s,         Xbug_w,
-  Xbug_gon,            Xbug_goe,       Xbug_gos,       Xbug_gow,
-  Xdrip_eat,           Xdrip_eat,      Xdrip_eat,      Xdrip_eat,
+  Xbug_1_n,            Xbug_1_e,       Xbug_1_s,       Xbug_1_w,
+  Xbug_2_n,            Xbug_2_e,       Xbug_2_s,       Xbug_2_w,
+  Xdrip,               Xdrip,          Xdrip,          Xdrip,
 
   Xstone,              Xbomb,          Xdiamond,       Xemerald,
   Xwonderwall,         Xnut,           Xnut,           Xnut,
@@ -538,7 +538,7 @@ static unsigned short remap_emerald[256] =
 
   Xblank,              Xsand,          Xsand,          Xsand,
   Xsand_stone,         Xsand_stone,    Xsand_stone,    Xsand,
-  Xstone,              Xgrow_ew,       Xgrow_ns,       Xdynamite_1,
+  Xstone,              Xslidewall_ew,  Xslidewall_ns,  Xdynamite_1,
   Xdynamite_2,         Xdynamite_3,    Xdynamite_4,    Xacid_s,
 
 #ifdef ALLOW_ROLLING_SPRING
@@ -560,14 +560,14 @@ static unsigned short remap_emerald[256] =
 
 #ifdef BAD_ROLL
 
-  Xblank,              Xblank,         Xblank,         Xspring_force_w,
-  Xspring_force_e,     Xacid_1,        Xacid_2,        Xacid_3,
+  Xblank,              Xblank,         Xblank,         Xpush_spring_w,
+  Xpush_spring_e,      Xacid_1,        Xacid_2,        Xacid_3,
   Xacid_4,             Xacid_5,        Xacid_6,        Xacid_7,
   Xacid_8,             Xblank,         Xblank,         Xblank,
 
-  Xblank,              Xblank,         Xnut_force_w,   Xnut_force_e,
-  Xsteel_1,            Xblank,         Xblank,         Xbomb_force_w,
-  Xbomb_force_e,       Xstone_force_w, Xstone_force_e, Xblank,
+  Xblank,              Xblank,         Xpush_nut_w,    Xpush_nut_e,
+  Xsteel_1,            Xblank,         Xblank,         Xpush_bomb_w,
+  Xpush_bomb_e,                Xpush_stone_w,  Xpush_stone_e,  Xblank,
   Xblank,              Xblank,         Xblank,         Xblank,
 
 #else
@@ -584,10 +584,10 @@ static unsigned short remap_emerald[256] =
 
 #endif
 
-  Xblank,              Xround_wall_1,  Xgrass,         Xsteel_1,
+  Xblank,              Xroundwall_1,   Xgrass,         Xsteel_1,
   Xwall_1,             Xkey_1,         Xkey_2,         Xkey_3,
   Xkey_4,              Xdoor_1,        Xdoor_2,        Xdoor_3,
-  Xdoor_4,             Xdripper,       Xfake_door_1,   Xfake_door_2,
+  Xdoor_4,             Xfake_amoeba,   Xfake_door_1,   Xfake_door_2,
 
   Xfake_door_3,                Xfake_door_4,   Xwonderwall,    Xwheel,
   Xsand,               Xacid_nw,       Xacid_ne,       Xacid_sw,
@@ -600,8 +600,8 @@ static unsigned short remap_emerald[256] =
   Xalpha_comma,                Xalpha_quote,   Xalpha_minus,   Xdynamite,
 
   Xsteel_3,            Xdecor_6,       Xdecor_7,       Xsteel_2,
-  Xround_wall_2,       Xdecor_2,       Xdecor_4,       Xdecor_3,
-  Xwind_nesw,          Xwind_e,        Xwind_s,        Xwind_w,
+  Xroundwall_2,                Xdecor_2,       Xdecor_4,       Xdecor_3,
+  Xwind_any,           Xwind_e,        Xwind_s,        Xwind_w,
   Xwind_n,             Xdirt,          Xplant,         Xkey_5,
 
   Xkey_6,              Xkey_7,         Xkey_8,         Xdoor_5,
@@ -791,29 +791,29 @@ void convert_em_level(unsigned char *src, int file_version)
 
   if (temp & 32)
   {
-    lev.android_array[Xtank_n]         = Xtank_n;
-    lev.android_array[Xtank_gon]       = Xtank_n;
-    lev.android_array[Ytank_nB]                = Xtank_n;
-    lev.android_array[Ytank_n_e]       = Xtank_n;
-    lev.android_array[Ytank_n_w]       = Xtank_n;
-
-    lev.android_array[Xtank_e]         = Xtank_e;
-    lev.android_array[Xtank_goe]       = Xtank_e;
-    lev.android_array[Ytank_eB]                = Xtank_e;
-    lev.android_array[Ytank_e_s]       = Xtank_e;
-    lev.android_array[Ytank_e_n]       = Xtank_e;
-
-    lev.android_array[Xtank_s]         = Xtank_s;
-    lev.android_array[Xtank_gos]       = Xtank_s;
-    lev.android_array[Ytank_sB]                = Xtank_s;
-    lev.android_array[Ytank_s_w]       = Xtank_s;
-    lev.android_array[Ytank_s_e]       = Xtank_s;
-
-    lev.android_array[Xtank_w]         = Xtank_w;
-    lev.android_array[Xtank_gow]       = Xtank_w;
-    lev.android_array[Ytank_wB]                = Xtank_w;
-    lev.android_array[Ytank_w_n]       = Xtank_w;
-    lev.android_array[Ytank_w_s]       = Xtank_w;
+    lev.android_array[Xtank_1_n]       = Xtank_1_n;
+    lev.android_array[Xtank_2_n]       = Xtank_1_n;
+    lev.android_array[Ytank_nB]                = Xtank_1_n;
+    lev.android_array[Ytank_n_e]       = Xtank_1_n;
+    lev.android_array[Ytank_n_w]       = Xtank_1_n;
+
+    lev.android_array[Xtank_1_e]       = Xtank_1_e;
+    lev.android_array[Xtank_2_e]       = Xtank_1_e;
+    lev.android_array[Ytank_eB]                = Xtank_1_e;
+    lev.android_array[Ytank_e_s]       = Xtank_1_e;
+    lev.android_array[Ytank_e_n]       = Xtank_1_e;
+
+    lev.android_array[Xtank_1_s]       = Xtank_1_s;
+    lev.android_array[Xtank_2_s]       = Xtank_1_s;
+    lev.android_array[Ytank_sB]                = Xtank_1_s;
+    lev.android_array[Ytank_s_w]       = Xtank_1_s;
+    lev.android_array[Ytank_s_e]       = Xtank_1_s;
+
+    lev.android_array[Xtank_1_w]       = Xtank_1_w;
+    lev.android_array[Xtank_2_w]       = Xtank_1_w;
+    lev.android_array[Ytank_wB]                = Xtank_1_w;
+    lev.android_array[Ytank_w_n]       = Xtank_1_w;
+    lev.android_array[Ytank_w_s]       = Xtank_1_w;
   }
 
   if (temp & 64)
@@ -833,29 +833,29 @@ void convert_em_level(unsigned char *src, int file_version)
 
   if (temp & 128)
   {
-    lev.android_array[Xbug_n]          = Xbug_gon;
-    lev.android_array[Xbug_gon]                = Xbug_gon;
-    lev.android_array[Ybug_nB]         = Xbug_gon;
-    lev.android_array[Ybug_n_e]                = Xbug_gon;
-    lev.android_array[Ybug_n_w]                = Xbug_gon;
-
-    lev.android_array[Xbug_e]          = Xbug_goe;
-    lev.android_array[Xbug_goe]                = Xbug_goe;
-    lev.android_array[Ybug_eB]         = Xbug_goe;
-    lev.android_array[Ybug_e_s]                = Xbug_goe;
-    lev.android_array[Ybug_e_n]                = Xbug_goe;
-
-    lev.android_array[Xbug_s]          = Xbug_gos;
-    lev.android_array[Xbug_gos]                = Xbug_gos;
-    lev.android_array[Ybug_sB]         = Xbug_gos;
-    lev.android_array[Ybug_s_w]                = Xbug_gos;
-    lev.android_array[Ybug_s_e]                = Xbug_gos;
-
-    lev.android_array[Xbug_w]          = Xbug_gow;
-    lev.android_array[Xbug_gow]                = Xbug_gow;
-    lev.android_array[Ybug_wB]         = Xbug_gow;
-    lev.android_array[Ybug_w_n]                = Xbug_gow;
-    lev.android_array[Ybug_w_s]                = Xbug_gow;
+    lev.android_array[Xbug_1_n]                = Xbug_2_n;
+    lev.android_array[Xbug_2_n]                = Xbug_2_n;
+    lev.android_array[Ybug_nB]         = Xbug_2_n;
+    lev.android_array[Ybug_n_e]                = Xbug_2_n;
+    lev.android_array[Ybug_n_w]                = Xbug_2_n;
+
+    lev.android_array[Xbug_1_e]                = Xbug_2_e;
+    lev.android_array[Xbug_2_e]                = Xbug_2_e;
+    lev.android_array[Ybug_eB]         = Xbug_2_e;
+    lev.android_array[Ybug_e_s]                = Xbug_2_e;
+    lev.android_array[Ybug_e_n]                = Xbug_2_e;
+
+    lev.android_array[Xbug_1_s]                = Xbug_2_s;
+    lev.android_array[Xbug_2_s]                = Xbug_2_s;
+    lev.android_array[Ybug_sB]         = Xbug_2_s;
+    lev.android_array[Ybug_s_w]                = Xbug_2_s;
+    lev.android_array[Ybug_s_e]                = Xbug_2_s;
+
+    lev.android_array[Xbug_1_w]                = Xbug_2_w;
+    lev.android_array[Xbug_2_w]                = Xbug_2_w;
+    lev.android_array[Ybug_wB]         = Xbug_2_w;
+    lev.android_array[Ybug_w_n]                = Xbug_2_w;
+    lev.android_array[Ybug_w_s]                = Xbug_2_w;
   }
 
   if (temp & 256)
@@ -874,10 +874,10 @@ void convert_em_level(unsigned char *src, int file_version)
     lev.android_array[Xspring_pause]   = Xspring;
     lev.android_array[Xspring_e]       = Xspring;
     lev.android_array[Yspring_eB]      = Xspring;
-    lev.android_array[Yspring_kill_eB] = Xspring;
+    lev.android_array[Yspring_alien_eB]        = Xspring;
     lev.android_array[Xspring_w]       = Xspring;
     lev.android_array[Yspring_wB]      = Xspring;
-    lev.android_array[Yspring_kill_wB] = Xspring;
+    lev.android_array[Yspring_alien_wB]        = Xspring;
     lev.android_array[Xspring_fall]    = Xspring;
     lev.android_array[Yspring_sB]      = Xspring;
   }
@@ -893,16 +893,16 @@ void convert_em_level(unsigned char *src, int file_version)
 
   if (temp & 2048)
   {
-    lev.android_array[Xdripper]                = Xdrip_eat;
-    lev.android_array[XdripperB]       = Xdrip_eat;
-    lev.android_array[Xamoeba_1]       = Xdrip_eat;
-    lev.android_array[Xamoeba_2]       = Xdrip_eat;
-    lev.android_array[Xamoeba_3]       = Xdrip_eat;
-    lev.android_array[Xamoeba_4]       = Xdrip_eat;
-    lev.android_array[Xamoeba_5]       = Xdrip_eat;
-    lev.android_array[Xamoeba_6]       = Xdrip_eat;
-    lev.android_array[Xamoeba_7]       = Xdrip_eat;
-    lev.android_array[Xamoeba_8]       = Xdrip_eat;
+    lev.android_array[Xfake_amoeba]    = Xdrip;
+    lev.android_array[Xfake_amoebaB]   = Xdrip;
+    lev.android_array[Xamoeba_1]       = Xdrip;
+    lev.android_array[Xamoeba_2]       = Xdrip;
+    lev.android_array[Xamoeba_3]       = Xdrip;
+    lev.android_array[Xamoeba_4]       = Xdrip;
+    lev.android_array[Xamoeba_5]       = Xdrip;
+    lev.android_array[Xamoeba_6]       = Xdrip;
+    lev.android_array[Xamoeba_7]       = Xdrip;
+    lev.android_array[Xamoeba_8]       = Xdrip;
   }
 
   if (temp & 4096)
@@ -980,7 +980,7 @@ void convert_em_level(unsigned char *src, int file_version)
   /* first fill the complete playfield with the default border element */
   for (y = 0; y < HEIGHT; y++)
     for (x = 0; x < WIDTH; x++)
-      native_em_level.cave[x][y] = ZBORDER;
+      native_em_level.cave[x][y] = Zborder;
 
   /* then copy the real level contents from level file into the playfield */
   temp = 0;
diff --git a/src/game_em/emerald.h b/src/game_em/emerald.h
index 3329c4883abf31a2965ae2ec26d65155b86b2dd1..55f90e4705f3ba1d4d053ac15c6476d8a4e67f80 100644 (file)
--- a/src/game_em/emerald.h
+++ b/src/game_em/emerald.h
@@ -1,7 +1,48 @@
+/*
+
+This program "Emerald Mine for X11"
+is copyright © 2009 David Tritscher.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. The origin of this software must not be misrepresented; you must
+   not claim that you wrote the original software.  If you use this
+   software in a product, an acknowledgment in the product
+   documentation would be appreciated but is not required.
+
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+/* 2007-03-31 06:22:47
+ *
+ * emerald mine game engine defines
+ */
+
+// ----------------------------------------------------------------------------
+// EM game engine source code was altered for integration in Rocks'n'Diamonds
+// ----------------------------------------------------------------------------
+
 #ifndef EMERALD_H
 #define EMERALD_H
 
-/* 2000-07-30T11:06:03Z */
 
 // ----------------------------------------------------------------------------
 // constant definitions
@@ -23,7 +64,7 @@
 #define BAD_SPRING
 #endif
 
-/* one border for ZBORDER elements, one border for steelwall, if needed */
+/* one border for Zborder elements, one border for steelwall, if needed */
 #define EM_MAX_CAVE_WIDTH              (MAX_PLAYFIELD_WIDTH  + 2 + 2)
 #define EM_MAX_CAVE_HEIGHT             (MAX_PLAYFIELD_HEIGHT + 2 + 2)
 
@@ -39,23 +80,23 @@
 
 enum
 {
-  Xblank = 0,          /* still */
-  Yacid_splash_eB,     /* hmm */
-  Yacid_splash_wB,     /* hmm */
+  Xblank = 0,
+  Xacid_splash_e,
+  Xacid_splash_w,
 
 #ifdef EM_ENGINE_BAD_ROLL
-  Xstone_force_e,      /* only use these in eater */
-  Xstone_force_w,
-  Xnut_force_e,
-  Xnut_force_w,
-  Xspring_force_e,
-  Xspring_force_w,
-  Xemerald_force_e,
-  Xemerald_force_w,
-  Xdiamond_force_e,
-  Xdiamond_force_w,
-  Xbomb_force_e,
-  Xbomb_force_w,
+  Xpush_stone_e,
+  Xpush_stone_w,
+  Xpush_nut_e,
+  Xpush_nut_w,
+  Xpush_spring_e,
+  Xpush_spring_w,
+  Xpush_emerald_e,
+  Xpush_emerald_w,
+  Xpush_diamond_e,
+  Xpush_diamond_w,
+  Xpush_bomb_e,
+  Xpush_bomb_w,
 #endif
 
   Xstone,
@@ -76,14 +117,14 @@ enum
   Ynut_eB,
   Ynut_w,
   Ynut_wB,
-  Xbug_n,
-  Xbug_e,
-  Xbug_s,
-  Xbug_w,
-  Xbug_gon,
-  Xbug_goe,
-  Xbug_gos,
-  Xbug_gow,
+  Xbug_1_n,
+  Xbug_1_e,
+  Xbug_1_s,
+  Xbug_1_w,
+  Xbug_2_n,
+  Xbug_2_e,
+  Xbug_2_s,
+  Xbug_2_w,
   Ybug_n,
   Ybug_nB,
   Ybug_e,
@@ -102,14 +143,14 @@ enum
   Ybug_n_w,
   Ybug_stone,
   Ybug_spring,
-  Xtank_n,
-  Xtank_e,
-  Xtank_s,
-  Xtank_w,
-  Xtank_gon,
-  Xtank_goe,
-  Xtank_gos,
-  Xtank_gow,
+  Xtank_1_n,
+  Xtank_1_e,
+  Xtank_1_s,
+  Xtank_1_w,
+  Xtank_2_n,
+  Xtank_2_e,
+  Xtank_2_s,
+  Xtank_2_w,
   Ytank_n,
   Ytank_nB,
   Ytank_e,
@@ -164,10 +205,10 @@ enum
   Yspring_eB,
   Yspring_w,
   Yspring_wB,
-  Yspring_kill_e,
-  Yspring_kill_eB,
-  Yspring_kill_w,
-  Yspring_kill_wB,
+  Yspring_alien_e,
+  Yspring_alien_eB,
+  Yspring_alien_w,
+  Yspring_alien_wB,
   Xeater_n,
   Xeater_e,
   Xeater_w,
@@ -204,8 +245,8 @@ enum
   Yemerald_eB,
   Yemerald_w,
   Yemerald_wB,
-  Yemerald_eat,
-  Yemerald_stone,
+  Yemerald_blank,
+  Ynut_stone,
   Xdiamond,
   Xdiamond_pause,
   Xdiamond_fall,
@@ -216,16 +257,16 @@ enum
   Ydiamond_eB,
   Ydiamond_w,
   Ydiamond_wB,
-  Ydiamond_eat,
+  Ydiamond_blank,
   Ydiamond_stone,
   Xdrip_fall,
   Xdrip_stretch,
   Xdrip_stretchB,
-  Xdrip_eat,
-  Ydrip_s1,
-  Ydrip_s1B,
-  Ydrip_s2,
-  Ydrip_s2B,
+  Xdrip,
+  Ydrip_1_s,
+  Ydrip_1_sB,
+  Ydrip_2_s,
+  Ydrip_2_sB,
   Xbomb,
   Xbomb_pause,
   Xbomb_fall,
@@ -235,7 +276,7 @@ enum
   Ybomb_eB,
   Ybomb_w,
   Ybomb_wB,
-  Ybomb_eat,
+  Ybomb_blank,
   Xballoon,
   Yballoon_n,
   Yballoon_nB,
@@ -269,30 +310,30 @@ enum
   Xacid_7,
   Xacid_8,
   Xball_1,
-  Xball_1B,
+  Yball_1,
   Xball_2,
-  Xball_2B,
-  Yball_eat,
+  Yball_2,
+  Yball_blank,
 
 #ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
-  Ykey_1_eat,
-  Ykey_2_eat,
-  Ykey_3_eat,
-  Ykey_4_eat,
-  Ykey_5_eat,
-  Ykey_6_eat,
-  Ykey_7_eat,
-  Ykey_8_eat,
-  Ylenses_eat,
-  Ymagnify_eat,
-  Ygrass_eat,
-  Ydirt_eat,
+  Ykey_1_blank,
+  Ykey_2_blank,
+  Ykey_3_blank,
+  Ykey_4_blank,
+  Ykey_5_blank,
+  Ykey_6_blank,
+  Ykey_7_blank,
+  Ykey_8_blank,
+  Ylenses_blank,
+  Ymagnify_blank,
+  Ygrass_blank,
+  Ydirt_blank,
 #endif
 
-  Xgrow_ns,
-  Ygrow_ns_eat,
-  Xgrow_ew,
-  Ygrow_ew_eat,
+  Xslidewall_ns,       /* growing wall */
+  Yslidewall_ns_blank,
+  Xslidewall_ew,
+  Yslidewall_ew_blank,
   Xwonderwall,
   XwonderwallB,
   Xamoeba_1,
@@ -323,14 +364,14 @@ enum
   Xwind_e,
   Xwind_s,
   Xwind_w,
-  Xwind_nesw,
+  Xwind_any,
   Xwind_stop,
   Xexit,
   Xexit_1,
   Xexit_2,
   Xexit_3,
   Xdynamite,
-  Ydynamite_eat,
+  Ydynamite_blank,
   Xdynamite_1,
   Xdynamite_2,
   Xdynamite_3,
@@ -367,8 +408,8 @@ enum
   Yplant,
   Xlenses,
   Xmagnify,
-  Xdripper,
-  XdripperB,
+  Xfake_amoeba,                /* dripper */
+  Xfake_amoebaB,
   Xfake_blank,
   Xfake_blankB,
   Xfake_grass,
@@ -401,10 +442,10 @@ enum
   Xwall_2,
   Xwall_3,
   Xwall_4,
-  Xround_wall_1,
-  Xround_wall_2,
-  Xround_wall_3,
-  Xround_wall_4,
+  Xroundwall_1,
+  Xroundwall_2,
+  Xroundwall_3,
+  Xroundwall_4,
   Xdecor_1,
   Xdecor_2,
   Xdecor_3,
@@ -480,7 +521,7 @@ enum
                           no picture */
   Zplayer,             /* special code to indicate player;
                           no picture */
-  ZBORDER,             /* special code to indicate border;
+  Zborder,             /* special code to indicate border;
                           no picture */
 
   TILE_MAX
@@ -490,53 +531,62 @@ enum
 
 enum
 {
-  SPR_still = 0,
-  SPR_walk  = 1,
-  SPR_push  = 5,
-  SPR_spray = 9,
-
-  SPR_MAX   = 13
+  PLY_still = 0,
+  PLY_walk_n,
+  PLY_walk_e,
+  PLY_walk_s,
+  PLY_walk_w,
+  PLY_push_n,
+  PLY_push_e,
+  PLY_push_s,
+  PLY_push_w,
+  PLY_shoot_n,
+  PLY_shoot_e,
+  PLY_shoot_s,
+  PLY_shoot_w,
+
+  PLY_MAX
 };
 
 enum
 {
-  SAMPLE_blank = 0,    /* player walks on blank */
-  SAMPLE_roll,         /* player pushes stone/bomb/nut/spring */
-  SAMPLE_stone,                /* stone hits ground */
-  SAMPLE_nut,          /* nut hits ground */
-  SAMPLE_crack,                /* stone hits nut */
-  SAMPLE_bug,          /* bug moves */
-  SAMPLE_tank,         /* tank moves */
-  SAMPLE_android_clone,        /* android places something */
-  SAMPLE_android_move, /* android moves */
-  SAMPLE_spring,       /* spring hits ground/wall/bumper, stone hits spring */
-  SAMPLE_slurp,                /* spring kills alien */
-  SAMPLE_eater,                /* eater sits */
-  SAMPLE_eater_eat,    /* eater eats diamond */
-  SAMPLE_alien,                /* alien moves */
-  SAMPLE_collect,      /* player collects object */
-  SAMPLE_diamond,      /* diamond/emerald hits ground */
-  SAMPLE_squash,       /* stone squashes diamond */
-  SAMPLE_wonderfall,   /* object falls thru wonderwall */
-  SAMPLE_drip,         /* drip hits ground */
-  SAMPLE_push,         /* player pushes balloon/android */
-  SAMPLE_dirt,         /* player walks on dirt */
-  SAMPLE_acid,         /* acid splashes */
-  SAMPLE_ball,         /* ball places something */
-  SAMPLE_grow,         /* growing wall grows */
-  SAMPLE_wonder,       /* wonderwall is active */
-  SAMPLE_door,         /* player goes thru door (gate) */
-  SAMPLE_exit_open,    /* exit opens */
-  SAMPLE_exit_leave,   /* player goes into exit */
-  SAMPLE_dynamite,     /* player places dynamite */
-  SAMPLE_tick,         /* dynamite ticks */
-  SAMPLE_press,                /* player presses wheel/wind/switch */
-  SAMPLE_wheel,                /* wheel moves */
-  SAMPLE_boom,         /* explosion */
-  SAMPLE_time,         /* time runs out */
-  SAMPLE_die,          /* player dies */
-
-  SAMPLE_MAX
+  SOUND_blank = 0,     /* player walks on blank */
+  SOUND_roll,          /* player pushes stone/bomb/nut/spring */
+  SOUND_stone,         /* stone hits ground */
+  SOUND_nut,           /* nut hits ground */
+  SOUND_crack,         /* stone hits nut */
+  SOUND_bug,           /* bug moves */
+  SOUND_tank,          /* tank moves */
+  SOUND_android_clone, /* android places something */
+  SOUND_android_move,  /* android moves */
+  SOUND_spring,                /* spring hits ground/wall/bumper, stone hits spring */
+  SOUND_slurp,         /* spring kills alien */
+  SOUND_eater,         /* eater sits */
+  SOUND_eater_eat,     /* eater eats diamond */
+  SOUND_alien,         /* alien moves */
+  SOUND_collect,       /* player collects object */
+  SOUND_diamond,       /* diamond/emerald hits ground */
+  SOUND_squash,                /* stone squashes diamond */
+  SOUND_wonderfall,    /* object falls thru wonderwall */
+  SOUND_drip,          /* drip hits ground */
+  SOUND_push,          /* player pushes spring/balloon/android */
+  SOUND_dirt,          /* player digs into dirt */
+  SOUND_acid,          /* acid splashes */
+  SOUND_ball,          /* ball places something */
+  SOUND_slidewall,     /* slide wall grows */
+  SOUND_wonder,                /* wonderwall is active */
+  SOUND_door,          /* player goes thru door (gate) */
+  SOUND_exit_open,     /* exit opens */
+  SOUND_exit_leave,    /* player goes into exit */
+  SOUND_dynamite,      /* player places dynamite */
+  SOUND_tick,          /* dynamite ticks */
+  SOUND_press,         /* player presses wheel/wind/switch */
+  SOUND_wheel,         /* wheel moves */
+  SOUND_boom,          /* explosion */
+  SOUND_time,          /* time runs out */
+  SOUND_die,           /* player dies */
+
+  SOUND_MAX
 };
 
 
diff --git a/src/game_em/export.h b/src/game_em/export.h
index e6f25b3c5bb8ef54f1ca6483be8f5dcc9fd9b5fe..5c9864a64863046a3e72ecd8cd414fb4e3519d3b 100644 (file)
--- a/src/game_em/export.h
+++ b/src/game_em/export.h
@@ -89,7 +89,7 @@ extern struct GlobalInfo_EM global_em_info;
 extern struct GameInfo_EM game_em;
 extern struct LevelInfo_EM native_em_level;
 extern struct GraphicInfo_EM graphic_info_em_object[TILE_MAX][8];
-extern struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][SPR_MAX][8];
+extern struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][PLY_MAX][8];
 extern struct EngineSnapshotInfo_EM engine_snapshot_em;
 
 void em_open_all(void);
diff --git a/src/game_em/input.c b/src/game_em/input.c
index 9bafe55b6e5d0a6a9ec31ad50d36e739e98d7918..e3e17cb80150b4ea2e1026ab4da5830ec9885669 100644 (file)
--- a/src/game_em/input.c
+++ b/src/game_em/input.c
@@ -32,13 +32,13 @@ void game_init_vars(void)
 
   for (y = 0; y < HEIGHT; y++)
     for (x = 0; x < WIDTH; x++)
-      Array[0][y][x] = ZBORDER;
+      Array[0][y][x] = Zborder;
   for (y = 0; y < HEIGHT; y++)
     for (x = 0; x < WIDTH; x++)
-      Array[1][y][x] = ZBORDER;
+      Array[1][y][x] = Zborder;
   for (y = 0; y < HEIGHT; y++)
     for (x = 0; x < WIDTH; x++)
-      Array[2][y][x] = ZBORDER;
+      Array[2][y][x] = Zborder;
   for (y = 0; y < HEIGHT; y++)
     for (x = 0; x < WIDTH; x++)
       Array[3][y][x] = Xblank;
diff --git a/src/game_em/main_em.h b/src/game_em/main_em.h
index cde3df154a0696d710bc4533d6f0ca1b555f1e22..1376d58b545d8d308acc66c04ac473d891244b2b 100644 (file)
--- a/src/game_em/main_em.h
+++ b/src/game_em/main_em.h
@@ -97,7 +97,7 @@ extern struct PLAYER ply[MAX_PLAYERS];
 
 extern struct LevelInfo_EM native_em_level;
 extern struct GraphicInfo_EM graphic_info_em_object[TILE_MAX][8];
-extern struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][SPR_MAX][8];
+extern struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][PLY_MAX][8];
 
 extern short **Boom;
 extern short **Cave;
@@ -114,7 +114,7 @@ extern unsigned short tab_explode_normal[TILE_MAX];
 extern unsigned short tab_explode_dynamite[TILE_MAX];
 
 extern unsigned short map_obj[8][TILE_MAX];
-extern unsigned short map_spr[2][8][SPR_MAX];
+extern unsigned short map_ply[2][8][PLY_MAX];
 extern unsigned short map_ttl[128];
 
 extern Bitmap *screenBitmap;
diff --git a/src/game_em/synchro_1.c b/src/game_em/synchro_1.c
index b390ad916e71dfeec0f108d8fa38d81edbdd9b7b..08a823a0b359d4ba6f22f7d2f103e66a45fe3f6f 100644 (file)
--- a/src/game_em/synchro_1.c
+++ b/src/game_em/synchro_1.c
@@ -36,7 +36,7 @@ void synchro_1(void)
   {
     ply[i].oldx = ply[i].x;
     ply[i].oldy = ply[i].y;
-    ply[i].anim = SPR_still;
+    ply[i].anim = PLY_still;
   }
 
   start_check_nr = (RandomEM & 128 ? 0 : 1) * 2 + (RandomEM & 256 ? 0 : 1);
@@ -81,93 +81,93 @@ static boolean player_killed(struct PLAYER *ply)
 
   switch(Cave[y-1][x])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       return TRUE;
   }
 
   switch(Cave[y][x+1])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       return TRUE;
   }
 
   switch(Cave[y+1][x])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       return TRUE;
   }
 
   switch(Cave[y][x-1])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       return TRUE;
   }
 
   switch(Cave[y][x])
   {
     case Xblank:
-    case Yacid_splash_eB:
-    case Yacid_splash_wB:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
     case Zplayer:
     case Xdynamite_1:
     case Xdynamite_2:
@@ -198,100 +198,100 @@ static void kill_player(struct PLAYER *ply)
 
   switch(Cave[y-1][x])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
       Cave[y-1][x] = Xboom_bug;
       break;
 
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       Cave[y-1][x] = Xboom_bomb;
       break;
   }
 
   switch(Cave[y][x+1])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
       Cave[y][x+1] = Xboom_bug;
       break;
 
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       Cave[y][x+1] = Xboom_bomb;
       break;
   }
 
   switch(Cave[y+1][x])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
       Cave[y+1][x] = Xboom_bug;
       break;
 
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       Cave[y+1][x] = Xboom_bomb;
       break;
   }
 
   switch(Cave[y][x-1])
   {
-    case Xbug_n:
-    case Xbug_e:
-    case Xbug_s:
-    case Xbug_w:
-    case Xbug_gon:
-    case Xbug_goe:
-    case Xbug_gos:
-    case Xbug_gow:
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
       Cave[y][x-1] = Xboom_bug;
       break;
 
-    case Xtank_n:
-    case Xtank_e:
-    case Xtank_s:
-    case Xtank_w:
-    case Xtank_gon:
-    case Xtank_goe:
-    case Xtank_gos:
-    case Xtank_gow:
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
       Cave[y][x-1] = Xboom_bomb;
       break;
   }
@@ -303,11 +303,11 @@ static void kill_player(struct PLAYER *ply)
     case Xexit_3:
       lev.exit_x = x;
       lev.exit_y = y;
-      play_element_sound(x, y, SAMPLE_exit_leave, Xexit_1);
+      play_element_sound(x, y, SOUND_exit_leave, Xexit_1);
       break;
 
     default:
-      play_element_sound(x, y, SAMPLE_die, Zplayer);
+      play_element_sound(x, y, SOUND_die, Zplayer);
       break;
   }
 
@@ -411,7 +411,7 @@ static void check_player(struct PLAYER *ply)
       if (++ply->dynamite_cnt == 5 && ply->dynamite)
       {
        Cave[y][x] = Xdynamite_1;
-       play_element_sound(x, y, SAMPLE_dynamite, Xdynamite_1);
+       play_element_sound(x, y, SOUND_dynamite, Xdynamite_1);
        ply->dynamite--;
       }
     }
@@ -486,8 +486,8 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
     {
       /* fire is released */
       case Xblank:
-      case Yacid_splash_eB:
-      case Yacid_splash_wB:
+      case Xacid_splash_e:
+      case Xacid_splash_w:
        Cave[y][x] = Zplayer;
        Next[y][x] = Zplayer;
 #if 1
@@ -500,8 +500,8 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
       case Xfake_acid_7:
       case Xfake_acid_8:
 #endif
-       play_element_sound(x, y, SAMPLE_blank, Xblank);
-       ply->anim = SPR_walk + anim;
+       play_element_sound(x, y, SOUND_blank, Xblank);
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
@@ -516,30 +516,30 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
       case Xacid_7:
       case Xacid_8:
        if (Cave[y-1][x+1] == Xblank)
-         Cave[y-1][x+1] = Yacid_splash_eB;
+         Cave[y-1][x+1] = Xacid_splash_e;
        if (Cave[y-1][x-1] == Xblank)
-         Cave[y-1][x-1] = Yacid_splash_wB;
-       play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         Cave[y-1][x-1] = Xacid_splash_w;
+       play_element_sound(x, y, SOUND_acid, Xacid_1);
 #endif
 
       case Xboom_android:
       case Xboom_1:
-      case Xbug_n:
-      case Xbug_e:
-      case Xbug_s:
-      case Xbug_w:
-      case Xbug_gon:
-      case Xbug_goe:
-      case Xbug_gos:
-      case Xbug_gow:
-      case Xtank_n:
-      case Xtank_e:
-      case Xtank_s:
-      case Xtank_w:
-      case Xtank_gon:
-      case Xtank_goe:
-      case Xtank_gos:
-      case Xtank_gow:
+      case Xbug_1_n:
+      case Xbug_1_e:
+      case Xbug_1_s:
+      case Xbug_1_w:
+      case Xbug_2_n:
+      case Xbug_2_e:
+      case Xbug_2_s:
+      case Xbug_2_w:
+      case Xtank_1_n:
+      case Xtank_1_e:
+      case Xtank_1_s:
+      case Xtank_1_w:
+      case Xtank_2_n:
+      case Xtank_2_e:
+      case Xtank_2_s:
+      case Xtank_2_w:
 
 #if !USE_CHANGED_ACID_STUFF
       case Xacid_1:
@@ -551,7 +551,7 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
       case Xacid_7:
       case Xacid_8:
 #endif
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
@@ -560,8 +560,8 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        Cave[y][x] = (dy ? (dy < 0 ? Ygrass_nB : Ygrass_sB) :
                      (dx > 0 ? Ygrass_eB : Ygrass_wB));
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_dirt, Xgrass);
-       ply->anim = SPR_walk + anim;
+       play_element_sound(x, y, SOUND_dirt, Xgrass);
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
@@ -570,117 +570,117 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        Cave[y][x] = (dy ? (dy < 0 ? Ydirt_nB : Ydirt_sB) :
                      (dx > 0 ? Ydirt_eB : Ydirt_wB));
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_dirt, Xdirt);
-       ply->anim = SPR_walk + anim;
+       play_element_sound(x, y, SOUND_dirt, Xdirt);
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xdiamond:
       case Xdiamond_pause:
-       Cave[y][x] = Ydiamond_eat;
+       Cave[y][x] = Ydiamond_blank;
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.diamond_score;
        lev.required = lev.required < 3 ? 0 : lev.required - 3;
        game.snapshot.collected_item = TRUE;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xemerald:
       case Xemerald_pause:
-       Cave[y][x] = Yemerald_eat;
+       Cave[y][x] = Yemerald_blank;
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.emerald_score;
        lev.required = lev.required < 1 ? 0 : lev.required - 1;
        game.snapshot.collected_item = TRUE;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xdynamite:
-       Cave[y][x] = Ydynamite_eat;
+       Cave[y][x] = Ydynamite_blank;
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.dynamite_score;
        ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xkey_1:
        ply->keys |= 0x01;
-       Cave[y][x] = Ykey_1_eat;
+       Cave[y][x] = Ykey_1_blank;
        goto key_walk;
 
       case Xkey_2:
        ply->keys |= 0x02;
-       Cave[y][x] = Ykey_2_eat;
+       Cave[y][x] = Ykey_2_blank;
        goto key_walk;
 
       case Xkey_3:
        ply->keys |= 0x04;
-       Cave[y][x] = Ykey_3_eat;
+       Cave[y][x] = Ykey_3_blank;
        goto key_walk;
 
       case Xkey_4:
        ply->keys |= 0x08;
-       Cave[y][x] = Ykey_4_eat;
+       Cave[y][x] = Ykey_4_blank;
        goto key_walk;
 
       case Xkey_5:
        ply->keys |= 0x10;
-       Cave[y][x] = Ykey_5_eat;
+       Cave[y][x] = Ykey_5_blank;
        goto key_walk;
 
       case Xkey_6:
        ply->keys |= 0x20;
-       Cave[y][x] = Ykey_6_eat;
+       Cave[y][x] = Ykey_6_blank;
        goto key_walk;
 
       case Xkey_7:
        ply->keys |= 0x40;
-       Cave[y][x] = Ykey_7_eat;
+       Cave[y][x] = Ykey_7_blank;
        goto key_walk;
 
       case Xkey_8:
        ply->keys |= 0x80;
-       Cave[y][x] = Ykey_8_eat;
+       Cave[y][x] = Ykey_8_blank;
        goto key_walk;
 
       key_walk:
 
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.key_score;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xlenses:
-       Cave[y][x] = Ylenses_eat;
+       Cave[y][x] = Ylenses_blank;
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.lenses_score;
        lev.lenses_cnt = lev.lenses_time;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
 
       case Xmagnify:
-       Cave[y][x] = Ymagnify_eat;
+       Cave[y][x] = Ymagnify_blank;
        Next[y][x] = Zplayer;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.magnify_score;
        lev.magnify_cnt = lev.magnify_time;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
@@ -700,15 +700,15 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y-1][x+dx+1] == Xblank)
-             Cave[y-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y-1][x+dx-1] == Xblank)
-             Cave[y-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto stone_walk;
 
           case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y][x+dx] = dx > 0 ? Ystone_e : Ystone_w;
            Next[y][x+dx] = Xstone_pause;
 
@@ -716,11 +716,11 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 
            Cave[y][x] = dx > 0 ? Ystone_eB : Ystone_wB;
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_roll, Xstone);
+           play_element_sound(x, y, SOUND_roll, Xstone);
            ply->x = x;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xbomb:
@@ -738,15 +738,15 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y-1][x+dx+1] == Xblank)
-             Cave[y-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y-1][x+dx-1] == Xblank)
-             Cave[y-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto bomb_walk;
 
          case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y][x+dx] = dx > 0 ? Ybomb_e : Ybomb_w;
            Next[y][x+dx] = Xbomb_pause;
 
@@ -754,11 +754,11 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 
            Cave[y][x] = dx > 0 ? Ybomb_eB : Ybomb_wB;
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_roll, Xbomb);
+           play_element_sound(x, y, SOUND_roll, Xbomb);
            ply->x = x;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xnut:
@@ -776,15 +776,15 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y-1][x+dx+1] == Xblank)
-             Cave[y-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y-1][x+dx-1] == Xblank)
-             Cave[y-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto nut_walk;
 
           case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y][x+dx] = dx > 0 ? Ynut_e : Ynut_w;
            Next[y][x+dx] = Xnut_pause;
 
@@ -792,11 +792,11 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 
            Cave[y][x] = dx > 0 ? Ynut_eB : Ynut_wB;
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_roll, Xnut);
+           play_element_sound(x, y, SOUND_roll, Xnut);
            ply->x = x;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xspring:
@@ -807,11 +807,11 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        {
           case Xalien:
           case Xalien_pause:
-           Cave[y][x] = dx > 0 ? Yspring_kill_eB : Yspring_kill_wB;
-           Cave[y][x+dx] = dx > 0 ? Yspring_kill_e : Yspring_kill_w;
+           Cave[y][x] = dx > 0 ? Yspring_alien_eB : Yspring_alien_wB;
+           Cave[y][x+dx] = dx > 0 ? Yspring_alien_e : Yspring_alien_w;
            Next[y][x] = Zplayer;
            Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
-           play_element_sound(x, y, SAMPLE_slurp, Xalien);
+           play_element_sound(x, y, SOUND_slurp, Xalien);
            lev.score += lev.slurp_score;
            ply->x = x;
            break;
@@ -825,26 +825,26 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y-1][x+dx+1] == Xblank)
-             Cave[y-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y-1][x+dx-1] == Xblank)
-             Cave[y-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto spring_walk;
 
           case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y][x+dx] = dx > 0 ? Yspring_e : Yspring_w;
            Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
 
          spring_walk:
            Cave[y][x] = dx > 0 ? Yspring_eB : Yspring_wB;
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_roll, Xspring);
+           play_element_sound(x, y, SOUND_roll, Xspring);
            ply->x = x;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xspring_pause:
@@ -858,7 +858,7 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        if (dy)
          break;
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xballoon:
@@ -873,15 +873,15 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y+dy-1][x+dx+1] == Xblank)
-             Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y+dy-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y+dy-1][x+dx-1] == Xblank)
-             Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y+dy-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto balloon_walk;
 
           case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yballoon_n : Yballoon_s) :
                                (dx > 0 ? Yballoon_e : Yballoon_w));
            Next[y+dy][x+dx] = Xballoon;
@@ -890,12 +890,12 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
            Cave[y][x] = (dy ? (dy < 0 ? Yballoon_nB : Yballoon_sB) :
                          (dx > 0 ? Yballoon_eB : Yballoon_wB));
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_push, Xballoon);
+           play_element_sound(x, y, SOUND_push, Xballoon);
            ply->x = x;
            ply->y = y;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xandroid:
@@ -918,15 +918,15 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
           case Xacid_7:
           case Xacid_8:
            if (Cave[y+dy-1][x+dx+1] == Xblank)
-             Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
+             Cave[y+dy-1][x+dx+1] = Xacid_splash_e;
            if (Cave[y+dy-1][x+dx-1] == Xblank)
-             Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
-           play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             Cave[y+dy-1][x+dx-1] = Xacid_splash_w;
+           play_element_sound(x, y, SOUND_acid, Xacid_1);
            goto android_walk;
 
           case Xblank:
-          case Yacid_splash_eB:
-          case Yacid_splash_wB:
+          case Xacid_splash_e:
+          case Xacid_splash_w:
            Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yandroid_n : Yandroid_s) :
                                (dx > 0 ? Yandroid_e : Yandroid_w));
            Next[y+dy][x+dx] = (dy ? (dy < 0 ? Xandroid_2_n : Xandroid_2_s) :
@@ -936,12 +936,12 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
            Cave[y][x] = (dy ? (dy < 0 ? Yandroid_nB : Yandroid_sB) :
                          (dx > 0 ? Yandroid_eB : Yandroid_wB));
            Next[y][x] = Zplayer;
-           play_element_sound(x, y, SAMPLE_push, Xandroid);
+           play_element_sound(x, y, SOUND_push, Xandroid);
            ply->x = x;
            ply->y = y;
        }
 
-       ply->anim = SPR_push + anim;
+       ply->anim = PLY_push_n + anim;
        break;
 
       case Xdoor_1:
@@ -1006,14 +1006,14 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 
        Cave[y+dy][x+dx] = Zplayer;
        Next[y+dy][x+dx] = Zplayer;
-       play_element_sound(x, y, SAMPLE_door, element);
-       ply->anim = SPR_walk + anim;
+       play_element_sound(x, y, SOUND_door, element);
+       ply->anim = PLY_walk_n + anim;
        ply->x = x + dx;
        ply->y = y + dy;
        break;
 
       case Xwheel:
-       play_element_sound(x, y, SAMPLE_press, element);
+       play_element_sound(x, y, SOUND_press, element);
        lev.wheel_cnt = lev.wheel_time;
        lev.wheel_x = x;
        lev.wheel_y = y;
@@ -1035,22 +1035,22 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        lev.wind_direction = 3;
        goto wind_walk;
 
-      case Xwind_nesw:
+      case Xwind_any:
        lev.wind_direction = dy ? (dy < 0 ? 0 : 2) : (dx > 0 ? 1 : 3);
        goto wind_walk;
 
       wind_walk:
-       play_element_sound(x, y, SAMPLE_press, element);
+       play_element_sound(x, y, SOUND_press, element);
        lev.wind_cnt = lev.wind_time;
        break;
 
       case Xwind_stop:
-       play_element_sound(x, y, SAMPLE_press, element);
+       play_element_sound(x, y, SOUND_press, element);
        lev.wind_cnt = 0;
        break;
 
       case Xswitch:
-       play_element_sound(x, y, SAMPLE_press, element);
+       play_element_sound(x, y, SOUND_press, element);
        lev.ball_cnt = lev.ball_time;
        lev.ball_state = !lev.ball_state;
        break;
@@ -1058,8 +1058,8 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
       case Xplant:
        Cave[y][x] = Yplant;
        Next[y][x] = Xplant;
-       play_element_sound(x, y, SAMPLE_blank, Xplant);
-       ply->anim = SPR_walk + anim;
+       play_element_sound(x, y, SOUND_blank, Xplant);
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
        break;
@@ -1072,7 +1072,7 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
        if (lev.home == 0)
          game_em.level_solved = TRUE;
 
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        ply->x = x;
        ply->y = y;
 
@@ -1091,113 +1091,113 @@ static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
       /* fire is pressed */
 
       case Xgrass:
-       Cave[y][x] = Ygrass_eat;
+       Cave[y][x] = Ygrass_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_dirt, element);
-       ply->anim = SPR_spray + anim;
+       play_element_sound(x, y, SOUND_dirt, element);
+       ply->anim = PLY_shoot_n + anim;
        break;
 
       case Xdirt:
-       Cave[y][x] = Ydirt_eat;
+       Cave[y][x] = Ydirt_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_dirt, element);
-       ply->anim = SPR_spray + anim;
+       play_element_sound(x, y, SOUND_dirt, element);
+       ply->anim = PLY_shoot_n + anim;
        break;
 
       case Xdiamond:
       case Xdiamond_pause:
-       Cave[y][x] = Ydiamond_eat;
+       Cave[y][x] = Ydiamond_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.diamond_score;
        lev.required = lev.required < 3 ? 0 : lev.required - 3;
        game.snapshot.collected_item = TRUE;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       case Xemerald:
       case Xemerald_pause:
-       Cave[y][x] = Yemerald_eat;
+       Cave[y][x] = Yemerald_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.emerald_score;
        lev.required = lev.required < 1 ? 0 : lev.required - 1;
        game.snapshot.collected_item = TRUE;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       case Xdynamite:
-       Cave[y][x] = Ydynamite_eat;
+       Cave[y][x] = Ydynamite_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.dynamite_score;
        ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       case Xkey_1:
        ply->keys |= 0x01;
-       Cave[y][x] = Ykey_1_eat;
+       Cave[y][x] = Ykey_1_blank;
        goto key_shoot;
 
       case Xkey_2:
        ply->keys |= 0x02;
-       Cave[y][x] = Ykey_2_eat;
+       Cave[y][x] = Ykey_2_blank;
        goto key_shoot;
 
       case Xkey_3:
        ply->keys |= 0x04;
-       Cave[y][x] = Ykey_3_eat;
+       Cave[y][x] = Ykey_3_blank;
        goto key_shoot;
 
       case Xkey_4:
        ply->keys |= 0x08;
-       Cave[y][x] = Ykey_4_eat;
+       Cave[y][x] = Ykey_4_blank;
        goto key_shoot;
 
       case Xkey_5:
        ply->keys |= 0x10;
-       Cave[y][x] = Ykey_5_eat;
+       Cave[y][x] = Ykey_5_blank;
        goto key_shoot;
 
       case Xkey_6:
        ply->keys |= 0x20;
-       Cave[y][x] = Ykey_6_eat;
+       Cave[y][x] = Ykey_6_blank;
        goto key_shoot;
 
       case Xkey_7:
        ply->keys |= 0x40;
-       Cave[y][x] = Ykey_7_eat;
+       Cave[y][x] = Ykey_7_blank;
        goto key_shoot;
 
       case Xkey_8:
        ply->keys |= 0x80;
-       Cave[y][x] = Ykey_8_eat;
+       Cave[y][x] = Ykey_8_blank;
        goto key_shoot;
 
       key_shoot:
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.key_score;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       case Xlenses:
-       Cave[y][x] = Ylenses_eat;
+       Cave[y][x] = Ylenses_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.lenses_score;
        lev.lenses_cnt = lev.lenses_time;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       case Xmagnify:
-       Cave[y][x] = Ymagnify_eat;
+       Cave[y][x] = Ymagnify_blank;
        Next[y][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_collect, element);
+       play_element_sound(x, y, SOUND_collect, element);
        lev.score += lev.magnify_score;
        lev.magnify_cnt = lev.magnify_time;
-       ply->anim = SPR_walk + anim;
+       ply->anim = PLY_walk_n + anim;
        break;
 
       default:
diff --git a/src/game_em/synchro_2.c b/src/game_em/synchro_2.c
index 70f6797c88e38030fabacdcfec58249e5f8ae8a0..98188da61259e617c0d9f1ed6ae254fc2504bf70 100644 (file)
--- a/src/game_em/synchro_2.c
+++ b/src/game_em/synchro_2.c
@@ -64,10 +64,10 @@ void synchro_2(void)
     /* --------------------------------------------------------------------- */
 
 #ifdef BAD_ROLL
-    case Xstone_force_e:
+    case Xpush_stone_e:
       switch (Cave[y][x+1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -87,10 +87,10 @@ void synchro_2(void)
          goto loop;
       }
 
-    case Xstone_force_w:
+    case Xpush_stone_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -110,10 +110,10 @@ void synchro_2(void)
          goto loop;
       }
 
-    case Xnut_force_e:
+    case Xpush_nut_e:
       switch (Cave[y][x+1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -133,10 +133,10 @@ void synchro_2(void)
          goto loop;
       }
 
-    case Xnut_force_w:
+    case Xpush_nut_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -156,10 +156,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xspring_force_e:
+    case Xpush_spring_e:
       switch (Cave[y][x+1])
       {
-        case ZBORDER:
+        case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -185,10 +185,10 @@ void synchro_2(void)
          goto loop;
       }
 
-    case Xspring_force_w:
+    case Xpush_spring_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -213,10 +213,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xemerald_force_e:
+    case Xpush_emerald_e:
       switch (Cave[y][x+1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -236,10 +236,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xemerald_force_w:
+    case Xpush_emerald_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -259,10 +259,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xdiamond_force_e:
+    case Xpush_diamond_e:
       switch (Cave[y][x+1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -282,10 +282,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xdiamond_force_w:
+    case Xpush_diamond_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -305,10 +305,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xbomb_force_e:
+    case Xpush_bomb_e:
       switch (Cave[y][x+1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -328,10 +328,10 @@ void synchro_2(void)
          goto loop;
        }
 
-    case Xbomb_force_w:
+    case Xpush_bomb_w:
       switch (Cave[y][x-1])
       {
-       case ZBORDER:
+       case Zborder:
        case Znormal:
        case Zdynamite:
        case Xboom_bug:
@@ -367,16 +367,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ystone_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
 #if 1
@@ -430,8 +430,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xkey_1:
        case Xkey_2:
        case Xkey_3:
@@ -444,10 +444,10 @@ void synchro_2(void)
        case Xswitch:
        case Xlenses:
        case Xmagnify:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -508,16 +508,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ystone_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
 #if 1
         case Xfake_acid_1:
         case Xfake_acid_2:
@@ -555,16 +555,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ystone_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Zplayer:
 #if 1
         case Xfake_acid_1:
@@ -584,21 +584,21 @@ void synchro_2(void)
 
        case Xnut:
        case Xnut_pause:
-         Cave[y+1][x] = Yemerald_stone;
+         Cave[y+1][x] = Ynut_stone;
          Next[y][x] = Xstone;
          Next[y+1][x] = Xemerald;
-         play_element_sound(x, y, SAMPLE_crack, Xnut);
+         play_element_sound(x, y, SOUND_crack, Xnut);
          score += lev.nut_score;
          goto loop;
 
-       case Xbug_n:
-       case Xbug_e:
-       case Xbug_s:
-       case Xbug_w:
-       case Xbug_gon:
-       case Xbug_goe:
-       case Xbug_gos:
-       case Xbug_gow:
+       case Xbug_1_n:
+       case Xbug_1_e:
+       case Xbug_1_s:
+       case Xbug_1_w:
+       case Xbug_2_n:
+       case Xbug_2_e:
+       case Xbug_2_s:
+       case Xbug_2_w:
          Cave[y][x] = Ystone_sB;
          Cave[y+1][x] = Ybug_stone;
          Next[y+1][x] = Znormal;
@@ -612,19 +612,19 @@ void synchro_2(void)
          Boom[y+2][x] = Xemerald;
          Boom[y+2][x+1] = Xemerald;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.bug_score;
          goto loop;
 
-       case Xtank_n:
-       case Xtank_e:
-       case Xtank_s:
-       case Xtank_w:
-       case Xtank_gon:
-       case Xtank_goe:
-       case Xtank_gos:
-       case Xtank_gow:
+       case Xtank_1_n:
+       case Xtank_1_e:
+       case Xtank_1_s:
+       case Xtank_1_w:
+       case Xtank_2_n:
+       case Xtank_2_e:
+       case Xtank_2_s:
+       case Xtank_2_w:
          Cave[y][x] = Ystone_sB;
          Cave[y+1][x] = Ytank_stone;
          Next[y+1][x] = Znormal;
@@ -638,7 +638,7 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.tank_score;
          goto loop;
@@ -649,8 +649,8 @@ void synchro_2(void)
            switch (Cave[y+1][x+1])
            {
              case Xblank:
-             case Yacid_splash_eB:
-             case Yacid_splash_wB:
+             case Xacid_splash_e:
+             case Xacid_splash_w:
              case Xalien:
              case Xalien_pause:
                Cave[y+1][x] = Xspring_e;
@@ -666,8 +666,8 @@ void synchro_2(void)
            switch (Cave[y+1][x-1])
            {
              case Xblank:
-             case Yacid_splash_eB:
-             case Yacid_splash_wB:
+             case Xacid_splash_e:
+             case Xacid_splash_w:
              case Xalien:
              case Xalien_pause:
                Cave[y+1][x] = Xspring_w;
@@ -698,7 +698,7 @@ void synchro_2(void)
          Boom[y+2][x] = lev.eater_array[lev.eater_pos][7];
          Boom[y+2][x+1] = lev.eater_array[lev.eater_pos][8];
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          lev.eater_pos = (lev.eater_pos + 1) & 7;
          score += lev.eater_score;
@@ -719,7 +719,7 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.alien_score;
          goto loop;
@@ -729,25 +729,25 @@ void synchro_2(void)
          switch (Cave[y+2][x])
          {
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
            case Zplayer:
-           case Xbug_n:
-           case Xbug_e:
-           case Xbug_s:
-           case Xbug_w:
-           case Xbug_gon:
-           case Xbug_goe:
-           case Xbug_gos:
-           case Xbug_gow:
-           case Xtank_n:
-           case Xtank_e:
-           case Xtank_s:
-           case Xtank_w:
-           case Xtank_gon:
-           case Xtank_goe:
-           case Xtank_gos:
-           case Xtank_gow:
+           case Xbug_1_n:
+           case Xbug_1_e:
+           case Xbug_1_s:
+           case Xbug_1_w:
+           case Xbug_2_n:
+           case Xbug_2_e:
+           case Xbug_2_s:
+           case Xbug_2_w:
+           case Xtank_1_n:
+           case Xtank_1_e:
+           case Xtank_1_s:
+           case Xtank_1_w:
+           case Xtank_2_n:
+           case Xtank_2_e:
+           case Xtank_2_s:
+           case Xtank_2_w:
            case Xspring_fall:
            case Xandroid:
            case Xandroid_1_n:
@@ -775,7 +775,7 @@ void synchro_2(void)
            case Xplant:
            case Yplant:
              Next[y][x] = Xstone;
-             play_element_sound(x, y, SAMPLE_stone, Xstone);
+             play_element_sound(x, y, SOUND_stone, Xstone);
              goto loop;
          }
 
@@ -783,12 +783,12 @@ void synchro_2(void)
          Cave[y+1][x] = Ydiamond_stone;
          Next[y][x] = Xblank;
          Next[y+1][x] = Xstone_pause;
-         play_element_sound(x, y, SAMPLE_squash, Xdiamond);
+         play_element_sound(x, y, SOUND_squash, Xdiamond);
          goto loop;
 
        case Xbomb:
        case Xbomb_pause:
-         Cave[y+1][x] = Ybomb_eat;
+         Cave[y+1][x] = Ybomb_blank;
          Next[y+1][x] = Znormal;
          Boom[y][x-1] = Xblank;
          Boom[y][x] = Xblank;
@@ -800,7 +800,7 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          goto loop;
 
@@ -817,14 +817,14 @@ void synchro_2(void)
            }
 
            Next[y][x] = Xblank;
-           play_element_sound(x, y, SAMPLE_wonderfall, Xwonderwall);
+           play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
            goto loop;
          }
 
        default:
          Cave[y][x] = Xstone;
          Next[y][x] = Xstone;
-         play_element_sound(x, y, SAMPLE_stone, Xstone);
+         play_element_sound(x, y, SOUND_stone, Xstone);
          goto loop;
       }
 
@@ -843,16 +843,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ynut_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ynut_sB;
          Cave[y+1][x] = Ynut_s;
          Next[y][x] = Xblank;
@@ -887,8 +887,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xkey_1:
        case Xkey_2:
        case Xkey_3:
@@ -899,10 +899,10 @@ void synchro_2(void)
        case Xkey_8:
        case Xbumper:
        case Xswitch:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -964,16 +964,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ynut_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ynut_sB;
          Cave[y+1][x] = Ynut_s;
          Next[y][x] = Xblank;
@@ -1001,16 +1001,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ynut_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Zplayer:
          Cave[y][x] = Ynut_sB;
          Cave[y+1][x] = Ynut_s;
@@ -1021,13 +1021,13 @@ void synchro_2(void)
        default:
          Cave[y][x] = Xnut;
          Next[y][x] = Xnut;
-         play_element_sound(x, y, SAMPLE_nut, Xnut);
+         play_element_sound(x, y, SOUND_nut, Xnut);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xbug_n:
+    case Xbug_1_n:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1037,8 +1037,8 @@ void synchro_2(void)
       switch (Cave[y][x+1])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1051,15 +1051,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ybug_n_e;
-         Next[y][x] = Xbug_goe;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_e;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          goto bug_gon;
        }
 
-    case Xbug_gon:
+    case Xbug_2_n:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1080,36 +1080,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybug_nB;
          if (Cave[y-2][x+1] == Xblank)
-           Cave[y-2][x+1] = Yacid_splash_eB;
+           Cave[y-2][x+1] = Xacid_splash_e;
          if (Cave[y-2][x-1] == Xblank)
-           Cave[y-2][x-1] = Yacid_splash_wB;
+           Cave[y-2][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ybug_nB;
          Cave[y-1][x] = Ybug_n;
          Next[y][x] = Xblank;
-         Next[y-1][x] = Xbug_n;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y-1][x] = Xbug_1_n;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          Cave[y][x] = Ybug_n_w;
-         Next[y][x] = Xbug_gow;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_w;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xbug_e:
+    case Xbug_1_e:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1119,8 +1119,8 @@ void synchro_2(void)
       switch (Cave[y+1][x])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1133,15 +1133,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ybug_e_s;
-         Next[y][x] = Xbug_gos;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_s;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          goto bug_goe;
       }
 
-    case Xbug_goe:
+    case Xbug_2_e:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1162,36 +1162,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybug_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ybug_eB;
          Cave[y][x+1] = Ybug_e;
          Next[y][x] = Xblank;
-         Next[y][x+1] = Xbug_e;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x+1] = Xbug_1_e;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          Cave[y][x] = Ybug_e_n;
-         Next[y][x] = Xbug_gon;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_n;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xbug_s:
+    case Xbug_1_s:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1201,8 +1201,8 @@ void synchro_2(void)
       switch (Cave[y][x-1])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1215,15 +1215,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ybug_s_w;
-         Next[y][x] = Xbug_gow;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_w;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          goto bug_gos;
       }
 
-    case Xbug_gos:
+    case Xbug_2_s:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1244,36 +1244,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybug_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ybug_sB;
          Cave[y+1][x] = Ybug_s;
          Next[y][x] = Xblank;
-         Next[y+1][x] = Xbug_s;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y+1][x] = Xbug_1_s;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          Cave[y][x] = Ybug_s_e;
-         Next[y][x] = Xbug_goe;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_e;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xbug_w:
+    case Xbug_1_w:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1283,8 +1283,8 @@ void synchro_2(void)
       switch (Cave[y-1][x])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1297,15 +1297,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ybug_w_n;
-         Next[y][x] = Xbug_gon;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_n;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          goto bug_gow;
       }
 
-    case Xbug_gow:
+    case Xbug_2_w:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1326,36 +1326,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybug_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ybug_wB;
          Cave[y][x-1] = Ybug_w;
          Next[y][x] = Xblank;
-         Next[y][x-1] = Xbug_w;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x-1] = Xbug_1_w;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
 
        default:
          Cave[y][x] = Ybug_w_s;
-         Next[y][x] = Xbug_gos;
-         play_element_sound(x, y, SAMPLE_bug, element);
+         Next[y][x] = Xbug_2_s;
+         play_element_sound(x, y, SOUND_bug, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xtank_n:
+    case Xtank_1_n:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1365,8 +1365,8 @@ void synchro_2(void)
       switch (Cave[y][x-1])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1379,15 +1379,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ytank_n_w;
-         Next[y][x] = Xtank_gow;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_w;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          goto tank_gon;
       }
 
-    case Xtank_gon:
+    case Xtank_2_n:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1408,36 +1408,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ytank_nB;
          if (Cave[y-2][x+1] == Xblank)
-           Cave[y-2][x+1] = Yacid_splash_eB;
+           Cave[y-2][x+1] = Xacid_splash_e;
          if (Cave[y-2][x-1] == Xblank)
-           Cave[y-2][x-1] = Yacid_splash_wB;
+           Cave[y-2][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ytank_nB;
          Cave[y-1][x] = Ytank_n;
          Next[y][x] = Xblank;
-         Next[y-1][x] = Xtank_n;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y-1][x] = Xtank_1_n;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          Cave[y][x] = Ytank_n_e;
-         Next[y][x] = Xtank_goe;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_e;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xtank_e:
+    case Xtank_1_e:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1447,8 +1447,8 @@ void synchro_2(void)
       switch (Cave[y-1][x])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1461,15 +1461,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ytank_e_n;
-         Next[y][x] = Xtank_gon;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_n;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          goto tank_goe;
       }
 
-    case Xtank_goe:
+    case Xtank_2_e:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1490,36 +1490,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ytank_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ytank_eB;
          Cave[y][x+1] = Ytank_e;
          Next[y][x] = Xblank;
-         Next[y][x+1] = Xtank_e;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x+1] = Xtank_1_e;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          Cave[y][x] = Ytank_e_s;
-         Next[y][x] = Xtank_gos;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_s;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xtank_s:
+    case Xtank_1_s:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1529,8 +1529,8 @@ void synchro_2(void)
       switch (Cave[y][x+1])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1543,15 +1543,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ytank_s_e;
-         Next[y][x] = Xtank_goe;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_e;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          goto tank_gos;
       }
 
-    case Xtank_gos:
+    case Xtank_2_s:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1572,36 +1572,36 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ytank_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ytank_sB;
          Cave[y+1][x] = Ytank_s;
          Next[y][x] = Xblank;
-         Next[y+1][x] = Xtank_s;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y+1][x] = Xtank_1_s;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          Cave[y][x] = Ytank_s_w;
-         Next[y][x] = Xtank_gow;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_w;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
-    case Xtank_w:
+    case Xtank_1_w:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1611,8 +1611,8 @@ void synchro_2(void)
       switch (Cave[y+1][x])
       {
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Xacid_1:
@@ -1625,15 +1625,15 @@ void synchro_2(void)
        case Xacid_8:
        case Zplayer:
          Cave[y][x] = Ytank_w_s;
-         Next[y][x] = Xtank_gos;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_s;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          goto tank_gow;
       }
 
-    case Xtank_gow:
+    case Xtank_2_w:
       if (tab_amoeba[Cave[y-1][x]] ||
          tab_amoeba[Cave[y][x+1]] ||
          tab_amoeba[Cave[y+1][x]] ||
@@ -1654,30 +1654,30 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ytank_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
          Cave[y][x] = Ytank_wB;
          Cave[y][x-1] = Ytank_w;
          Next[y][x] = Xblank;
-         Next[y][x-1] = Xtank_w;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x-1] = Xtank_1_w;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
 
        default:
          Cave[y][x] = Ytank_w_n;
-         Next[y][x] = Xtank_gon;
-         play_element_sound(x, y, SAMPLE_tank, element);
+         Next[y][x] = Xtank_2_n;
+         play_element_sound(x, y, SOUND_tank, element);
          goto loop;
       }
 
@@ -1793,7 +1793,7 @@ void synchro_2(void)
        }
 
        Next[y][x] = temp;      /* the item we chose to clone */
-       play_element_sound(x, y, SAMPLE_android_clone, temp);
+       play_element_sound(x, y, SOUND_android_clone, temp);
 
        switch (RANDOM & 7)
        {
@@ -2035,7 +2035,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_nB;
       Cave[y-1][x] = Yandroid_n;
       Next[y-1][x] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_ne:
@@ -2043,7 +2043,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_neB;
       Cave[y-1][x+1] = Yandroid_ne;
       Next[y-1][x+1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_e:
@@ -2051,7 +2051,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_eB;
       Cave[y][x+1] = Yandroid_e;
       Next[y][x+1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_se:
@@ -2059,7 +2059,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_seB;
       Cave[y+1][x+1] = Yandroid_se;
       Next[y+1][x+1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_s:
@@ -2067,7 +2067,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_sB;
       Cave[y+1][x] = Yandroid_s;
       Next[y+1][x] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_sw:
@@ -2075,7 +2075,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_swB;
       Cave[y+1][x-1] = Yandroid_sw;
       Next[y+1][x-1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_w:
@@ -2083,7 +2083,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_wB;
       Cave[y][x-1] = Yandroid_w;
       Next[y][x-1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     android_nw:
@@ -2091,7 +2091,7 @@ void synchro_2(void)
       Cave[y][x] = Yandroid_nwB;
       Cave[y-1][x-1] = Yandroid_nw;
       Next[y-1][x-1] = Xandroid;
-      play_element_sound(x, y, SAMPLE_android_move, element);
+      play_element_sound(x, y, SOUND_android_move, element);
       goto loop;
 
     /* --------------------------------------------------------------------- */
@@ -2109,21 +2109,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_nB;
          if (Cave[y-2][x+1] == Xblank)
-           Cave[y-2][x+1] = Yacid_splash_eB;
+           Cave[y-2][x+1] = Xacid_splash_e;
          if (Cave[y-2][x-1] == Xblank)
-           Cave[y-2][x-1] = Yacid_splash_wB;
+           Cave[y-2][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_nB;
          Cave[y-1][x] = Yandroid_n;
          Next[y][x] = Xblank;
          Next[y-1][x] = Xandroid;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2143,21 +2143,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_nB;
          if (Cave[y-2][x+1] == Xblank)
-           Cave[y-2][x+1] = Yacid_splash_eB;
+           Cave[y-2][x+1] = Xacid_splash_e;
          if (Cave[y-2][x-1] == Xblank)
-           Cave[y-2][x-1] = Yacid_splash_wB;
+           Cave[y-2][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_nB;
          Cave[y-1][x] = Yandroid_n;
          Next[y][x] = Xblank;
          Next[y-1][x] = Xandroid_1_n;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2179,21 +2179,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_eB;
          Cave[y][x+1] = Yandroid_e;
          Next[y][x] = Xblank;
          Next[y][x+1] = Xandroid;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2213,21 +2213,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_eB;
          Cave[y][x+1] = Yandroid_e;
          Next[y][x] = Xblank;
          Next[y][x+1] = Xandroid_1_e;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2249,21 +2249,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_sB;
          Cave[y+1][x] = Yandroid_s;
          Next[y][x] = Xblank;
          Next[y+1][x] = Xandroid;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2283,21 +2283,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_sB;
          Cave[y+1][x] = Yandroid_s;
          Next[y][x] = Xblank;
          Next[y+1][x] = Xandroid_1_s;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2319,21 +2319,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_wB;
          Cave[y][x-1] = Yandroid_w;
          Next[y][x] = Xblank;
          Next[y][x-1] = Xandroid;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2353,21 +2353,21 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yandroid_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yandroid_wB;
          Cave[y][x-1] = Yandroid_w;
          Next[y][x] = Xblank;
          Next[y][x-1] = Xandroid_1_w;
-         play_element_sound(x, y, SAMPLE_android_move, element);
+         play_element_sound(x, y, SOUND_android_move, element);
          goto loop;
 
        default:
@@ -2389,16 +2389,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
          Cave[y][x] = Yspring_sB;
@@ -2435,8 +2435,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xkey_1:
        case Xkey_2:
        case Xkey_3:
@@ -2447,10 +2447,10 @@ void synchro_2(void)
        case Xkey_8:
        case Xbumper:
        case Xswitch:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -2543,16 +2543,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Yspring_s;
          Next[y][x] = Xblank;
@@ -2580,16 +2580,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Yspring_s;
          Next[y][x] = Xblank;
@@ -2612,16 +2612,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Yalien_nB:
        case Yalien_eB:
        case Yalien_sB:
@@ -2638,11 +2638,11 @@ void synchro_2(void)
        case Yalien_e:
        case Yalien_s:
        case Yalien_w:
-         Cave[y][x] = Yspring_kill_eB;
-         Cave[y][x+1] = Yspring_kill_e;
+         Cave[y][x] = Yspring_alien_eB;
+         Cave[y][x+1] = Yspring_alien_e;
          Next[y][x] = Xblank;
          Next[y][x+1] = Xspring_e;
-         play_element_sound(x, y, SAMPLE_slurp, Xalien);
+         play_element_sound(x, y, SOUND_slurp, Xalien);
          score += lev.slurp_score;
          goto loop;
 
@@ -2650,13 +2650,13 @@ void synchro_2(void)
        case XbumperB:
          Cave[y][x+1] = XbumperB;
          Next[y][x] = Xspring_w;
-         play_element_sound(x, y, SAMPLE_spring, Xspring);
+         play_element_sound(x, y, SOUND_spring, Xspring);
          goto loop;
 
        default:
          Cave[y][x] = Xspring;
          Next[y][x] = Xspring;
-         play_element_sound(x, y, SAMPLE_spring, Xspring);
+         play_element_sound(x, y, SOUND_spring, Xspring);
          goto loop;
       }
 
@@ -2675,16 +2675,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Yspring_s;
          Next[y][x] = Xblank;
@@ -2707,16 +2707,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Yalien_nB:
        case Yalien_eB:
        case Yalien_sB:
@@ -2733,11 +2733,11 @@ void synchro_2(void)
        case Yalien_e:
        case Yalien_s:
        case Yalien_w:
-         Cave[y][x] = Yspring_kill_wB;
-         Cave[y][x-1] = Yspring_kill_w;
+         Cave[y][x] = Yspring_alien_wB;
+         Cave[y][x-1] = Yspring_alien_w;
          Next[y][x] = Xblank;
          Next[y][x-1] = Xspring_w;
-         play_element_sound(x, y, SAMPLE_slurp, Xalien);
+         play_element_sound(x, y, SOUND_slurp, Xalien);
          score += lev.slurp_score;
          goto loop;
 
@@ -2745,13 +2745,13 @@ void synchro_2(void)
        case XbumperB:
          Cave[y][x-1] = XbumperB;
          Next[y][x] = Xspring_e;
-         play_element_sound(x, y, SAMPLE_spring, Xspring);
+         play_element_sound(x, y, SOUND_spring, Xspring);
          goto loop;
 
        default:
          Cave[y][x] = Xspring;
          Next[y][x] = Xspring;
-         play_element_sound(x, y, SAMPLE_spring, Xspring);
+         play_element_sound(x, y, SOUND_spring, Xspring);
          goto loop;
       }
 
@@ -2770,16 +2770,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yspring_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Zplayer:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Yspring_s;
@@ -2789,7 +2789,7 @@ void synchro_2(void)
 
        case Xbomb:
        case Xbomb_pause:
-         Cave[y+1][x] = Ybomb_eat;
+         Cave[y+1][x] = Ybomb_blank;
          Next[y+1][x] = Znormal;
          Boom[y][x-1] = Xblank;
          Boom[y][x] = Xblank;
@@ -2801,18 +2801,18 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          goto loop;
 
-       case Xbug_n:
-       case Xbug_e:
-       case Xbug_s:
-       case Xbug_w:
-       case Xbug_gon:
-       case Xbug_goe:
-       case Xbug_gos:
-       case Xbug_gow:
+       case Xbug_1_n:
+       case Xbug_1_e:
+       case Xbug_1_s:
+       case Xbug_1_w:
+       case Xbug_2_n:
+       case Xbug_2_e:
+       case Xbug_2_s:
+       case Xbug_2_w:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Ybug_spring;
          Next[y+1][x] = Znormal;
@@ -2826,19 +2826,19 @@ void synchro_2(void)
          Boom[y+2][x] = Xemerald;
          Boom[y+2][x+1] = Xemerald;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.bug_score;
          goto loop;
 
-       case Xtank_n:
-       case Xtank_e:
-       case Xtank_s:
-       case Xtank_w:
-       case Xtank_gon:
-       case Xtank_goe:
-       case Xtank_gos:
-       case Xtank_gow:
+       case Xtank_1_n:
+       case Xtank_1_e:
+       case Xtank_1_s:
+       case Xtank_1_w:
+       case Xtank_2_n:
+       case Xtank_2_e:
+       case Xtank_2_s:
+       case Xtank_2_w:
          Cave[y][x] = Yspring_sB;
          Cave[y+1][x] = Ytank_spring;
          Next[y+1][x] = Znormal;
@@ -2852,7 +2852,7 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.tank_score;
          goto loop;
@@ -2874,7 +2874,7 @@ void synchro_2(void)
          Boom[y+2][x] = lev.eater_array[lev.eater_pos][7];
          Boom[y+2][x+1] = lev.eater_array[lev.eater_pos][8];
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          lev.eater_pos = (lev.eater_pos + 1) & 7;
          score += lev.eater_score;
@@ -2895,7 +2895,7 @@ void synchro_2(void)
          Boom[y+2][x] = Xblank;
          Boom[y+2][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          score += lev.alien_score;
          goto loop;
@@ -2903,7 +2903,7 @@ void synchro_2(void)
        default:
          Cave[y][x] = Xspring;
          Next[y][x] = Xspring;
-         play_element_sound(x, y, SAMPLE_spring, Xspring);
+         play_element_sound(x, y, SOUND_spring, Xspring);
          goto loop;
       }
 
@@ -2912,33 +2912,33 @@ void synchro_2(void)
     case Xeater_n:
       if (Cave[y][x+1] == Xdiamond)
       {
-       Cave[y][x+1] = Ydiamond_eat;
+       Cave[y][x+1] = Ydiamond_blank;
        Next[y][x+1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y+1][x] == Xdiamond)
       {
-       Cave[y+1][x] = Ydiamond_eat;
+       Cave[y+1][x] = Ydiamond_blank;
        Next[y+1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x-1] == Xdiamond)
       {
-       Cave[y][x-1] = Ydiamond_eat;
+       Cave[y][x-1] = Ydiamond_blank;
        Next[y][x-1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y-1][x] == Xdiamond)
       {
-       Cave[y-1][x] = Ydiamond_eat;
+       Cave[y-1][x] = Ydiamond_blank;
        Next[y-1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
@@ -2954,16 +2954,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yeater_nB;
          if (Cave[y-2][x+1] == Xblank)
-           Cave[y-2][x+1] = Yacid_splash_eB;
+           Cave[y-2][x+1] = Xacid_splash_e;
          if (Cave[y-2][x-1] == Xblank)
-           Cave[y-2][x-1] = Yacid_splash_wB;
+           Cave[y-2][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
@@ -2975,7 +2975,7 @@ void synchro_2(void)
 
        default:
          Next[y][x] = RANDOM & 1 ? Xeater_e : Xeater_w;
-         play_element_sound(x, y, SAMPLE_eater, element);
+         play_element_sound(x, y, SOUND_eater, element);
          goto loop;
       }
 
@@ -2984,33 +2984,33 @@ void synchro_2(void)
     case Xeater_e:
       if (Cave[y+1][x] == Xdiamond)
       {
-       Cave[y+1][x] = Ydiamond_eat;
+       Cave[y+1][x] = Ydiamond_blank;
        Next[y+1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x-1] == Xdiamond)
       {
-       Cave[y][x-1] = Ydiamond_eat;
+       Cave[y][x-1] = Ydiamond_blank;
        Next[y][x-1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y-1][x] == Xdiamond)
       {
-       Cave[y-1][x] = Ydiamond_eat;
+       Cave[y-1][x] = Ydiamond_blank;
        Next[y-1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x+1] == Xdiamond)
       {
-       Cave[y][x+1] = Ydiamond_eat;
+       Cave[y][x+1] = Ydiamond_blank;
        Next[y][x+1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
@@ -3026,16 +3026,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yeater_eB;
          if (Cave[y-1][x+2] == Xblank)
-           Cave[y-1][x+2] = Yacid_splash_eB;
+           Cave[y-1][x+2] = Xacid_splash_e;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_wB;
+           Cave[y-1][x] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
@@ -3047,7 +3047,7 @@ void synchro_2(void)
 
        default:
          Next[y][x] = RANDOM & 1 ? Xeater_n : Xeater_s;
-         play_element_sound(x, y, SAMPLE_eater, element);
+         play_element_sound(x, y, SOUND_eater, element);
          goto loop;
       }
 
@@ -3056,33 +3056,33 @@ void synchro_2(void)
     case Xeater_s:
       if (Cave[y][x-1] == Xdiamond)
       {
-       Cave[y][x-1] = Ydiamond_eat;
+       Cave[y][x-1] = Ydiamond_blank;
        Next[y][x-1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y-1][x] == Xdiamond)
       {
-       Cave[y-1][x] = Ydiamond_eat;
+       Cave[y-1][x] = Ydiamond_blank;
        Next[y-1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x+1] == Xdiamond)
       {
-       Cave[y][x+1] = Ydiamond_eat;
+       Cave[y][x+1] = Ydiamond_blank;
        Next[y][x+1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y+1][x] == Xdiamond)
       {
-       Cave[y+1][x] = Ydiamond_eat;
+       Cave[y+1][x] = Ydiamond_blank;
        Next[y+1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
@@ -3098,16 +3098,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yeater_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
@@ -3119,7 +3119,7 @@ void synchro_2(void)
 
        default:
          Next[y][x] = RANDOM & 1 ? Xeater_e : Xeater_w;
-         play_element_sound(x, y, SAMPLE_eater, element);
+         play_element_sound(x, y, SOUND_eater, element);
          goto loop;
       }
 
@@ -3128,33 +3128,33 @@ void synchro_2(void)
     case Xeater_w:
       if (Cave[y-1][x] == Xdiamond)
       {
-       Cave[y-1][x] = Ydiamond_eat;
+       Cave[y-1][x] = Ydiamond_blank;
        Next[y-1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x+1] == Xdiamond)
       {
-       Cave[y][x+1] = Ydiamond_eat;
+       Cave[y][x+1] = Ydiamond_blank;
        Next[y][x+1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y+1][x] == Xdiamond)
       {
-       Cave[y+1][x] = Ydiamond_eat;
+       Cave[y+1][x] = Ydiamond_blank;
        Next[y+1][x] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
       if (Cave[y][x-1] == Xdiamond)
       {
-       Cave[y][x-1] = Ydiamond_eat;
+       Cave[y][x-1] = Ydiamond_blank;
        Next[y][x-1] = Xblank;
-       play_element_sound(x, y, SAMPLE_eater_eat, element);
+       play_element_sound(x, y, SOUND_eater_eat, element);
        goto loop;
       }
 
@@ -3170,16 +3170,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yeater_wB;
          if (Cave[y-1][x] == Xblank)
-           Cave[y-1][x] = Yacid_splash_eB;
+           Cave[y-1][x] = Xacid_splash_e;
          if (Cave[y-1][x-2] == Xblank)
-           Cave[y-1][x-2] = Yacid_splash_wB;
+           Cave[y-1][x-2] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
@@ -3191,7 +3191,7 @@ void synchro_2(void)
 
        default:
          Next[y][x] = RANDOM & 1 ? Xeater_n : Xeater_s;
-         play_element_sound(x, y, SAMPLE_eater, element);
+         play_element_sound(x, y, SOUND_eater, element);
          goto loop;
       }
 
@@ -3225,16 +3225,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yalien_nB;
              if (Cave[y-2][x+1] == Xblank)
-               Cave[y-2][x+1] = Yacid_splash_eB;
+               Cave[y-2][x+1] = Xacid_splash_e;
              if (Cave[y-2][x-1] == Xblank)
-               Cave[y-2][x-1] = Yacid_splash_wB;
+               Cave[y-2][x-1] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
            case Xplant:
            case Yplant:
            case Zplayer:
@@ -3242,7 +3242,7 @@ void synchro_2(void)
              Cave[y-1][x] = Yalien_n;
              Next[y][x] = Xblank;
              Next[y-1][x] = Xalien_pause;
-             play_element_sound(x, y, SAMPLE_alien, Xalien);
+             play_element_sound(x, y, SOUND_alien, Xalien);
              goto loop;
          }
        }
@@ -3261,15 +3261,15 @@ void synchro_2(void)
              Cave[y][x] = Yalien_sB;
              Next[y][x] = Xblank;
              if (Cave[y][x+1] == Xblank)
-               Cave[y][x+1] = Yacid_splash_eB;
+               Cave[y][x+1] = Xacid_splash_e;
              if (Cave[y][x-1] == Xblank)
-               Cave[y][x-1] = Yacid_splash_wB;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+               Cave[y][x-1] = Xacid_splash_w;
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
            case Xplant:
            case Yplant:
            case Zplayer:
@@ -3277,7 +3277,7 @@ void synchro_2(void)
              Cave[y+1][x] = Yalien_s;
              Next[y][x] = Xblank;
              Next[y+1][x] = Xalien_pause;
-             play_element_sound(x, y, SAMPLE_alien, Xalien);
+             play_element_sound(x, y, SOUND_alien, Xalien);
              goto loop;
          }
        }
@@ -3298,16 +3298,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yalien_eB;
              if (Cave[y-1][x+2] == Xblank)
-               Cave[y-1][x+2] = Yacid_splash_eB;
+               Cave[y-1][x+2] = Xacid_splash_e;
              if (Cave[y-1][x] == Xblank)
-               Cave[y-1][x] = Yacid_splash_wB;
+               Cave[y-1][x] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
            case Xplant:
            case Yplant:
            case Zplayer:
@@ -3315,7 +3315,7 @@ void synchro_2(void)
              Cave[y][x+1] = Yalien_e;
              Next[y][x] = Xblank;
              Next[y][x+1] = Xalien_pause;
-             play_element_sound(x, y, SAMPLE_alien, Xalien);
+             play_element_sound(x, y, SOUND_alien, Xalien);
              goto loop;
          }
        }
@@ -3333,16 +3333,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yalien_wB;
              if (Cave[y-1][x] == Xblank)
-               Cave[y-1][x] = Yacid_splash_eB;
+               Cave[y-1][x] = Xacid_splash_e;
              if (Cave[y-1][x-2] == Xblank)
-               Cave[y-1][x-2] = Yacid_splash_wB;
+               Cave[y-1][x-2] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
            case Xplant:
            case Yplant:
            case Zplayer:
@@ -3350,7 +3350,7 @@ void synchro_2(void)
              Cave[y][x-1] = Yalien_w;
              Next[y][x] = Xblank;
              Next[y][x-1] = Xalien_pause;
-             play_element_sound(x, y, SAMPLE_alien, Xalien);
+             play_element_sound(x, y, SOUND_alien, Xalien);
              goto loop;
          }
        }
@@ -3377,16 +3377,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yemerald_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yemerald_sB;
          Cave[y+1][x] = Yemerald_s;
          Next[y][x] = Xblank;
@@ -3421,8 +3421,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xwonderwall:
        case Xkey_1:
        case Xkey_2:
@@ -3442,10 +3442,10 @@ void synchro_2(void)
        case Xwall_2:
        case Xwall_3:
        case Xwall_4:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -3512,16 +3512,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yemerald_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Yemerald_sB;
          Cave[y+1][x] = Yemerald_s;
          Next[y][x] = Xblank;
@@ -3549,16 +3549,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Yemerald_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Zplayer:
          Cave[y][x] = Yemerald_sB;
          Cave[y+1][x] = Yemerald_s;
@@ -3578,14 +3578,14 @@ void synchro_2(void)
            }
 
            Next[y][x] = Xblank;
-           play_element_sound(x, y, SAMPLE_wonderfall, Xwonderwall);
+           play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
            goto loop;
          }
 
        default:
          Cave[y][x] = Xemerald;
          Next[y][x] = Xemerald;
-         play_element_sound(x, y, SAMPLE_diamond, Xemerald);
+         play_element_sound(x, y, SOUND_diamond, Xemerald);
          goto loop;
       }
 
@@ -3604,16 +3604,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ydiamond_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ydiamond_sB;
          Cave[y+1][x] = Ydiamond_s;
          Next[y][x] = Xblank;
@@ -3648,8 +3648,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xwonderwall:
        case Xkey_1:
        case Xkey_2:
@@ -3669,10 +3669,10 @@ void synchro_2(void)
        case Xwall_2:
        case Xwall_3:
        case Xwall_4:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -3739,16 +3739,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ydiamond_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ydiamond_sB;
          Cave[y+1][x] = Ydiamond_s;
          Next[y][x] = Xblank;
@@ -3776,16 +3776,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ydiamond_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Zplayer:
          Cave[y][x] = Ydiamond_sB;
          Cave[y+1][x] = Ydiamond_s;
@@ -3805,14 +3805,14 @@ void synchro_2(void)
            }
 
            Next[y][x] = Xblank;
-           play_element_sound(x, y, SAMPLE_wonderfall, Xwonderwall);
+           play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
            goto loop;
          }
 
        default:
          Cave[y][x] = Xdiamond;
          Next[y][x] = Xdiamond;
-         play_element_sound(x, y, SAMPLE_diamond, Xdiamond);
+         play_element_sound(x, y, SOUND_diamond, Xdiamond);
          goto loop;
       }
 
@@ -3829,23 +3829,23 @@ void synchro_2(void)
        case Xacid_6:
        case Xacid_7:
        case Xacid_8:
-         Cave[y][x] = Ydrip_s1B;
+         Cave[y][x] = Ydrip_1_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xdrip_stretchB;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
        case Xplant:
        case Yplant:
        case Zplayer:
-         Cave[y][x] = Ydrip_s1B;
-         Cave[y+1][x] = Ydrip_s1;
+         Cave[y][x] = Ydrip_1_sB;
+         Cave[y+1][x] = Ydrip_1_s;
          Next[y][x] = Xdrip_stretchB;
          Next[y+1][x] = Xdrip_stretch;
          goto loop;
@@ -3888,23 +3888,23 @@ void synchro_2(void)
 
          Cave[y][x] = temp;
          Next[y][x] = temp;
-         play_element_sound(x, y, SAMPLE_drip, Xdrip_fall);
+         play_element_sound(x, y, SOUND_drip, Xdrip_fall);
          goto loop;
       }
 
     /* --------------------------------------------------------------------- */
 
     case Xdrip_stretch:
-      Cave[y][x] = Ydrip_s2;
+      Cave[y][x] = Ydrip_2_s;
       Next[y][x] = Xdrip_fall;
       goto loop;
 
     case Xdrip_stretchB:
-      Cave[y][x] = Ydrip_s2B;
+      Cave[y][x] = Ydrip_2_sB;
       Next[y][x] = Xblank;
       goto loop;
 
-    case Xdrip_eat:
+    case Xdrip:
       Next[y][x] = Xdrip_fall;
       goto loop;
 
@@ -3923,16 +3923,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybomb_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ybomb_sB;
          Cave[y+1][x] = Ybomb_s;
          Next[y][x] = Xblank;
@@ -3967,8 +3967,8 @@ void synchro_2(void)
        case Xball_2:
        case Xnut:
        case Xnut_pause:
-       case Xgrow_ns:
-       case Xgrow_ew:
+       case Xslidewall_ns:
+       case Xslidewall_ew:
        case Xkey_1:
        case Xkey_2:
        case Xkey_3:
@@ -3979,10 +3979,10 @@ void synchro_2(void)
        case Xkey_8:
        case Xbumper:
        case Xswitch:
-       case Xround_wall_1:
-       case Xround_wall_2:
-       case Xround_wall_3:
-       case Xround_wall_4:
+       case Xroundwall_1:
+       case Xroundwall_2:
+       case Xroundwall_3:
+       case Xroundwall_4:
          if (RANDOM & 1)
          {
            if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
@@ -4043,16 +4043,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybomb_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ybomb_sB;
          Cave[y+1][x] = Ybomb_s;
          Next[y][x] = Xblank;
@@ -4080,16 +4080,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Ybomb_sB;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xblank;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Ybomb_sB;
          Cave[y+1][x] = Ybomb_s;
          Next[y][x] = Xblank;
@@ -4097,7 +4097,7 @@ void synchro_2(void)
          goto loop;
 
        default:
-         Cave[y][x] = Ybomb_eat;
+         Cave[y][x] = Ybomb_blank;
          Next[y][x] = Znormal;
          Boom[y-1][x-1] = Xblank;
          Boom[y-1][x] = Xblank;
@@ -4109,7 +4109,7 @@ void synchro_2(void)
          Boom[y+1][x] = Xblank;
          Boom[y+1][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-         play_element_sound(x, y, SAMPLE_boom, element);
+         play_element_sound(x, y, SOUND_boom, element);
 #endif
          goto loop;
       }
@@ -4135,16 +4135,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yballoon_nB;
              if (Cave[y-2][x+1] == Xblank)
-               Cave[y-2][x+1] = Yacid_splash_eB;
+               Cave[y-2][x+1] = Xacid_splash_e;
              if (Cave[y-2][x-1] == Xblank)
-               Cave[y-2][x-1] = Yacid_splash_wB;
+               Cave[y-2][x-1] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
              Cave[y][x] = Yballoon_nB;
              Cave[y-1][x] = Yballoon_n;
              Next[y][x] = Xblank;
@@ -4168,16 +4168,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yballoon_eB;
              if (Cave[y-1][x+2] == Xblank)
-               Cave[y-1][x+2] = Yacid_splash_eB;
+               Cave[y-1][x+2] = Xacid_splash_e;
              if (Cave[y-1][x] == Xblank)
-               Cave[y-1][x] = Yacid_splash_wB;
+               Cave[y-1][x] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
              Cave[y][x] = Yballoon_eB;
              Cave[y][x+1] = Yballoon_e;
              Next[y][x] = Xblank;
@@ -4201,16 +4201,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yballoon_sB;
              if (Cave[y][x+1] == Xblank)
-               Cave[y][x+1] = Yacid_splash_eB;
+               Cave[y][x+1] = Xacid_splash_e;
              if (Cave[y][x-1] == Xblank)
-               Cave[y][x-1] = Yacid_splash_wB;
+               Cave[y][x-1] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
              Cave[y][x] = Yballoon_sB;
              Cave[y+1][x] = Yballoon_s;
              Next[y][x] = Xblank;
@@ -4234,16 +4234,16 @@ void synchro_2(void)
            case Xacid_8:
              Cave[y][x] = Yballoon_wB;
              if (Cave[y-1][x] == Xblank)
-               Cave[y-1][x] = Yacid_splash_eB;
+               Cave[y-1][x] = Xacid_splash_e;
              if (Cave[y-1][x-2] == Xblank)
-               Cave[y-1][x-2] = Yacid_splash_wB;
+               Cave[y-1][x-2] = Xacid_splash_w;
              Next[y][x] = Xblank;
-             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+             play_element_sound(x, y, SOUND_acid, Xacid_1);
              goto loop;
 
            case Xblank:
-           case Yacid_splash_eB:
-           case Yacid_splash_wB:
+           case Xacid_splash_e:
+           case Xacid_splash_w:
              Cave[y][x] = Yballoon_wB;
              Cave[y][x-1] = Yballoon_w;
              Next[y][x] = Xblank;
@@ -4327,7 +4327,7 @@ void synchro_2(void)
       if (lev.ball_state == 0)
        goto loop;
 
-      Cave[y][x] = Xball_1B;
+      Cave[y][x] = Yball_1;
       Next[y][x] = Xball_2;
       if (lev.ball_cnt)
        goto loop;
@@ -4338,7 +4338,7 @@ void synchro_2(void)
       if (lev.ball_state == 0)
        goto loop;
 
-      Cave[y][x] = Xball_2B;
+      Cave[y][x] = Yball_2;
       Next[y][x] = Xball_1;
       if (lev.ball_cnt)
        goto loop;
@@ -4347,7 +4347,7 @@ void synchro_2(void)
 
     ball_common:
 
-      play_element_sound(x, y, SAMPLE_ball, element);
+      play_element_sound(x, y, SOUND_ball, element);
       if (lev.ball_random)
       {
        switch (RANDOM & 7)
@@ -4356,7 +4356,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][0] != Xblank &&
                tab_blank[Cave[y-1][x-1]])
            {
-             Cave[y-1][x-1] = Yball_eat;
+             Cave[y-1][x-1] = Yball_blank;
              Next[y-1][x-1] = lev.ball_array[lev.ball_pos][0];
            }
            break;
@@ -4365,7 +4365,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][1] != Xblank &&
                tab_blank[Cave[y-1][x]])
            {
-             Cave[y-1][x] = Yball_eat;
+             Cave[y-1][x] = Yball_blank;
              Next[y-1][x] = lev.ball_array[lev.ball_pos][1];
            }
            break;
@@ -4374,7 +4374,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][2] != Xblank &&
                tab_blank[Cave[y-1][x+1]])
            {
-             Cave[y-1][x+1] = Yball_eat;
+             Cave[y-1][x+1] = Yball_blank;
              Next[y-1][x+1] = lev.ball_array[lev.ball_pos][2];
            }
            break;
@@ -4383,7 +4383,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][3] != Xblank &&
                tab_blank[Cave[y][x-1]])
            {
-             Cave[y][x-1] = Yball_eat;
+             Cave[y][x-1] = Yball_blank;
              Next[y][x-1] = lev.ball_array[lev.ball_pos][3];
            }
            break;
@@ -4392,7 +4392,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][4] != Xblank &&
                tab_blank[Cave[y][x+1]])
            {
-             Cave[y][x+1] = Yball_eat;
+             Cave[y][x+1] = Yball_blank;
              Next[y][x+1] = lev.ball_array[lev.ball_pos][4];
            }
            break;
@@ -4401,7 +4401,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][5] != Xblank &&
                tab_blank[Cave[y+1][x-1]])
            {
-             Cave[y+1][x-1] = Yball_eat;
+             Cave[y+1][x-1] = Yball_blank;
              Next[y+1][x-1] = lev.ball_array[lev.ball_pos][5];
            }
            break;
@@ -4410,7 +4410,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][6] != Xblank &&
                tab_blank[Cave[y+1][x]])
            {
-             Cave[y+1][x] = Yball_eat;
+             Cave[y+1][x] = Yball_blank;
              Next[y+1][x] = lev.ball_array[lev.ball_pos][6];
            }
            break;
@@ -4419,7 +4419,7 @@ void synchro_2(void)
            if (lev.ball_array[lev.ball_pos][7] != Xblank &&
                tab_blank[Cave[y+1][x+1]])
            {
-             Cave[y+1][x+1] = Yball_eat;
+             Cave[y+1][x+1] = Yball_blank;
              Next[y+1][x+1] = lev.ball_array[lev.ball_pos][7];
            }
            break;
@@ -4430,56 +4430,56 @@ void synchro_2(void)
        if (lev.ball_array[lev.ball_pos][0] != Xblank &&
            tab_blank[Cave[y-1][x-1]])
        {
-         Cave[y-1][x-1] = Yball_eat;
+         Cave[y-1][x-1] = Yball_blank;
          Next[y-1][x-1] = lev.ball_array[lev.ball_pos][0];
        }
 
        if (lev.ball_array[lev.ball_pos][1] != Xblank &&
            tab_blank[Cave[y-1][x]])
        {
-         Cave[y-1][x] = Yball_eat;
+         Cave[y-1][x] = Yball_blank;
          Next[y-1][x] = lev.ball_array[lev.ball_pos][1];
        }
 
        if (lev.ball_array[lev.ball_pos][2] != Xblank &&
            tab_blank[Cave[y-1][x+1]])
        {
-         Cave[y-1][x+1] = Yball_eat;
+         Cave[y-1][x+1] = Yball_blank;
          Next[y-1][x+1] = lev.ball_array[lev.ball_pos][2];
        }
 
        if (lev.ball_array[lev.ball_pos][3] != Xblank &&
            tab_blank[Cave[y][x-1]])
        {
-         Cave[y][x-1] = Yball_eat;
+         Cave[y][x-1] = Yball_blank;
          Next[y][x-1] = lev.ball_array[lev.ball_pos][3];
        }
 
        if (lev.ball_array[lev.ball_pos][4] != Xblank &&
            tab_blank[Cave[y][x+1]])
        {
-         Cave[y][x+1] = Yball_eat;
+         Cave[y][x+1] = Yball_blank;
          Next[y][x+1] = lev.ball_array[lev.ball_pos][4];
        }
 
        if (lev.ball_array[lev.ball_pos][5] != Xblank &&
            tab_blank[Cave[y+1][x-1]])
        {
-         Cave[y+1][x-1] = Yball_eat;
+         Cave[y+1][x-1] = Yball_blank;
          Next[y+1][x-1] = lev.ball_array[lev.ball_pos][5];
        }
 
        if (lev.ball_array[lev.ball_pos][6] != Xblank &&
            tab_blank[Cave[y+1][x]])
        {
-         Cave[y+1][x] = Yball_eat;
+         Cave[y+1][x] = Yball_blank;
          Next[y+1][x] = lev.ball_array[lev.ball_pos][6];
        }
 
        if (lev.ball_array[lev.ball_pos][7] != Xblank &&
            tab_blank[Cave[y+1][x+1]])
        {
-         Cave[y+1][x+1] = Yball_eat;
+         Cave[y+1][x+1] = Yball_blank;
          Next[y+1][x+1] = lev.ball_array[lev.ball_pos][7];
        }
       }
@@ -4490,36 +4490,36 @@ void synchro_2(void)
 
     /* --------------------------------------------------------------------- */
 
-    case Xgrow_ns:
+    case Xslidewall_ns:
       if (tab_blank[Cave[y-1][x]])
       {
-       Cave[y-1][x] = Ygrow_ns_eat;
-       Next[y-1][x] = Xgrow_ns;
-       play_element_sound(x, y, SAMPLE_grow, Xgrow_ns);
+       Cave[y-1][x] = Yslidewall_ns_blank;
+       Next[y-1][x] = Xslidewall_ns;
+       play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
       }
 
       if (tab_blank[Cave[y+1][x]])
       {
-       Cave[y+1][x] = Ygrow_ns_eat;
-       Next[y+1][x] = Xgrow_ns;
-       play_element_sound(x, y, SAMPLE_grow, Xgrow_ns);
+       Cave[y+1][x] = Yslidewall_ns_blank;
+       Next[y+1][x] = Xslidewall_ns;
+       play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
       }
 
       goto loop;
 
-    case Xgrow_ew:
+    case Xslidewall_ew:
       if (tab_blank[Cave[y][x+1]])
       {
-       Cave[y][x+1] = Ygrow_ew_eat;
-       Next[y][x+1] = Xgrow_ew;
-       play_element_sound(x, y, SAMPLE_grow, Xgrow_ew);
+       Cave[y][x+1] = Yslidewall_ew_blank;
+       Next[y][x+1] = Xslidewall_ew;
+       play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
       }
 
       if (tab_blank[Cave[y][x-1]])
       {
-       Cave[y][x-1] = Ygrow_ew_eat;
-       Next[y][x-1] = Xgrow_ew;
-       play_element_sound(x, y, SAMPLE_grow, Xgrow_ew);
+       Cave[y][x-1] = Yslidewall_ew_blank;
+       Next[y][x-1] = Xslidewall_ew;
+       play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
       }
 
       goto loop;
@@ -4530,7 +4530,7 @@ void synchro_2(void)
       if (lev.wonderwall_time && lev.wonderwall_state)
       {
        Cave[y][x] = XwonderwallB;
-       play_element_sound(x, y, SAMPLE_wonder, Xwonderwall);
+       play_element_sound(x, y, SOUND_wonder, Xwonderwall);
       }
 
       goto loop;
@@ -4558,7 +4558,7 @@ void synchro_2(void)
        Next[y][x] = Xexit_1;
       }
 
-      play_element_sound(x, y, SAMPLE_exit_open, Xexit);
+      play_element_sound(x, y, SOUND_exit_open, Xexit);
 
       goto loop;
 
@@ -4577,22 +4577,22 @@ void synchro_2(void)
     /* --------------------------------------------------------------------- */
 
     case Xdynamite_1:
-      play_element_sound(x, y, SAMPLE_tick, Xdynamite_1);
+      play_element_sound(x, y, SOUND_tick, Xdynamite_1);
       Next[y][x] = Xdynamite_2;
       goto loop;
 
     case Xdynamite_2:
-      play_element_sound(x, y, SAMPLE_tick, Xdynamite_2);
+      play_element_sound(x, y, SOUND_tick, Xdynamite_2);
       Next[y][x] = Xdynamite_3;
       goto loop;
 
     case Xdynamite_3:
-      play_element_sound(x, y, SAMPLE_tick, Xdynamite_3);
+      play_element_sound(x, y, SOUND_tick, Xdynamite_3);
       Next[y][x] = Xdynamite_4;
       goto loop;
 
     case Xdynamite_4:
-      play_element_sound(x, y, SAMPLE_tick, Xdynamite_4);
+      play_element_sound(x, y, SOUND_tick, Xdynamite_4);
       Next[y][x] = Zdynamite;
       Boom[y-1][x-1] = Xblank;
       Boom[y-1][x] = Xblank;
@@ -4634,16 +4634,16 @@ void synchro_2(void)
        case Xacid_8:
          Cave[y][x] = Xsand_stonesand_quickout_1;
          if (Cave[y][x+1] == Xblank)
-           Cave[y][x+1] = Yacid_splash_eB;
+           Cave[y][x+1] = Xacid_splash_e;
          if (Cave[y][x-1] == Xblank)
-           Cave[y][x-1] = Yacid_splash_wB;
+           Cave[y][x-1] = Xacid_splash_w;
          Next[y][x] = Xsand_stonesand_quickout_2;
-         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
+         play_element_sound(x, y, SOUND_acid, Xacid_1);
          goto loop;
 
        case Xblank:
-       case Yacid_splash_eB:
-       case Yacid_splash_wB:
+       case Xacid_splash_e:
+       case Xacid_splash_w:
          Cave[y][x] = Xsand_stonesand_quickout_1;
          Cave[y+1][x] = Xsand_stoneout_1;
          Next[y][x] = Xsand_stonesand_quickout_2;
@@ -4729,9 +4729,9 @@ void synchro_2(void)
 
     /* --------------------------------------------------------------------- */
 
-    case Xdripper:
+    case Xfake_amoeba:
       if (lev.lenses_cnt)
-       Cave[y][x] = XdripperB;
+       Cave[y][x] = Xfake_amoebaB;
       goto loop;
 
     /* --------------------------------------------------------------------- */
@@ -4805,7 +4805,7 @@ void synchro_2(void)
       Boom[y+1][x] = Xemerald;
       Boom[y+1][x+1] = Xemerald;
 #if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SAMPLE_boom, element);
+      play_element_sound(x, y, SOUND_boom, element);
 #endif
       goto loop;
 
@@ -4824,19 +4824,19 @@ void synchro_2(void)
       Boom[y+1][x] = Xblank;
       Boom[y+1][x+1] = Xblank;
 #if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SAMPLE_boom, element);
+      play_element_sound(x, y, SOUND_boom, element);
 #endif
       goto loop;
 
     case Xboom_android:
 #if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SAMPLE_boom, Xandroid);
+      play_element_sound(x, y, SOUND_boom, Xandroid);
 #endif
     case Xboom_1:
       Next[y][x] = Xboom_2;
 #if !PLAY_ELEMENT_SOUND
       if (x != lev.exit_x && y != lev.exit_y)
-       play_sound(x, y, SAMPLE_boom);
+       play_sound(x, y, SOUND_boom);
       else
        lev.exit_x = lev.exit_y = -1;
 #endif
@@ -4848,7 +4848,7 @@ void synchro_2(void)
 
     /* --------------------------------------------------------------------- */
 
-    case ZBORDER:
+    case Zborder:
       if (++y < HEIGHT - 1)
       {
        x = 0;
diff --git a/src/game_em/synchro_3.c b/src/game_em/synchro_3.c
index ca83a820d2fdcad18834058d06a166dbabf2ba36..cdea7a2149d113dde8bc3545a8b573ce4007f0c2 100644 (file)
--- a/src/game_em/synchro_3.c
+++ b/src/game_em/synchro_3.c
@@ -39,7 +39,7 @@ void synchro_3(void)
     lev.wonderwall_time--;
 
   if (lev.wheel_cnt)
-    play_element_sound(lev.wheel_x, lev.wheel_y, SAMPLE_wheel, Xwheel);
+    play_element_sound(lev.wheel_x, lev.wheel_y, SOUND_wheel, Xwheel);
 
   /* grow amoeba */
 
@@ -52,8 +52,8 @@ void synchro_3(void)
     switch (Cave[y][x])
     {
       case Xblank:
-      case Yacid_splash_eB:
-      case Yacid_splash_wB:
+      case Xacid_splash_e:
+      case Xacid_splash_w:
       case Xgrass:
       case Xdirt:
       case Xsand:
@@ -63,7 +63,7 @@ void synchro_3(void)
            tab_amoeba[Cave[y][x+1]] ||
            tab_amoeba[Cave[y+1][x]] ||
            tab_amoeba[Cave[y][x-1]])
-         Cave[y][x] = Xdrip_eat;
+         Cave[y][x] = Xdrip;
     }
 
     random = random * 129 + 1;
diff --git a/src/game_em/tab_generate.c b/src/game_em/tab_generate.c
index f109fa878a2b3562f72afd7dc451420ea2f89bc9..bcdecfe5c27cb664125e9ebd37601b9872bfea52 100644 (file)
--- a/src/game_em/tab_generate.c
+++ b/src/game_em/tab_generate.c
@@ -20,8 +20,8 @@
 int tile_blank[] =
 {
   Xblank, 1,
-  Yacid_splash_eB, 1,
-  Yacid_splash_wB, 1,
+  Xacid_splash_e, 1,
+  Xacid_splash_w, 1,
   TILE_MAX
 };
 
@@ -29,8 +29,8 @@ int tile_blank[] =
 int tile_acid[] =
 {
   Xblank, 1,
-  Yacid_splash_eB, 1,
-  Yacid_splash_wB, 1,
+  Xacid_splash_e, 1,
+  Xacid_splash_w, 1,
   Xacid_1, 1,
   Xacid_2, 1,
   Xacid_3, 1,
@@ -45,8 +45,8 @@ int tile_acid[] =
 /* 0=stop 1=amoeba */
 int tile_amoeba[] =
 {
-  Xdripper, 1,
-  XdripperB, 1,
+  Xfake_amoeba, 1,
+  Xfake_amoebaB, 1,
   Xamoeba_1, 1,
   Xamoeba_2, 1,
   Xamoeba_3, 1,
@@ -62,8 +62,8 @@ int tile_amoeba[] =
 int tile_android_move[] =
 {
   Xblank, 1,
-  Yacid_splash_eB, 1,
-  Yacid_splash_wB, 1,
+  Xacid_splash_e, 1,
+  Xacid_splash_w, 1,
   Xplant, 1,
   TILE_MAX
 };
@@ -75,7 +75,7 @@ int tile_android_move[] =
 /* everything is initially filled with Xboom_1 */
 int tile_explode[] =
 {
-  ZBORDER,
+  Zborder,
   Znormal,
   Zdynamite,
   Xboom_bug,
@@ -127,14 +127,14 @@ int tile_explode[] =
   Xsteel_4,
   TILE_MAX,                    /* up till here are indestructable */
 
-  Xbug_n, Xboom_bug,
-  Xbug_e, Xboom_bug,
-  Xbug_s, Xboom_bug,
-  Xbug_w, Xboom_bug,
-  Xbug_gon, Xboom_bug,
-  Xbug_goe, Xboom_bug,
-  Xbug_gos, Xboom_bug,
-  Xbug_gow, Xboom_bug,
+  Xbug_1_n, Xboom_bug,
+  Xbug_1_e, Xboom_bug,
+  Xbug_1_s, Xboom_bug,
+  Xbug_1_w, Xboom_bug,
+  Xbug_2_n, Xboom_bug,
+  Xbug_2_e, Xboom_bug,
+  Xbug_2_s, Xboom_bug,
+  Xbug_2_w, Xboom_bug,
   Xbomb, Xboom_bomb,
   Xbomb_pause, Xboom_bomb,
   Xbomb_fall, Xboom_bomb,
@@ -245,22 +245,22 @@ int obj_map[] =
   Xstone_fall, 7,
 
 #ifdef BAD_ROLL
-  Xstone_force_e, 0,
-  Xstone_force_e, 1,
-  Xstone_force_e, 2,
-  Xstone_force_e, 3,
-  Xstone_force_e, 4,
-  Xstone_force_e, 5,
-  Xstone_force_e, 6,
-  Xstone_force_e, 7,
-  Xstone_force_w, 0,
-  Xstone_force_w, 1,
-  Xstone_force_w, 2,
-  Xstone_force_w, 3,
-  Xstone_force_w, 4,
-  Xstone_force_w, 5,
-  Xstone_force_w, 6,
-  Xstone_force_w, 7,
+  Xpush_stone_e, 0,
+  Xpush_stone_e, 1,
+  Xpush_stone_e, 2,
+  Xpush_stone_e, 3,
+  Xpush_stone_e, 4,
+  Xpush_stone_e, 5,
+  Xpush_stone_e, 6,
+  Xpush_stone_e, 7,
+  Xpush_stone_w, 0,
+  Xpush_stone_w, 1,
+  Xpush_stone_w, 2,
+  Xpush_stone_w, 3,
+  Xpush_stone_w, 4,
+  Xpush_stone_w, 5,
+  Xpush_stone_w, 6,
+  Xpush_stone_w, 7,
 #endif
 
   Ystone_s, 7,
@@ -365,22 +365,22 @@ int obj_map[] =
   Xnut_fall, 7,
 
 #ifdef BAD_ROLL
-  Xnut_force_e, 0,
-  Xnut_force_e, 1,
-  Xnut_force_e, 2,
-  Xnut_force_e, 3,
-  Xnut_force_e, 4,
-  Xnut_force_e, 5,
-  Xnut_force_e, 6,
-  Xnut_force_e, 7,
-  Xnut_force_w, 0,
-  Xnut_force_w, 1,
-  Xnut_force_w, 2,
-  Xnut_force_w, 3,
-  Xnut_force_w, 4,
-  Xnut_force_w, 5,
-  Xnut_force_w, 6,
-  Xnut_force_w, 7,
+  Xpush_nut_e, 0,
+  Xpush_nut_e, 1,
+  Xpush_nut_e, 2,
+  Xpush_nut_e, 3,
+  Xpush_nut_e, 4,
+  Xpush_nut_e, 5,
+  Xpush_nut_e, 6,
+  Xpush_nut_e, 7,
+  Xpush_nut_w, 0,
+  Xpush_nut_w, 1,
+  Xpush_nut_w, 2,
+  Xpush_nut_w, 3,
+  Xpush_nut_w, 4,
+  Xpush_nut_w, 5,
+  Xpush_nut_w, 6,
+  Xpush_nut_w, 7,
 #endif
 
   -1,
@@ -425,14 +425,14 @@ int obj_map[] =
   Xfake_blank, 5,
   Xfake_blank, 6,
   Xfake_blank, 7,
-  Xdripper, 0,
-  Xdripper, 1,
-  Xdripper, 2,
-  Xdripper, 3,
-  Xdripper, 4,
-  Xdripper, 5,
-  Xdripper, 6,
-  Xdripper, 7,
+  Xfake_amoeba, 0,
+  Xfake_amoeba, 1,
+  Xfake_amoeba, 2,
+  Xfake_amoeba, 3,
+  Xfake_amoeba, 4,
+  Xfake_amoeba, 5,
+  Xfake_amoeba, 6,
+  Xfake_amoeba, 7,
   Zplayer, 0,
   Zplayer, 1,
   Zplayer, 2,
@@ -441,11 +441,11 @@ int obj_map[] =
   Zplayer, 5,
   Zplayer, 6,
   Zplayer, 7,
-  Ydynamite_eat, 3,
-  Ydynamite_eat, 4,
-  Ydynamite_eat, 5,
-  Ydynamite_eat, 6,
-  Ydynamite_eat, 7,
+  Ydynamite_blank, 3,
+  Ydynamite_blank, 4,
+  Ydynamite_blank, 5,
+  Ydynamite_blank, 6,
+  Ydynamite_blank, 7,
   -1,
   -1,
   -1,
@@ -541,82 +541,82 @@ int obj_map[] =
   Ybug_w_n, 7,
   Ybug_e_n, 7,
   Ybug_n, 7,
-  Xbug_n, 0,
-  Xbug_n, 1,
-  Xbug_n, 2,
-  Xbug_n, 3,
-  Xbug_n, 4,
-  Xbug_n, 5,
-  Xbug_n, 6,
-  Xbug_n, 7,
-  Xbug_gon, 0,
-  Xbug_gon, 1,
-  Xbug_gon, 2,
-  Xbug_gon, 3,
-  Xbug_gon, 4,
-  Xbug_gon, 5,
-  Xbug_gon, 6,
-  Xbug_gon, 7,
+  Xbug_1_n, 0,
+  Xbug_1_n, 1,
+  Xbug_1_n, 2,
+  Xbug_1_n, 3,
+  Xbug_1_n, 4,
+  Xbug_1_n, 5,
+  Xbug_1_n, 6,
+  Xbug_1_n, 7,
+  Xbug_2_n, 0,
+  Xbug_2_n, 1,
+  Xbug_2_n, 2,
+  Xbug_2_n, 3,
+  Xbug_2_n, 4,
+  Xbug_2_n, 5,
+  Xbug_2_n, 6,
+  Xbug_2_n, 7,
   -1,
   Ybug_n_e, 7,
   Ybug_s_e, 7,
   Ybug_e, 7,
-  Xbug_e, 0,
-  Xbug_e, 1,
-  Xbug_e, 2,
-  Xbug_e, 3,
-  Xbug_e, 4,
-  Xbug_e, 5,
-  Xbug_e, 6,
-  Xbug_e, 7,
-  Xbug_goe, 0,
-  Xbug_goe, 1,
-  Xbug_goe, 2,
-  Xbug_goe, 3,
-  Xbug_goe, 4,
-  Xbug_goe, 5,
-  Xbug_goe, 6,
-  Xbug_goe, 7,
+  Xbug_1_e, 0,
+  Xbug_1_e, 1,
+  Xbug_1_e, 2,
+  Xbug_1_e, 3,
+  Xbug_1_e, 4,
+  Xbug_1_e, 5,
+  Xbug_1_e, 6,
+  Xbug_1_e, 7,
+  Xbug_2_e, 0,
+  Xbug_2_e, 1,
+  Xbug_2_e, 2,
+  Xbug_2_e, 3,
+  Xbug_2_e, 4,
+  Xbug_2_e, 5,
+  Xbug_2_e, 6,
+  Xbug_2_e, 7,
   -1,
   Ybug_e_s, 7,
   Ybug_w_s, 7,
   Ybug_s, 7,
-  Xbug_s, 0,
-  Xbug_s, 1,
-  Xbug_s, 2,
-  Xbug_s, 3,
-  Xbug_s, 4,
-  Xbug_s, 5,
-  Xbug_s, 6,
-  Xbug_s, 7,
-  Xbug_gos, 0,
-  Xbug_gos, 1,
-  Xbug_gos, 2,
-  Xbug_gos, 3,
-  Xbug_gos, 4,
-  Xbug_gos, 5,
-  Xbug_gos, 6,
-  Xbug_gos, 7,
+  Xbug_1_s, 0,
+  Xbug_1_s, 1,
+  Xbug_1_s, 2,
+  Xbug_1_s, 3,
+  Xbug_1_s, 4,
+  Xbug_1_s, 5,
+  Xbug_1_s, 6,
+  Xbug_1_s, 7,
+  Xbug_2_s, 0,
+  Xbug_2_s, 1,
+  Xbug_2_s, 2,
+  Xbug_2_s, 3,
+  Xbug_2_s, 4,
+  Xbug_2_s, 5,
+  Xbug_2_s, 6,
+  Xbug_2_s, 7,
   -1,
   Ybug_n_w, 7,
   Ybug_s_w, 7,
   Ybug_w, 7,
-  Xbug_w, 0,
-  Xbug_w, 1,
-  Xbug_w, 2,
-  Xbug_w, 3,
-  Xbug_w, 4,
-  Xbug_w, 5,
-  Xbug_w, 6,
-  Xbug_w, 7,
-  Xbug_gow, 0,
-  Xbug_gow, 1,
-  Xbug_gow, 2,
-  Xbug_gow, 3,
-  Xbug_gow, 4,
-  Xbug_gow, 5,
-  Xbug_gow, 6,
-  Xbug_gow, 7,
+  Xbug_1_w, 0,
+  Xbug_1_w, 1,
+  Xbug_1_w, 2,
+  Xbug_1_w, 3,
+  Xbug_1_w, 4,
+  Xbug_1_w, 5,
+  Xbug_1_w, 6,
+  Xbug_1_w, 7,
+  Xbug_2_w, 0,
+  Xbug_2_w, 1,
+  Xbug_2_w, 2,
+  Xbug_2_w, 3,
+  Xbug_2_w, 4,
+  Xbug_2_w, 5,
+  Xbug_2_w, 6,
+  Xbug_2_w, 7,
   -1,
   Ybug_n, 0,
   -1,
@@ -846,82 +846,82 @@ int obj_map[] =
   Ytank_w_n, 7,
   Ytank_e_n, 7,
   Ytank_n, 7,
-  Xtank_n, 0,
-  Xtank_n, 1,
-  Xtank_n, 2,
-  Xtank_n, 3,
-  Xtank_n, 4,
-  Xtank_n, 5,
-  Xtank_n, 6,
-  Xtank_n, 7,
-  Xtank_gon, 0,
-  Xtank_gon, 1,
-  Xtank_gon, 2,
-  Xtank_gon, 3,
-  Xtank_gon, 4,
-  Xtank_gon, 5,
-  Xtank_gon, 6,
-  Xtank_gon, 7,
+  Xtank_1_n, 0,
+  Xtank_1_n, 1,
+  Xtank_1_n, 2,
+  Xtank_1_n, 3,
+  Xtank_1_n, 4,
+  Xtank_1_n, 5,
+  Xtank_1_n, 6,
+  Xtank_1_n, 7,
+  Xtank_2_n, 0,
+  Xtank_2_n, 1,
+  Xtank_2_n, 2,
+  Xtank_2_n, 3,
+  Xtank_2_n, 4,
+  Xtank_2_n, 5,
+  Xtank_2_n, 6,
+  Xtank_2_n, 7,
   -1,
   Ytank_n_e, 7,
   Ytank_s_e, 7,
   Ytank_e, 7,
-  Xtank_e, 0,
-  Xtank_e, 1,
-  Xtank_e, 2,
-  Xtank_e, 3,
-  Xtank_e, 4,
-  Xtank_e, 5,
-  Xtank_e, 6,
-  Xtank_e, 7,
-  Xtank_goe, 0,
-  Xtank_goe, 1,
-  Xtank_goe, 2,
-  Xtank_goe, 3,
-  Xtank_goe, 4,
-  Xtank_goe, 5,
-  Xtank_goe, 6,
-  Xtank_goe, 7,
+  Xtank_1_e, 0,
+  Xtank_1_e, 1,
+  Xtank_1_e, 2,
+  Xtank_1_e, 3,
+  Xtank_1_e, 4,
+  Xtank_1_e, 5,
+  Xtank_1_e, 6,
+  Xtank_1_e, 7,
+  Xtank_2_e, 0,
+  Xtank_2_e, 1,
+  Xtank_2_e, 2,
+  Xtank_2_e, 3,
+  Xtank_2_e, 4,
+  Xtank_2_e, 5,
+  Xtank_2_e, 6,
+  Xtank_2_e, 7,
   -1,
   Ytank_e_s, 7,
   Ytank_w_s, 7,
   Ytank_s, 7,
-  Xtank_s, 0,
-  Xtank_s, 1,
-  Xtank_s, 2,
-  Xtank_s, 3,
-  Xtank_s, 4,
-  Xtank_s, 5,
-  Xtank_s, 6,
-  Xtank_s, 7,
-  Xtank_gos, 0,
-  Xtank_gos, 1,
-  Xtank_gos, 2,
-  Xtank_gos, 3,
-  Xtank_gos, 4,
-  Xtank_gos, 5,
-  Xtank_gos, 6,
-  Xtank_gos, 7,
+  Xtank_1_s, 0,
+  Xtank_1_s, 1,
+  Xtank_1_s, 2,
+  Xtank_1_s, 3,
+  Xtank_1_s, 4,
+  Xtank_1_s, 5,
+  Xtank_1_s, 6,
+  Xtank_1_s, 7,
+  Xtank_2_s, 0,
+  Xtank_2_s, 1,
+  Xtank_2_s, 2,
+  Xtank_2_s, 3,
+  Xtank_2_s, 4,
+  Xtank_2_s, 5,
+  Xtank_2_s, 6,
+  Xtank_2_s, 7,
   -1,
   Ytank_n_w, 7,
   Ytank_s_w, 7,
   Ytank_w, 7,
-  Xtank_w, 0,
-  Xtank_w, 1,
-  Xtank_w, 2,
-  Xtank_w, 3,
-  Xtank_w, 4,
-  Xtank_w, 5,
-  Xtank_w, 6,
-  Xtank_w, 7,
-  Xtank_gow, 0,
-  Xtank_gow, 1,
-  Xtank_gow, 2,
-  Xtank_gow, 3,
-  Xtank_gow, 4,
-  Xtank_gow, 5,
-  Xtank_gow, 6,
-  Xtank_gow, 7,
+  Xtank_1_w, 0,
+  Xtank_1_w, 1,
+  Xtank_1_w, 2,
+  Xtank_1_w, 3,
+  Xtank_1_w, 4,
+  Xtank_1_w, 5,
+  Xtank_1_w, 6,
+  Xtank_1_w, 7,
+  Xtank_2_w, 0,
+  Xtank_2_w, 1,
+  Xtank_2_w, 2,
+  Xtank_2_w, 3,
+  Xtank_2_w, 4,
+  Xtank_2_w, 5,
+  Xtank_2_w, 6,
+  Xtank_2_w, 7,
   -1,
   Ytank_n, 0,
   -1,
@@ -1414,8 +1414,8 @@ int obj_map[] =
 
   Yspring_e, 7,
   Yspring_w, 7,
-  Yspring_kill_e, 7,
-  Yspring_kill_w, 7,
+  Yspring_alien_e, 7,
+  Yspring_alien_w, 7,
   Yspring_s, 7,
   Xspring, 0,
   Xspring, 1,
@@ -1459,22 +1459,22 @@ int obj_map[] =
   Xspring_fall, 7,
 
 #ifdef BAD_ROLL
-  Xspring_force_e, 0,
-  Xspring_force_e, 1,
-  Xspring_force_e, 2,
-  Xspring_force_e, 3,
-  Xspring_force_e, 4,
-  Xspring_force_e, 5,
-  Xspring_force_e, 6,
-  Xspring_force_e, 7,
-  Xspring_force_w, 0,
-  Xspring_force_w, 1,
-  Xspring_force_w, 2,
-  Xspring_force_w, 3,
-  Xspring_force_w, 4,
-  Xspring_force_w, 5,
-  Xspring_force_w, 6,
-  Xspring_force_w, 7,
+  Xpush_spring_e, 0,
+  Xpush_spring_e, 1,
+  Xpush_spring_e, 2,
+  Xpush_spring_e, 3,
+  Xpush_spring_e, 4,
+  Xpush_spring_e, 5,
+  Xpush_spring_e, 6,
+  Xpush_spring_e, 7,
+  Xpush_spring_w, 0,
+  Xpush_spring_w, 1,
+  Xpush_spring_w, 2,
+  Xpush_spring_w, 3,
+  Xpush_spring_w, 4,
+  Xpush_spring_w, 5,
+  Xpush_spring_w, 6,
+  Xpush_spring_w, 7,
 #endif
 
   -1,
@@ -1548,61 +1548,61 @@ int obj_map[] =
   Yspring_e, 0,
   Yspring_wB, 6,
   -1,
-  Yspring_kill_eB, 6,
+  Yspring_alien_eB, 6,
   -1,
-  Yspring_kill_e, 6,
+  Yspring_alien_e, 6,
   -1,
-  Yspring_kill_eB, 5,
+  Yspring_alien_eB, 5,
   -1,
-  Yspring_kill_e, 5,
+  Yspring_alien_e, 5,
   -1,
-  Yspring_kill_eB, 4,
+  Yspring_alien_eB, 4,
   -1,
-  Yspring_kill_e, 4,
+  Yspring_alien_e, 4,
   -1,
-  Yspring_kill_eB, 3,
+  Yspring_alien_eB, 3,
   -1,
-  Yspring_kill_e, 3,
+  Yspring_alien_e, 3,
   -1,
-  Yspring_kill_eB, 2,
+  Yspring_alien_eB, 2,
   -1,
-  Yspring_kill_e, 2,
+  Yspring_alien_e, 2,
   -1,
-  Yspring_kill_eB, 1,
+  Yspring_alien_eB, 1,
   -1,
-  Yspring_kill_e, 1,
+  Yspring_alien_e, 1,
   -1,
-  Yspring_kill_eB, 0,
+  Yspring_alien_eB, 0,
   -1,
-  Yspring_kill_e, 0,
+  Yspring_alien_e, 0,
   -1,
-  Yspring_kill_w, 0,
+  Yspring_alien_w, 0,
   -1,
-  Yspring_kill_wB, 0,
+  Yspring_alien_wB, 0,
   -1,
-  Yspring_kill_w, 1,
+  Yspring_alien_w, 1,
   -1,
-  Yspring_kill_wB, 1,
+  Yspring_alien_wB, 1,
   -1,
-  Yspring_kill_w, 2,
+  Yspring_alien_w, 2,
   -1,
-  Yspring_kill_wB, 2,
+  Yspring_alien_wB, 2,
   -1,
-  Yspring_kill_w, 3,
+  Yspring_alien_w, 3,
   -1,
-  Yspring_kill_wB, 3,
+  Yspring_alien_wB, 3,
   -1,
-  Yspring_kill_w, 4,
+  Yspring_alien_w, 4,
   -1,
-  Yspring_kill_wB, 4,
+  Yspring_alien_wB, 4,
   -1,
-  Yspring_kill_w, 5,
+  Yspring_alien_w, 5,
   -1,
-  Yspring_kill_wB, 5,
+  Yspring_alien_wB, 5,
   -1,
-  Yspring_kill_w, 6,
+  Yspring_alien_w, 6,
   -1,
-  Yspring_kill_wB, 6,
+  Yspring_alien_wB, 6,
   -1,
 
   Xeater_n, 0,
@@ -1921,27 +1921,27 @@ int obj_map[] =
   Xemerald_fall, 7,
 
 #ifdef BAD_ROLL
-  Xemerald_force_e, 0,
-  Xemerald_force_e, 1,
-  Xemerald_force_e, 2,
-  Xemerald_force_e, 3,
-  Xemerald_force_e, 4,
-  Xemerald_force_e, 5,
-  Xemerald_force_e, 6,
-  Xemerald_force_e, 7,
-  Xemerald_force_w, 0,
-  Xemerald_force_w, 1,
-  Xemerald_force_w, 2,
-  Xemerald_force_w, 3,
-  Xemerald_force_w, 4,
-  Xemerald_force_w, 5,
-  Xemerald_force_w, 6,
-  Xemerald_force_w, 7,
+  Xpush_emerald_e, 0,
+  Xpush_emerald_e, 1,
+  Xpush_emerald_e, 2,
+  Xpush_emerald_e, 3,
+  Xpush_emerald_e, 4,
+  Xpush_emerald_e, 5,
+  Xpush_emerald_e, 6,
+  Xpush_emerald_e, 7,
+  Xpush_emerald_w, 0,
+  Xpush_emerald_w, 1,
+  Xpush_emerald_w, 2,
+  Xpush_emerald_w, 3,
+  Xpush_emerald_w, 4,
+  Xpush_emerald_w, 5,
+  Xpush_emerald_w, 6,
+  Xpush_emerald_w, 7,
 #endif
 
   Xemerald_shine, 0,
   Xemerald_shine, 7,
-  Yemerald_stone, 7,
+  Ynut_stone, 7,
   Yemerald_s, 7,
   Yemerald_e, 7,
   Yemerald_w, 7,
@@ -2025,33 +2025,33 @@ int obj_map[] =
   Yemerald_e, 0,
   Yemerald_wB, 6,
   -1,
-  Yemerald_eat, 6,
+  Yemerald_blank, 6,
   -1,
-  Yemerald_eat, 5,
+  Yemerald_blank, 5,
   -1,
-  Yemerald_eat, 4,
+  Yemerald_blank, 4,
   -1,
-  Yemerald_eat, 3,
+  Yemerald_blank, 3,
   -1,
-  Yemerald_eat, 2,
+  Yemerald_blank, 2,
   -1,
-  Yemerald_eat, 1,
+  Yemerald_blank, 1,
   -1,
-  Yemerald_eat, 0,
+  Yemerald_blank, 0,
   -1,
-  Yemerald_stone, 0,
+  Ynut_stone, 0,
   -1,
-  Yemerald_stone, 1,
+  Ynut_stone, 1,
   -1,
-  Yemerald_stone, 2,
+  Ynut_stone, 2,
   -1,
-  Yemerald_stone, 3,
+  Ynut_stone, 3,
   -1,
-  Yemerald_stone, 4,
+  Ynut_stone, 4,
   -1,
-  Yemerald_stone, 5,
+  Ynut_stone, 5,
   -1,
-  Yemerald_stone, 6,
+  Ynut_stone, 6,
   -1,
 
   Xdiamond, 0,
@@ -2080,22 +2080,22 @@ int obj_map[] =
   Xdiamond_fall, 7,
 
 #ifdef BAD_ROLL
-  Xdiamond_force_e, 0,
-  Xdiamond_force_e, 1,
-  Xdiamond_force_e, 2,
-  Xdiamond_force_e, 3,
-  Xdiamond_force_e, 4,
-  Xdiamond_force_e, 5,
-  Xdiamond_force_e, 6,
-  Xdiamond_force_e, 7,
-  Xdiamond_force_w, 0,
-  Xdiamond_force_w, 1,
-  Xdiamond_force_w, 2,
-  Xdiamond_force_w, 3,
-  Xdiamond_force_w, 4,
-  Xdiamond_force_w, 5,
-  Xdiamond_force_w, 6,
-  Xdiamond_force_w, 7,
+  Xpush_diamond_e, 0,
+  Xpush_diamond_e, 1,
+  Xpush_diamond_e, 2,
+  Xpush_diamond_e, 3,
+  Xpush_diamond_e, 4,
+  Xpush_diamond_e, 5,
+  Xpush_diamond_e, 6,
+  Xpush_diamond_e, 7,
+  Xpush_diamond_w, 0,
+  Xpush_diamond_w, 1,
+  Xpush_diamond_w, 2,
+  Xpush_diamond_w, 3,
+  Xpush_diamond_w, 4,
+  Xpush_diamond_w, 5,
+  Xpush_diamond_w, 6,
+  Xpush_diamond_w, 7,
 #endif
 
   Xdiamond_shine, 0,
@@ -2183,19 +2183,19 @@ int obj_map[] =
   Ydiamond_e, 0,
   Ydiamond_wB, 6,
   -1,
-  Ydiamond_eat, 6,
+  Ydiamond_blank, 6,
   -1,
-  Ydiamond_eat, 5,
+  Ydiamond_blank, 5,
   -1,
-  Ydiamond_eat, 4,
+  Ydiamond_blank, 4,
   -1,
-  Ydiamond_eat, 3,
+  Ydiamond_blank, 3,
   -1,
-  Ydiamond_eat, 2,
+  Ydiamond_blank, 2,
   -1,
-  Ydiamond_eat, 1,
+  Ydiamond_blank, 1,
   -1,
-  Ydiamond_eat, 0,
+  Ydiamond_blank, 0,
   -1,
   Ydiamond_stone, 0,
   -1,
@@ -2220,36 +2220,36 @@ int obj_map[] =
   Xdrip_fall, 5,
   Xdrip_fall, 6,
   Xdrip_fall, 7,
-  Xdrip_eat, 7,
-  Ydrip_s2, 7,
+  Xdrip, 7,
+  Ydrip_2_s, 7,
   -1,
-  Ydrip_s2B, 6,
+  Ydrip_2_sB, 6,
   -1,
-  Ydrip_s2, 6,
+  Ydrip_2_s, 6,
   -1,
-  Ydrip_s2B, 5,
+  Ydrip_2_sB, 5,
   -1,
-  Ydrip_s2, 5,
+  Ydrip_2_s, 5,
   -1,
-  Ydrip_s2B, 4,
+  Ydrip_2_sB, 4,
   -1,
-  Ydrip_s2, 4,
+  Ydrip_2_s, 4,
   -1,
-  Ydrip_s2B, 3,
+  Ydrip_2_sB, 3,
   -1,
-  Ydrip_s2, 3,
+  Ydrip_2_s, 3,
   -1,
-  Ydrip_s2B, 2,
+  Ydrip_2_sB, 2,
   -1,
-  Ydrip_s2, 2,
+  Ydrip_2_s, 2,
   -1,
-  Ydrip_s2B, 1,
+  Ydrip_2_sB, 1,
   -1,
-  Ydrip_s2, 1,
+  Ydrip_2_s, 1,
   -1,
-  Ydrip_s2B, 0,
+  Ydrip_2_sB, 0,
   -1,
-  Ydrip_s2, 0,
+  Ydrip_2_s, 0,
   -1,
   Xdrip_stretchB, 0,
   Xdrip_stretchB, 1,
@@ -2259,7 +2259,7 @@ int obj_map[] =
   Xdrip_stretchB, 5,
   Xdrip_stretchB, 6,
   Xdrip_stretchB, 7,
-  Ydrip_s1B, 7,
+  Ydrip_1_sB, 7,
   -1,
   Xdrip_stretch, 0,
   Xdrip_stretch, 1,
@@ -2269,49 +2269,49 @@ int obj_map[] =
   Xdrip_stretch, 5,
   Xdrip_stretch, 6,
   Xdrip_stretch, 7,
-  Ydrip_s1, 7,
+  Ydrip_1_s, 7,
   -1,
-  Ydrip_s1B, 6,
+  Ydrip_1_sB, 6,
   -1,
-  Ydrip_s1, 6,
+  Ydrip_1_s, 6,
   -1,
-  Ydrip_s1B, 5,
+  Ydrip_1_sB, 5,
   -1,
-  Ydrip_s1, 5,
+  Ydrip_1_s, 5,
   -1,
-  Ydrip_s1B, 4,
+  Ydrip_1_sB, 4,
   -1,
-  Ydrip_s1, 4,
+  Ydrip_1_s, 4,
   -1,
-  Ydrip_s1B, 3,
+  Ydrip_1_sB, 3,
   -1,
-  Ydrip_s1, 3,
+  Ydrip_1_s, 3,
   -1,
-  Ydrip_s1B, 2,
+  Ydrip_1_sB, 2,
   -1,
-  Ydrip_s1, 2,
+  Ydrip_1_s, 2,
   -1,
-  Ydrip_s1B, 1,
+  Ydrip_1_sB, 1,
   -1,
-  Ydrip_s1, 1,
+  Ydrip_1_s, 1,
   -1,
-  Ydrip_s1B, 0,
+  Ydrip_1_sB, 0,
   -1,
-  Ydrip_s1, 0,
+  Ydrip_1_s, 0,
   -1,
-  Xdrip_eat, 0,
+  Xdrip, 0,
   -1,
-  Xdrip_eat, 1,
+  Xdrip, 1,
   -1,
-  Xdrip_eat, 2,
+  Xdrip, 2,
   -1,
-  Xdrip_eat, 3,
+  Xdrip, 3,
   -1,
-  Xdrip_eat, 4,
+  Xdrip, 4,
   -1,
-  Xdrip_eat, 5,
+  Xdrip, 5,
   -1,
-  Xdrip_eat, 6,
+  Xdrip, 6,
   -1,
 
   Xbomb, 0,
@@ -2340,22 +2340,22 @@ int obj_map[] =
   Xbomb_fall, 7,
 
 #ifdef BAD_ROLL
-  Xbomb_force_e, 0,
-  Xbomb_force_e, 1,
-  Xbomb_force_e, 2,
-  Xbomb_force_e, 3,
-  Xbomb_force_e, 4,
-  Xbomb_force_e, 5,
-  Xbomb_force_e, 6,
-  Xbomb_force_e, 7,
-  Xbomb_force_w, 0,
-  Xbomb_force_w, 1,
-  Xbomb_force_w, 2,
-  Xbomb_force_w, 3,
-  Xbomb_force_w, 4,
-  Xbomb_force_w, 5,
-  Xbomb_force_w, 6,
-  Xbomb_force_w, 7,
+  Xpush_bomb_e, 0,
+  Xpush_bomb_e, 1,
+  Xpush_bomb_e, 2,
+  Xpush_bomb_e, 3,
+  Xpush_bomb_e, 4,
+  Xpush_bomb_e, 5,
+  Xpush_bomb_e, 6,
+  Xpush_bomb_e, 7,
+  Xpush_bomb_w, 0,
+  Xpush_bomb_w, 1,
+  Xpush_bomb_w, 2,
+  Xpush_bomb_w, 3,
+  Xpush_bomb_w, 4,
+  Xpush_bomb_w, 5,
+  Xpush_bomb_w, 6,
+  Xpush_bomb_w, 7,
 #endif
 
   Ybomb_s, 7,
@@ -2432,19 +2432,19 @@ int obj_map[] =
   Ybomb_e, 0,
   Ybomb_wB, 6,
   -1,
-  Ybomb_eat, 6,
+  Ybomb_blank, 6,
   -1,
-  Ybomb_eat, 5,
+  Ybomb_blank, 5,
   -1,
-  Ybomb_eat, 4,
+  Ybomb_blank, 4,
   -1,
-  Ybomb_eat, 3,
+  Ybomb_blank, 3,
   -1,
-  Ybomb_eat, 2,
+  Ybomb_blank, 2,
   -1,
-  Ybomb_eat, 1,
+  Ybomb_blank, 1,
   -1,
-  Ybomb_eat, 0,
+  Ybomb_blank, 0,
   -1,
 
   Yballoon_n, 7,
@@ -2802,26 +2802,26 @@ int obj_map[] =
   Xacid_8, 6,
   Xacid_8, 7,
   -1,
-  Yacid_splash_wB, 4,
-  Yacid_splash_wB, 5,
+  Xacid_splash_w, 4,
+  Xacid_splash_w, 5,
   -1,
-  Yacid_splash_wB, 2,
-  Yacid_splash_wB, 3,
+  Xacid_splash_w, 2,
+  Xacid_splash_w, 3,
   -1,
-  Yacid_splash_wB, 0,
-  Yacid_splash_wB, 1,
+  Xacid_splash_w, 0,
+  Xacid_splash_w, 1,
   -1,
-  Yacid_splash_eB, 4,
-  Yacid_splash_eB, 5,
+  Xacid_splash_e, 4,
+  Xacid_splash_e, 5,
   -1,
-  Yacid_splash_eB, 2,
-  Yacid_splash_eB, 3,
+  Xacid_splash_e, 2,
+  Xacid_splash_e, 3,
   -1,
-  Yacid_splash_eB, 0,
-  Yacid_splash_eB, 1,
+  Xacid_splash_e, 0,
+  Xacid_splash_e, 1,
   -1,
 
-  Xball_2B, 7,
+  Yball_2, 7,
   Xball_1, 0,
   Xball_1, 1,
   Xball_1, 2,
@@ -2831,21 +2831,21 @@ int obj_map[] =
   Xball_1, 6,
   Xball_1, 7,
   -1,
-  Xball_1B, 0,
+  Yball_1, 0,
   -1,
-  Xball_1B, 1,
+  Yball_1, 1,
   -1,
-  Xball_1B, 2,
+  Yball_1, 2,
   -1,
-  Xball_1B, 3,
+  Yball_1, 3,
   -1,
-  Xball_1B, 4,
+  Yball_1, 4,
   -1,
-  Xball_1B, 5,
+  Yball_1, 5,
   -1,
-  Xball_1B, 6,
+  Yball_1, 6,
   -1,
-  Xball_1B, 7,
+  Yball_1, 7,
   Xball_2, 0,
   Xball_2, 1,
   Xball_2, 2,
@@ -2855,68 +2855,68 @@ int obj_map[] =
   Xball_2, 6,
   Xball_2, 7,
   -1,
-  Xball_2B, 0,
+  Yball_2, 0,
   -1,
-  Xball_2B, 1,
+  Yball_2, 1,
   -1,
-  Xball_2B, 2,
+  Yball_2, 2,
   -1,
-  Xball_2B, 3,
+  Yball_2, 3,
   -1,
-  Xball_2B, 4,
+  Yball_2, 4,
   -1,
-  Xball_2B, 5,
+  Yball_2, 5,
   -1,
-  Xball_2B, 6,
+  Yball_2, 6,
   -1,
 
-  Ygrow_ew_eat, 7,
-  Xgrow_ew, 0,
-  Xgrow_ew, 1,
-  Xgrow_ew, 2,
-  Xgrow_ew, 3,
-  Xgrow_ew, 4,
-  Xgrow_ew, 5,
-  Xgrow_ew, 6,
-  Xgrow_ew, 7,
+  Yslidewall_ew_blank, 7,
+  Xslidewall_ew, 0,
+  Xslidewall_ew, 1,
+  Xslidewall_ew, 2,
+  Xslidewall_ew, 3,
+  Xslidewall_ew, 4,
+  Xslidewall_ew, 5,
+  Xslidewall_ew, 6,
+  Xslidewall_ew, 7,
   -1,
-  Ygrow_ew_eat, 0,
+  Yslidewall_ew_blank, 0,
   -1,
-  Ygrow_ew_eat, 1,
+  Yslidewall_ew_blank, 1,
   -1,
-  Ygrow_ew_eat, 2,
+  Yslidewall_ew_blank, 2,
   -1,
-  Ygrow_ew_eat, 3,
+  Yslidewall_ew_blank, 3,
   -1,
-  Ygrow_ew_eat, 4,
+  Yslidewall_ew_blank, 4,
   -1,
-  Ygrow_ew_eat, 5,
+  Yslidewall_ew_blank, 5,
   -1,
-  Ygrow_ew_eat, 6,
+  Yslidewall_ew_blank, 6,
   -1,
-  Ygrow_ns_eat, 7,
-  Xgrow_ns, 0,
-  Xgrow_ns, 1,
-  Xgrow_ns, 2,
-  Xgrow_ns, 3,
-  Xgrow_ns, 4,
-  Xgrow_ns, 5,
-  Xgrow_ns, 6,
-  Xgrow_ns, 7,
+  Yslidewall_ns_blank, 7,
+  Xslidewall_ns, 0,
+  Xslidewall_ns, 1,
+  Xslidewall_ns, 2,
+  Xslidewall_ns, 3,
+  Xslidewall_ns, 4,
+  Xslidewall_ns, 5,
+  Xslidewall_ns, 6,
+  Xslidewall_ns, 7,
   -1,
-  Ygrow_ns_eat, 0,
+  Yslidewall_ns_blank, 0,
   -1,
-  Ygrow_ns_eat, 1,
+  Yslidewall_ns_blank, 1,
   -1,
-  Ygrow_ns_eat, 2,
+  Yslidewall_ns_blank, 2,
   -1,
-  Ygrow_ns_eat, 3,
+  Yslidewall_ns_blank, 3,
   -1,
-  Ygrow_ns_eat, 4,
+  Yslidewall_ns_blank, 4,
   -1,
-  Ygrow_ns_eat, 5,
+  Yslidewall_ns_blank, 5,
   -1,
-  Ygrow_ns_eat, 6,
+  Yslidewall_ns_blank, 6,
   -1,
 
   XwonderwallB, 7,
@@ -3198,14 +3198,14 @@ int obj_map[] =
   Xwind_w, 6,
   Xwind_w, 7,
   -1,
-  Xwind_nesw, 0,
-  Xwind_nesw, 1,
-  Xwind_nesw, 2,
-  Xwind_nesw, 3,
-  Xwind_nesw, 4,
-  Xwind_nesw, 5,
-  Xwind_nesw, 6,
-  Xwind_nesw, 7,
+  Xwind_any, 0,
+  Xwind_any, 1,
+  Xwind_any, 2,
+  Xwind_any, 3,
+  Xwind_any, 4,
+  Xwind_any, 5,
+  Xwind_any, 6,
+  Xwind_any, 7,
   -1,
   Xwind_stop, 0,
   Xwind_stop, 1,
@@ -3256,9 +3256,9 @@ int obj_map[] =
   Xexit_2, 6,
   -1,
 
-  Ydynamite_eat, 0,
-  Ydynamite_eat, 1,
-  Ydynamite_eat, 2,
+  Ydynamite_blank, 0,
+  Ydynamite_blank, 1,
+  Ydynamite_blank, 2,
   Xdynamite, 0,
   Xdynamite, 1,
   Xdynamite, 2,
@@ -3484,14 +3484,14 @@ int obj_map[] =
   Xmagnify, 7,
   -1,
 
-  XdripperB, 0,
-  XdripperB, 1,
-  XdripperB, 2,
-  XdripperB, 3,
-  XdripperB, 4,
-  XdripperB, 5,
-  XdripperB, 6,
-  XdripperB, 7,
+  Xfake_amoebaB, 0,
+  Xfake_amoebaB, 1,
+  Xfake_amoebaB, 2,
+  Xfake_amoebaB, 3,
+  Xfake_amoebaB, 4,
+  Xfake_amoebaB, 5,
+  Xfake_amoebaB, 6,
+  Xfake_amoebaB, 7,
   -1,
 
   Xfake_blankB, 0,
@@ -3652,41 +3652,41 @@ int obj_map[] =
   Xwall_4, 6,
   Xwall_4, 7,
   -1,
-  Xround_wall_1, 0,
-  Xround_wall_1, 1,
-  Xround_wall_1, 2,
-  Xround_wall_1, 3,
-  Xround_wall_1, 4,
-  Xround_wall_1, 5,
-  Xround_wall_1, 6,
-  Xround_wall_1, 7,
-  -1,
-  Xround_wall_2, 0,
-  Xround_wall_2, 1,
-  Xround_wall_2, 2,
-  Xround_wall_2, 3,
-  Xround_wall_2, 4,
-  Xround_wall_2, 5,
-  Xround_wall_2, 6,
-  Xround_wall_2, 7,
-  -1,
-  Xround_wall_3, 0,
-  Xround_wall_3, 1,
-  Xround_wall_3, 2,
-  Xround_wall_3, 3,
-  Xround_wall_3, 4,
-  Xround_wall_3, 5,
-  Xround_wall_3, 6,
-  Xround_wall_3, 7,
-  -1,
-  Xround_wall_4, 0,
-  Xround_wall_4, 1,
-  Xround_wall_4, 2,
-  Xround_wall_4, 3,
-  Xround_wall_4, 4,
-  Xround_wall_4, 5,
-  Xround_wall_4, 6,
-  Xround_wall_4, 7,
+  Xroundwall_1, 0,
+  Xroundwall_1, 1,
+  Xroundwall_1, 2,
+  Xroundwall_1, 3,
+  Xroundwall_1, 4,
+  Xroundwall_1, 5,
+  Xroundwall_1, 6,
+  Xroundwall_1, 7,
+  -1,
+  Xroundwall_2, 0,
+  Xroundwall_2, 1,
+  Xroundwall_2, 2,
+  Xroundwall_2, 3,
+  Xroundwall_2, 4,
+  Xroundwall_2, 5,
+  Xroundwall_2, 6,
+  Xroundwall_2, 7,
+  -1,
+  Xroundwall_3, 0,
+  Xroundwall_3, 1,
+  Xroundwall_3, 2,
+  Xroundwall_3, 3,
+  Xroundwall_3, 4,
+  Xroundwall_3, 5,
+  Xroundwall_3, 6,
+  Xroundwall_3, 7,
+  -1,
+  Xroundwall_4, 0,
+  Xroundwall_4, 1,
+  Xroundwall_4, 2,
+  Xroundwall_4, 3,
+  Xroundwall_4, 4,
+  Xroundwall_4, 5,
+  Xroundwall_4, 6,
+  Xroundwall_4, 7,
   -1,
   Xdecor_1, 0,
   Xdecor_1, 1,
@@ -4211,118 +4211,118 @@ int obj_map[] =
   Xalpha_copyr, 7,
   -1,
 
-  Yball_eat, 7,
-  Yball_eat, 6,
-  Yball_eat, 5,
-  Ykey_1_eat, 7,
-  Ykey_1_eat, 6,
-  Ykey_1_eat, 5,
-  Ykey_2_eat, 7,
-  Ykey_2_eat, 6,
-  Ykey_2_eat, 5,
-  Ykey_3_eat, 7,
-  Ykey_3_eat, 6,
-  Ykey_3_eat, 5,
-  Ykey_4_eat, 7,
-  Ykey_4_eat, 6,
-  Ykey_4_eat, 5,
-  Ykey_5_eat, 7,
-  Ykey_5_eat, 6,
-  Ykey_5_eat, 5,
-  Ykey_6_eat, 7,
-  Ykey_6_eat, 6,
-  Ykey_6_eat, 5,
-  Ykey_7_eat, 7,
-  Ykey_7_eat, 6,
-  Ykey_7_eat, 5,
-  Ykey_8_eat, 7,
-  Ykey_8_eat, 6,
-  Ykey_8_eat, 5,
-  Ylenses_eat, 7,
-  Ylenses_eat, 6,
-  Ylenses_eat, 5,
-  Ymagnify_eat, 7,
-  Ymagnify_eat, 6,
-  Ymagnify_eat, 5,
-  Ygrass_eat, 7,
-  Ygrass_eat, 6,
-  Ygrass_eat, 5,
-  Ydirt_eat, 7,
-  Ydirt_eat, 6,
-  Ydirt_eat, 5,
+  Yball_blank, 7,
+  Yball_blank, 6,
+  Yball_blank, 5,
+  Ykey_1_blank, 7,
+  Ykey_1_blank, 6,
+  Ykey_1_blank, 5,
+  Ykey_2_blank, 7,
+  Ykey_2_blank, 6,
+  Ykey_2_blank, 5,
+  Ykey_3_blank, 7,
+  Ykey_3_blank, 6,
+  Ykey_3_blank, 5,
+  Ykey_4_blank, 7,
+  Ykey_4_blank, 6,
+  Ykey_4_blank, 5,
+  Ykey_5_blank, 7,
+  Ykey_5_blank, 6,
+  Ykey_5_blank, 5,
+  Ykey_6_blank, 7,
+  Ykey_6_blank, 6,
+  Ykey_6_blank, 5,
+  Ykey_7_blank, 7,
+  Ykey_7_blank, 6,
+  Ykey_7_blank, 5,
+  Ykey_8_blank, 7,
+  Ykey_8_blank, 6,
+  Ykey_8_blank, 5,
+  Ylenses_blank, 7,
+  Ylenses_blank, 6,
+  Ylenses_blank, 5,
+  Ymagnify_blank, 7,
+  Ymagnify_blank, 6,
+  Ymagnify_blank, 5,
+  Ygrass_blank, 7,
+  Ygrass_blank, 6,
+  Ygrass_blank, 5,
+  Ydirt_blank, 7,
+  Ydirt_blank, 6,
+  Ydirt_blank, 5,
   Xboom_2, 7,
   Xboom_2, 6,
   Xboom_2, 5,
   -1,
-  Yball_eat, 4,
-  Yball_eat, 3,
-  Yball_eat, 2,
-  Ykey_1_eat, 4,
-  Ykey_1_eat, 3,
-  Ykey_1_eat, 2,
-  Ykey_2_eat, 4,
-  Ykey_2_eat, 3,
-  Ykey_2_eat, 2,
-  Ykey_3_eat, 4,
-  Ykey_3_eat, 3,
-  Ykey_3_eat, 2,
-  Ykey_4_eat, 4,
-  Ykey_4_eat, 3,
-  Ykey_4_eat, 2,
-  Ykey_5_eat, 4,
-  Ykey_5_eat, 3,
-  Ykey_5_eat, 2,
-  Ykey_6_eat, 4,
-  Ykey_6_eat, 3,
-  Ykey_6_eat, 2,
-  Ykey_7_eat, 4,
-  Ykey_7_eat, 3,
-  Ykey_7_eat, 2,
-  Ykey_8_eat, 4,
-  Ykey_8_eat, 3,
-  Ykey_8_eat, 2,
-  Ylenses_eat, 4,
-  Ylenses_eat, 3,
-  Ylenses_eat, 2,
-  Ymagnify_eat, 4,
-  Ymagnify_eat, 3,
-  Ymagnify_eat, 2,
-  Ygrass_eat, 4,
-  Ygrass_eat, 3,
-  Ygrass_eat, 2,
-  Ydirt_eat, 4,
-  Ydirt_eat, 3,
-  Ydirt_eat, 2,
+  Yball_blank, 4,
+  Yball_blank, 3,
+  Yball_blank, 2,
+  Ykey_1_blank, 4,
+  Ykey_1_blank, 3,
+  Ykey_1_blank, 2,
+  Ykey_2_blank, 4,
+  Ykey_2_blank, 3,
+  Ykey_2_blank, 2,
+  Ykey_3_blank, 4,
+  Ykey_3_blank, 3,
+  Ykey_3_blank, 2,
+  Ykey_4_blank, 4,
+  Ykey_4_blank, 3,
+  Ykey_4_blank, 2,
+  Ykey_5_blank, 4,
+  Ykey_5_blank, 3,
+  Ykey_5_blank, 2,
+  Ykey_6_blank, 4,
+  Ykey_6_blank, 3,
+  Ykey_6_blank, 2,
+  Ykey_7_blank, 4,
+  Ykey_7_blank, 3,
+  Ykey_7_blank, 2,
+  Ykey_8_blank, 4,
+  Ykey_8_blank, 3,
+  Ykey_8_blank, 2,
+  Ylenses_blank, 4,
+  Ylenses_blank, 3,
+  Ylenses_blank, 2,
+  Ymagnify_blank, 4,
+  Ymagnify_blank, 3,
+  Ymagnify_blank, 2,
+  Ygrass_blank, 4,
+  Ygrass_blank, 3,
+  Ygrass_blank, 2,
+  Ydirt_blank, 4,
+  Ydirt_blank, 3,
+  Ydirt_blank, 2,
   Xboom_2, 4,
   Xboom_2, 3,
   Xboom_2, 2,
   -1,
-  Yball_eat, 1,
-  Yball_eat, 0,
-  Ykey_1_eat, 1,
-  Ykey_1_eat, 0,
-  Ykey_2_eat, 1,
-  Ykey_2_eat, 0,
-  Ykey_3_eat, 1,
-  Ykey_3_eat, 0,
-  Ykey_4_eat, 1,
-  Ykey_4_eat, 0,
-  Ykey_5_eat, 1,
-  Ykey_5_eat, 0,
-  Ykey_6_eat, 1,
-  Ykey_6_eat, 0,
-  Ykey_7_eat, 1,
-  Ykey_7_eat, 0,
-  Ykey_8_eat, 1,
-  Ykey_8_eat, 0,
-  Ylenses_eat, 1,
-  Ylenses_eat, 0,
-  Ymagnify_eat, 1,
-  Ymagnify_eat, 0,
-  Ygrass_eat, 1,
-  Ygrass_eat, 0,
-  Ydirt_eat, 1,
-  Ydirt_eat, 0,
+  Yball_blank, 1,
+  Yball_blank, 0,
+  Ykey_1_blank, 1,
+  Ykey_1_blank, 0,
+  Ykey_2_blank, 1,
+  Ykey_2_blank, 0,
+  Ykey_3_blank, 1,
+  Ykey_3_blank, 0,
+  Ykey_4_blank, 1,
+  Ykey_4_blank, 0,
+  Ykey_5_blank, 1,
+  Ykey_5_blank, 0,
+  Ykey_6_blank, 1,
+  Ykey_6_blank, 0,
+  Ykey_7_blank, 1,
+  Ykey_7_blank, 0,
+  Ykey_8_blank, 1,
+  Ykey_8_blank, 0,
+  Ylenses_blank, 1,
+  Ylenses_blank, 0,
+  Ymagnify_blank, 1,
+  Ymagnify_blank, 0,
+  Ygrass_blank, 1,
+  Ygrass_blank, 0,
+  Ydirt_blank, 1,
+  Ydirt_blank, 0,
   Xboom_2, 1,
   Xboom_2, 0,
   Xboom_1, 7,
@@ -4362,46 +4362,46 @@ int obj_map[] =
   Yeater_spring, 7,
   Yalien_stone, 7,
   Yalien_spring, 7,
-  Ybomb_eat, 7,
+  Ybomb_blank, 7,
   -1
 };
 
-int spr_map[] =
+int ply_map[] =
 {
-  SPR_walk + 0,                0,      0, 1, 2, 3, 4, 5, 6, 7,
-  SPR_walk + 1,                0,      8, 9, 10, 11, 12, 13, 14, 15,
-  SPR_walk + 2,                0,      16, 17, 18, 19, 20, 21, 22, 23,
-  SPR_walk + 3,                0,      24, 25, 26, 27, 28, 29, 30, 31,
+  PLY_walk_n,          0,      0, 1, 2, 3, 4, 5, 6, 7,
+  PLY_walk_e,          0,      8, 9, 10, 11, 12, 13, 14, 15,
+  PLY_walk_s,          0,      16, 17, 18, 19, 20, 21, 22, 23,
+  PLY_walk_w,          0,      24, 25, 26, 27, 28, 29, 30, 31,
 
-  SPR_push + 0,                0,      32, 33, 34, 35, 36, 35, 34, 33,
-  SPR_push + 1,                0,      37, 38, 39, 40, 41, 40, 39, 38,
-  SPR_push + 2,                0,      42, 43, 44, 45, 46, 45, 44, 43,
-  SPR_push + 3,                0,      47, 48, 49, 50, 51, 50, 49, 48,
+  PLY_push_n,          0,      32, 33, 34, 35, 36, 35, 34, 33,
+  PLY_push_e,          0,      37, 38, 39, 40, 41, 40, 39, 38,
+  PLY_push_s,          0,      42, 43, 44, 45, 46, 45, 44, 43,
+  PLY_push_w,          0,      47, 48, 49, 50, 51, 50, 49, 48,
 
-  SPR_spray + 0,       0,      52, 52, 52, 52, 52, 52, 52, 52,
-  SPR_spray + 1,       0,      53, 53, 53, 53, 53, 53, 53, 53,
-  SPR_spray + 2,       0,      54, 54, 54, 54, 54, 54, 54, 54,
-  SPR_spray + 3,       0,      55, 55, 55, 55, 55, 55, 55, 55,
+  PLY_shoot_n,         0,      52, 52, 52, 52, 52, 52, 52, 52,
+  PLY_shoot_e,         0,      53, 53, 53, 53, 53, 53, 53, 53,
+  PLY_shoot_s,         0,      54, 54, 54, 54, 54, 54, 54, 54,
+  PLY_shoot_w,         0,      55, 55, 55, 55, 55, 55, 55, 55,
 
-  SPR_walk + 0,                1,      56, 57, 58, 59, 60, 61, 62, 63,
-  SPR_walk + 1,                1,      64, 65, 66, 67, 68, 69, 70, 71,
-  SPR_walk + 2,                1,      72, 73, 74, 75, 76, 77, 78, 79,
-  SPR_walk + 3,                1,      80, 81, 82, 83, 84, 85, 86, 87,
+  PLY_walk_n,          1,      56, 57, 58, 59, 60, 61, 62, 63,
+  PLY_walk_e,          1,      64, 65, 66, 67, 68, 69, 70, 71,
+  PLY_walk_s,          1,      72, 73, 74, 75, 76, 77, 78, 79,
+  PLY_walk_w,          1,      80, 81, 82, 83, 84, 85, 86, 87,
 
-  SPR_push + 0,                1,      88, 89, 90, 91, 92, 91, 90, 89,
-  SPR_push + 1,                1,      93, 94, 95, 96, 97, 96, 95, 94,
-  SPR_push + 2,                1,      98, 99, 100, 101, 102, 101, 100, 99,
-  SPR_push + 3,                1,      103, 104, 105, 106, 107, 106, 105, 104,
+  PLY_push_n,          1,      88, 89, 90, 91, 92, 91, 90, 89,
+  PLY_push_e,          1,      93, 94, 95, 96, 97, 96, 95, 94,
+  PLY_push_s,          1,      98, 99, 100, 101, 102, 101, 100, 99,
+  PLY_push_w,          1,      103, 104, 105, 106, 107, 106, 105, 104,
 
-  SPR_spray + 0,       1,      108, 108, 108, 108, 108, 108, 108, 108,
-  SPR_spray + 1,       1,      109, 109, 109, 109, 109, 109, 109, 109,
-  SPR_spray + 2,       1,      110, 110, 110, 110, 110, 110, 110, 110,
-  SPR_spray + 3,       1,      111, 111, 111, 111, 111, 111, 111, 111,
+  PLY_shoot_n,         1,      108, 108, 108, 108, 108, 108, 108, 108,
+  PLY_shoot_e,         1,      109, 109, 109, 109, 109, 109, 109, 109,
+  PLY_shoot_s,         1,      110, 110, 110, 110, 110, 110, 110, 110,
+  PLY_shoot_w,         1,      111, 111, 111, 111, 111, 111, 111, 111,
 
-  SPR_still,           0,      112,112, 112, 112, 112, 112, 112, 112,
-  SPR_still,           1,      113,113, 113, 113, 113, 113, 113, 113,
+  PLY_still,           0,      112,112, 112, 112, 112, 112, 112, 112,
+  PLY_still,           1,      113,113, 113, 113, 113, 113, 113, 113,
 
-  SPR_MAX
+  PLY_MAX
 };
 
 
@@ -4423,11 +4423,11 @@ unsigned short tab_explode_normal[TILE_MAX];
 /* dynamite explosion */
 unsigned short tab_explode_dynamite[TILE_MAX];
 
-/* map tiles to coords */
+/* map objects to coords */
 unsigned short map_obj[8][TILE_MAX];
 
-/* map sprites to coords */
-unsigned short map_spr[2][8][13];
+/* map players to coords */
+unsigned short map_ply[2][8][13];
 
 /* map ascii to coords */
 unsigned short map_ttl[128];
@@ -4436,7 +4436,7 @@ unsigned short map_ttl[128];
 struct GraphicInfo_EM graphic_info_em_object[TILE_MAX][8];
 
 /* map player number, frames and action to graphic info */
-struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][SPR_MAX][8];
+struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][PLY_MAX][8];
 
 static void create_tab(int *invert, unsigned char *array)
 {
@@ -4543,13 +4543,13 @@ static void create_obj_graphics_info_em(void)
   }
 }
 
-static void create_spr(void)
+static void create_ply(void)
 {
   int i, j, k;
-  int *map = spr_map;
-  int buffer[2][8][SPR_MAX];
+  int *map = ply_map;
+  int buffer[2][8][PLY_MAX];
 
-  while (*map < SPR_MAX)
+  while (*map < PLY_MAX)
   {
     i = *map++;
     j = *map++;
@@ -4560,22 +4560,22 @@ static void create_spr(void)
 
   for (i = 0; i < 2; i++)
     for (j = 0; j < 8; j++)
-      for (k = 0; k < SPR_MAX; k++)
-       map_spr[i][j][k] = buffer[i][7 - j][k];
+      for (k = 0; k < PLY_MAX; k++)
+       map_ply[i][j][k] = buffer[i][7 - j][k];
 }
 
-static void create_spr_graphics_info_em(void)
+static void create_ply_graphics_info_em(void)
 {
   int i, j, k;
 
   for (i = 0; i < MAX_PLAYERS; i++)
   {
-    for (j = 0; j < SPR_MAX; j++)
+    for (j = 0; j < PLY_MAX; j++)
     {
       for (k = 0; k < 8; k++)
       {
        struct GraphicInfo_EM *g = &graphic_info_em_player[i][j][k];
-       int spr = map_spr[i % 2][k][j];
+       int spr = map_ply[i % 2][k][j];
 
        g->bitmap = sprBitmap;
        g->src_x = (spr / 8) * TILEX;
@@ -4607,13 +4607,13 @@ void tab_generate(void)
   create_tab(tile_android_move, tab_android_move);
   create_explode();
   create_obj();
-  create_spr();
+  create_ply();
 }
 
 void tab_generate_graphics_info_em(void)
 {
   create_obj_graphics_info_em();
-  create_spr_graphics_info_em();
+  create_ply_graphics_info_em();
 
   InitGraphicInfo_EM();
 }
diff --git a/src/tools.c b/src/tools.c
index 1095dd52e18f3f1d9aacc563c53f9fcb0b7885ad..c3668807a3f9601fd34ed7a7b6dac3dd960392b7 100644 (file)
--- a/src/tools.c
+++ b/src/tools.c
@@ -5745,61 +5745,61 @@ em_object_mapping_list[] =
     EL_EMPTY,                          -1, -1
   },
   {
-    Yacid_splash_eB,                   FALSE,  FALSE,
+    Xacid_splash_e,                    FALSE,  FALSE,
     EL_ACID_SPLASH_RIGHT,              -1, -1
   },
   {
-    Yacid_splash_wB,                   FALSE,  FALSE,
+    Xacid_splash_w,                    FALSE,  FALSE,
     EL_ACID_SPLASH_LEFT,               -1, -1
   },
 
 #ifdef EM_ENGINE_BAD_ROLL
   {
-    Xstone_force_e,                    FALSE,  FALSE,
+    Xpush_stone_e,                     FALSE,  FALSE,
     EL_ROCK,                           -1, MV_BIT_RIGHT
   },
   {
-    Xstone_force_w,                    FALSE,  FALSE,
+    Xpush_stone_w,                     FALSE,  FALSE,
     EL_ROCK,                           -1, MV_BIT_LEFT
   },
   {
-    Xnut_force_e,                      FALSE,  FALSE,
+    Xpush_nut_e,                       FALSE,  FALSE,
     EL_NUT,                            -1, MV_BIT_RIGHT
   },
   {
-    Xnut_force_w,                      FALSE,  FALSE,
+    Xpush_nut_w,                       FALSE,  FALSE,
     EL_NUT,                            -1, MV_BIT_LEFT
   },
   {
-    Xspring_force_e,                   FALSE,  FALSE,
+    Xpush_spring_e,                    FALSE,  FALSE,
     EL_SPRING,                         -1, MV_BIT_RIGHT
   },
   {
-    Xspring_force_w,                   FALSE,  FALSE,
+    Xpush_spring_w,                    FALSE,  FALSE,
     EL_SPRING,                         -1, MV_BIT_LEFT
   },
   {
-    Xemerald_force_e,                  FALSE,  FALSE,
+    Xpush_emerald_e,                   FALSE,  FALSE,
     EL_EMERALD,                                -1, MV_BIT_RIGHT
   },
   {
-    Xemerald_force_w,                  FALSE,  FALSE,
+    Xpush_emerald_w,                   FALSE,  FALSE,
     EL_EMERALD,                                -1, MV_BIT_LEFT
   },
   {
-    Xdiamond_force_e,                  FALSE,  FALSE,
+    Xpush_diamond_e,                   FALSE,  FALSE,
     EL_DIAMOND,                                -1, MV_BIT_RIGHT
   },
   {
-    Xdiamond_force_w,                  FALSE,  FALSE,
+    Xpush_diamond_w,                   FALSE,  FALSE,
     EL_DIAMOND,                                -1, MV_BIT_LEFT
   },
   {
-    Xbomb_force_e,                     FALSE,  FALSE,
+    Xpush_bomb_e,                      FALSE,  FALSE,
     EL_BOMB,                           -1, MV_BIT_RIGHT
   },
   {
-    Xbomb_force_w,                     FALSE,  FALSE,
+    Xpush_bomb_w,                      FALSE,  FALSE,
     EL_BOMB,                           -1, MV_BIT_LEFT
   },
 #endif // EM_ENGINE_BAD_ROLL
@@ -5877,35 +5877,35 @@ em_object_mapping_list[] =
     EL_NUT,                            ACTION_MOVING, MV_BIT_LEFT
   },
   {
-    Xbug_n,                            TRUE,   FALSE,
+    Xbug_1_n,                          TRUE,   FALSE,
     EL_BUG_UP,                         -1, -1
   },
   {
-    Xbug_e,                            TRUE,   FALSE,
+    Xbug_1_e,                          TRUE,   FALSE,
     EL_BUG_RIGHT,                      -1, -1
   },
   {
-    Xbug_s,                            TRUE,   FALSE,
+    Xbug_1_s,                          TRUE,   FALSE,
     EL_BUG_DOWN,                       -1, -1
   },
   {
-    Xbug_w,                            TRUE,   FALSE,
+    Xbug_1_w,                          TRUE,   FALSE,
     EL_BUG_LEFT,                       -1, -1
   },
   {
-    Xbug_gon,                          FALSE,  FALSE,
+    Xbug_2_n,                          FALSE,  FALSE,
     EL_BUG_UP,                         -1, -1
   },
   {
-    Xbug_goe,                          FALSE,  FALSE,
+    Xbug_2_e,                          FALSE,  FALSE,
     EL_BUG_RIGHT,                      -1, -1
   },
   {
-    Xbug_gos,                          FALSE,  FALSE,
+    Xbug_2_s,                          FALSE,  FALSE,
     EL_BUG_DOWN,                       -1, -1
   },
   {
-    Xbug_gow,                          FALSE,  FALSE,
+    Xbug_2_w,                          FALSE,  FALSE,
     EL_BUG_LEFT,                       -1, -1
   },
   {
@@ -5981,35 +5981,35 @@ em_object_mapping_list[] =
     EL_BUG,                            ACTION_SMASHED_BY_SPRING, -1
   },
   {
-    Xtank_n,                           TRUE,   FALSE,
+    Xtank_1_n,                         TRUE,   FALSE,
     EL_SPACESHIP_UP,                   -1, -1
   },
   {
-    Xtank_e,                           TRUE,   FALSE,
+    Xtank_1_e,                         TRUE,   FALSE,
     EL_SPACESHIP_RIGHT,                        -1, -1
   },
   {
-    Xtank_s,                           TRUE,   FALSE,
+    Xtank_1_s,                         TRUE,   FALSE,
     EL_SPACESHIP_DOWN,                 -1, -1
   },
   {
-    Xtank_w,                           TRUE,   FALSE,
+    Xtank_1_w,                         TRUE,   FALSE,
     EL_SPACESHIP_LEFT,                 -1, -1
   },
   {
-    Xtank_gon,                         FALSE,  FALSE,
+    Xtank_2_n,                         FALSE,  FALSE,
     EL_SPACESHIP_UP,                   -1, -1
   },
   {
-    Xtank_goe,                         FALSE,  FALSE,
+    Xtank_2_e,                         FALSE,  FALSE,
     EL_SPACESHIP_RIGHT,                        -1, -1
   },
   {
-    Xtank_gos,                         FALSE,  FALSE,
+    Xtank_2_s,                         FALSE,  FALSE,
     EL_SPACESHIP_DOWN,                 -1, -1
   },
   {
-    Xtank_gow,                         FALSE,  FALSE,
+    Xtank_2_w,                         FALSE,  FALSE,
     EL_SPACESHIP_LEFT,                 -1, -1
   },
   {
@@ -6229,19 +6229,19 @@ em_object_mapping_list[] =
     EL_SPRING,                         ACTION_MOVING, MV_BIT_LEFT
   },
   {
-    Yspring_kill_e,                    FALSE,  FALSE,
+    Yspring_alien_e,                   FALSE,  FALSE,
     EL_SPRING,                         ACTION_EATING, MV_BIT_RIGHT
   },
   {
-    Yspring_kill_eB,                   FALSE,  TRUE,
+    Yspring_alien_eB,                  FALSE,  TRUE,
     EL_SPRING,                         ACTION_EATING, MV_BIT_RIGHT
   },
   {
-    Yspring_kill_w,                    FALSE,  FALSE,
+    Yspring_alien_w,                   FALSE,  FALSE,
     EL_SPRING,                         ACTION_EATING, MV_BIT_LEFT
   },
   {
-    Yspring_kill_wB,                   FALSE,  TRUE,
+    Yspring_alien_wB,                  FALSE,  TRUE,
     EL_SPRING,                         ACTION_EATING, MV_BIT_LEFT
   },
   {
@@ -6389,11 +6389,11 @@ em_object_mapping_list[] =
     EL_EMERALD,                                ACTION_MOVING, MV_BIT_LEFT
   },
   {
-    Yemerald_eat,                      FALSE,  FALSE,
+    Yemerald_blank,                    FALSE,  FALSE,
     EL_EMERALD,                                ACTION_COLLECTING, -1
   },
   {
-    Yemerald_stone,                    FALSE,  FALSE,
+    Ynut_stone,                                FALSE,  FALSE,
     EL_NUT,                            ACTION_BREAKING, -1
   },
   {
@@ -6437,7 +6437,7 @@ em_object_mapping_list[] =
     EL_DIAMOND,                                ACTION_MOVING, MV_BIT_LEFT
   },
   {
-    Ydiamond_eat,                      FALSE,  FALSE,
+    Ydiamond_blank,                    FALSE,  FALSE,
     EL_DIAMOND,                                ACTION_COLLECTING, -1
   },
   {
@@ -6457,23 +6457,23 @@ em_object_mapping_list[] =
     EL_AMOEBA_DROP,                    ACTION_FALLING, -1
   },
   {
-    Xdrip_eat,                         FALSE,  FALSE,
+    Xdrip,                             FALSE,  FALSE,
     EL_AMOEBA_DROP,                    ACTION_GROWING, -1
   },
   {
-    Ydrip_s1,                          FALSE,  FALSE,
+    Ydrip_1_s,                         FALSE,  FALSE,
     EL_AMOEBA_DROP,                    ACTION_FALLING, -1
   },
   {
-    Ydrip_s1B,                         FALSE,  TRUE,
+    Ydrip_1_sB,                                FALSE,  TRUE,
     EL_AMOEBA_DROP,                    ACTION_FALLING, -1
   },
   {
-    Ydrip_s2,                          FALSE,  FALSE,
+    Ydrip_2_s,                         FALSE,  FALSE,
     EL_AMOEBA_DROP,                    ACTION_FALLING, -1
   },
   {
-    Ydrip_s2B,                         FALSE,  TRUE,
+    Ydrip_2_sB,                                FALSE,  TRUE,
     EL_AMOEBA_DROP,                    ACTION_FALLING, -1
   },
   {
@@ -6513,7 +6513,7 @@ em_object_mapping_list[] =
     EL_BOMB,                           ACTION_MOVING, MV_BIT_LEFT
   },
   {
-    Ybomb_eat,                         FALSE,  FALSE,
+    Ybomb_blank,                       FALSE,  FALSE,
     EL_BOMB,                           ACTION_ACTIVATING, -1
   },
   {
@@ -6649,7 +6649,7 @@ em_object_mapping_list[] =
     EL_EMC_MAGIC_BALL,                 -1, -1
   },
   {
-    Xball_1B,                          FALSE,  FALSE,
+    Yball_1,                           FALSE,  FALSE,
     EL_EMC_MAGIC_BALL,                 ACTION_ACTIVE, -1
   },
   {
@@ -6657,75 +6657,75 @@ em_object_mapping_list[] =
     EL_EMC_MAGIC_BALL,                 ACTION_ACTIVE, -1
   },
   {
-    Xball_2B,                          FALSE,  FALSE,
+    Yball_2,                           FALSE,  FALSE,
     EL_EMC_MAGIC_BALL,                 ACTION_ACTIVE, -1
   },
   {
-    Yball_eat,                         FALSE,  FALSE,
+    Yball_blank,                       FALSE,  FALSE,
     EL_EMC_MAGIC_BALL,                 ACTION_DROPPING, -1
   },
   {
-    Ykey_1_eat,                                FALSE,  FALSE,
+    Ykey_1_blank,                      FALSE,  FALSE,
     EL_EM_KEY_1,                       ACTION_COLLECTING, -1
   },
   {
-    Ykey_2_eat,                                FALSE,  FALSE,
+    Ykey_2_blank,                      FALSE,  FALSE,
     EL_EM_KEY_2,                       ACTION_COLLECTING, -1
   },
   {
-    Ykey_3_eat,                                FALSE,  FALSE,
+    Ykey_3_blank,                      FALSE,  FALSE,
     EL_EM_KEY_3,                       ACTION_COLLECTING, -1
   },
   {
-    Ykey_4_eat,                                FALSE,  FALSE,
+    Ykey_4_blank,                      FALSE,  FALSE,
     EL_EM_KEY_4,                       ACTION_COLLECTING, -1
   },
   {
-    Ykey_5_eat,                                FALSE,  FALSE,
+    Ykey_5_blank,                      FALSE,  FALSE,
     EL_EMC_KEY_5,                      ACTION_COLLECTING, -1
   },
   {
-    Ykey_6_eat,                                FALSE,  FALSE,
+    Ykey_6_blank,                      FALSE,  FALSE,
     EL_EMC_KEY_6,                      ACTION_COLLECTING, -1
   },
   {
-    Ykey_7_eat,                                FALSE,  FALSE,
+    Ykey_7_blank,                      FALSE,  FALSE,
     EL_EMC_KEY_7,                      ACTION_COLLECTING, -1
   },
   {
-    Ykey_8_eat,                                FALSE,  FALSE,
+    Ykey_8_blank,                      FALSE,  FALSE,
     EL_EMC_KEY_8,                      ACTION_COLLECTING, -1
   },
   {
-    Ylenses_eat,                       FALSE,  FALSE,
+    Ylenses_blank,                     FALSE,  FALSE,
     EL_EMC_LENSES,                     ACTION_COLLECTING, -1
   },
   {
-    Ymagnify_eat,                      FALSE,  FALSE,
+    Ymagnify_blank,                    FALSE,  FALSE,
     EL_EMC_MAGNIFIER,                  ACTION_COLLECTING, -1
   },
   {
-    Ygrass_eat,                                FALSE,  FALSE,
+    Ygrass_blank,                      FALSE,  FALSE,
     EL_EMC_GRASS,                      ACTION_SNAPPING, -1
   },
   {
-    Ydirt_eat,                         FALSE,  FALSE,
+    Ydirt_blank,                       FALSE,  FALSE,
     EL_SAND,                           ACTION_SNAPPING, -1
   },
   {
-    Xgrow_ns,                          TRUE,   FALSE,
+    Xslidewall_ns,                     TRUE,   FALSE,
     EL_EXPANDABLE_WALL_VERTICAL,       -1, -1
   },
   {
-    Ygrow_ns_eat,                      FALSE,  FALSE,
+    Yslidewall_ns_blank,               FALSE,  FALSE,
     EL_EXPANDABLE_WALL_VERTICAL,       ACTION_GROWING, -1
   },
   {
-    Xgrow_ew,                          TRUE,   FALSE,
+    Xslidewall_ew,                     TRUE,   FALSE,
     EL_EXPANDABLE_WALL_HORIZONTAL,     -1, -1
   },
   {
-    Ygrow_ew_eat,                      FALSE,  FALSE,
+    Yslidewall_ew_blank,               FALSE,  FALSE,
     EL_EXPANDABLE_WALL_HORIZONTAL,     ACTION_GROWING, -1
   },
   {
@@ -6849,7 +6849,7 @@ em_object_mapping_list[] =
     EL_BALLOON_SWITCH_LEFT,            -1, -1
   },
   {
-    Xwind_nesw,                                TRUE,   FALSE,
+    Xwind_any,                         TRUE,   FALSE,
     EL_BALLOON_SWITCH_ANY,             -1, -1
   },
   {
@@ -6877,7 +6877,7 @@ em_object_mapping_list[] =
     EL_EM_DYNAMITE,                    -1, -1
   },
   {
-    Ydynamite_eat,                     FALSE,  FALSE,
+    Ydynamite_blank,                   FALSE,  FALSE,
     EL_EM_DYNAMITE,                    ACTION_COLLECTING, -1
   },
   {
@@ -7009,11 +7009,11 @@ em_object_mapping_list[] =
     EL_EMC_MAGNIFIER,                  -1, -1
   },
   {
-    Xdripper,                          TRUE,   FALSE,
+    Xfake_amoeba,                      TRUE,   FALSE,
     EL_EMC_DRIPPER,                    -1, -1
   },
   {
-    XdripperB,                         FALSE,  FALSE,
+    Xfake_amoebaB,                     FALSE,  FALSE,
     EL_EMC_DRIPPER,                    ACTION_ACTIVE, -1
   },
   {
@@ -7129,19 +7129,19 @@ em_object_mapping_list[] =
     EL_EMC_WALL_16,                    -1, -1
   },
   {
-    Xround_wall_1,                     TRUE,   FALSE,
+    Xroundwall_1,                      TRUE,   FALSE,
     EL_WALL_SLIPPERY,                  -1, -1
   },
   {
-    Xround_wall_2,                     TRUE,   FALSE,
+    Xroundwall_2,                      TRUE,   FALSE,
     EL_EMC_WALL_SLIPPERY_2,            -1, -1
   },
   {
-    Xround_wall_3,                     TRUE,   FALSE,
+    Xroundwall_3,                      TRUE,   FALSE,
     EL_EMC_WALL_SLIPPERY_3,            -1, -1
   },
   {
-    Xround_wall_4,                     TRUE,   FALSE,
+    Xroundwall_4,                      TRUE,   FALSE,
     EL_EMC_WALL_SLIPPERY_4,            -1, -1
   },
   {
@@ -7410,7 +7410,7 @@ em_object_mapping_list[] =
     EL_EMPTY,                          -1, -1
   },
   {
-    ZBORDER,                           FALSE,  FALSE,
+    Zborder,                           FALSE,  FALSE,
     EL_EMPTY,                          -1, -1
   },
 
@@ -7432,211 +7432,211 @@ static struct Mapping_EM_to_RND_player
 em_player_mapping_list[] =
 {
   {
-    SPR_walk + 0,                      0,
+    PLY_walk_n,                                0,
     EL_PLAYER_1,                       ACTION_MOVING, MV_BIT_UP,
   },
   {
-    SPR_walk + 1,                      0,
+    PLY_walk_e,                                0,
     EL_PLAYER_1,                       ACTION_MOVING, MV_BIT_RIGHT,
   },
   {
-    SPR_walk + 2,                      0,
+    PLY_walk_s,                                0,
     EL_PLAYER_1,                       ACTION_MOVING, MV_BIT_DOWN,
   },
   {
-    SPR_walk + 3,                      0,
+    PLY_walk_w,                                0,
     EL_PLAYER_1,                       ACTION_MOVING, MV_BIT_LEFT,
   },
   {
-    SPR_push + 0,                      0,
+    PLY_push_n,                                0,
     EL_PLAYER_1,                       ACTION_PUSHING, MV_BIT_UP,
   },
   {
-    SPR_push + 1,                      0,
+    PLY_push_e,                                0,
     EL_PLAYER_1,                       ACTION_PUSHING, MV_BIT_RIGHT,
   },
   {
-    SPR_push + 2,                      0,
+    PLY_push_s,                                0,
     EL_PLAYER_1,                       ACTION_PUSHING, MV_BIT_DOWN,
   },
   {
-    SPR_push + 3,                      0,
+    PLY_push_w,                                0,
     EL_PLAYER_1,                       ACTION_PUSHING, MV_BIT_LEFT,
   },
   {
-    SPR_spray + 0,                     0,
+    PLY_shoot_n,                       0,
     EL_PLAYER_1,                       ACTION_SNAPPING, MV_BIT_UP,
   },
   {
-    SPR_spray + 1,                     0,
+    PLY_shoot_e,                       0,
     EL_PLAYER_1,                       ACTION_SNAPPING, MV_BIT_RIGHT,
   },
   {
-    SPR_spray + 2,                     0,
+    PLY_shoot_s,                       0,
     EL_PLAYER_1,                       ACTION_SNAPPING, MV_BIT_DOWN,
   },
   {
-    SPR_spray + 3,                     0,
+    PLY_shoot_w,                       0,
     EL_PLAYER_1,                       ACTION_SNAPPING, MV_BIT_LEFT,
   },
   {
-    SPR_walk + 0,                      1,
+    PLY_walk_n,                                1,
     EL_PLAYER_2,                       ACTION_MOVING, MV_BIT_UP,
   },
   {
-    SPR_walk + 1,                      1,
+    PLY_walk_e,                                1,
     EL_PLAYER_2,                       ACTION_MOVING, MV_BIT_RIGHT,
   },
   {
-    SPR_walk + 2,                      1,
+    PLY_walk_s,                                1,
     EL_PLAYER_2,                       ACTION_MOVING, MV_BIT_DOWN,
   },
   {
-    SPR_walk + 3,                      1,
+    PLY_walk_w,                                1,
     EL_PLAYER_2,                       ACTION_MOVING, MV_BIT_LEFT,
   },
   {
-    SPR_push + 0,                      1,
+    PLY_push_n,                                1,
     EL_PLAYER_2,                       ACTION_PUSHING, MV_BIT_UP,
   },
   {
-    SPR_push + 1,                      1,
+    PLY_push_e,                                1,
     EL_PLAYER_2,                       ACTION_PUSHING, MV_BIT_RIGHT,
   },
   {
-    SPR_push + 2,                      1,
+    PLY_push_s,                                1,
     EL_PLAYER_2,                       ACTION_PUSHING, MV_BIT_DOWN,
   },
   {
-    SPR_push + 3,                      1,
+    PLY_push_w,                                1,
     EL_PLAYER_2,                       ACTION_PUSHING, MV_BIT_LEFT,
   },
   {
-    SPR_spray + 0,                     1,
+    PLY_shoot_n,                       1,
     EL_PLAYER_2,                       ACTION_SNAPPING, MV_BIT_UP,
   },
   {
-    SPR_spray + 1,                     1,
+    PLY_shoot_e,                       1,
     EL_PLAYER_2,                       ACTION_SNAPPING, MV_BIT_RIGHT,
   },
   {
-    SPR_spray + 2,                     1,
+    PLY_shoot_s,                       1,
     EL_PLAYER_2,                       ACTION_SNAPPING, MV_BIT_DOWN,
   },
   {
-    SPR_spray + 3,                     1,
+    PLY_shoot_w,                       1,
     EL_PLAYER_2,                       ACTION_SNAPPING, MV_BIT_LEFT,
   },
   {
-    SPR_still,                         0,
+    PLY_still,                         0,
     EL_PLAYER_1,                       ACTION_DEFAULT, -1,
   },
   {
-    SPR_still,                         1,
+    PLY_still,                         1,
     EL_PLAYER_2,                       ACTION_DEFAULT, -1,
   },
   {
-    SPR_walk + 0,                      2,
+    PLY_walk_n,                                2,
     EL_PLAYER_3,                       ACTION_MOVING, MV_BIT_UP,
   },
   {
-    SPR_walk + 1,                      2,
+    PLY_walk_e,                                2,
     EL_PLAYER_3,                       ACTION_MOVING, MV_BIT_RIGHT,
   },
   {
-    SPR_walk + 2,                      2,
+    PLY_walk_s,                                2,
     EL_PLAYER_3,                       ACTION_MOVING, MV_BIT_DOWN,
   },
   {
-    SPR_walk + 3,                      2,
+    PLY_walk_w,                                2,
     EL_PLAYER_3,                       ACTION_MOVING, MV_BIT_LEFT,
   },
   {
-    SPR_push + 0,                      2,
+    PLY_push_n,                                2,
     EL_PLAYER_3,                       ACTION_PUSHING, MV_BIT_UP,
   },
   {
-    SPR_push + 1,                      2,
+    PLY_push_e,                                2,
     EL_PLAYER_3,                       ACTION_PUSHING, MV_BIT_RIGHT,
   },
   {
-    SPR_push + 2,                      2,
+    PLY_push_s,                                2,
     EL_PLAYER_3,                       ACTION_PUSHING, MV_BIT_DOWN,
   },
   {
-    SPR_push + 3,                      2,
+    PLY_push_w,                                2,
     EL_PLAYER_3,                       ACTION_PUSHING, MV_BIT_LEFT,
   },
   {
-    SPR_spray + 0,                     2,
+    PLY_shoot_n,                       2,
     EL_PLAYER_3,                       ACTION_SNAPPING, MV_BIT_UP,
   },
   {
-    SPR_spray + 1,                     2,
+    PLY_shoot_e,                       2,
     EL_PLAYER_3,                       ACTION_SNAPPING, MV_BIT_RIGHT,
   },
   {
-    SPR_spray + 2,                     2,
+    PLY_shoot_s,                       2,
     EL_PLAYER_3,                       ACTION_SNAPPING, MV_BIT_DOWN,
   },
   {
-    SPR_spray + 3,                     2,
+    PLY_shoot_w,                       2,
     EL_PLAYER_3,                       ACTION_SNAPPING, MV_BIT_LEFT,
   },
   {
-    SPR_walk + 0,                      3,
+    PLY_walk_n,                                3,
     EL_PLAYER_4,                       ACTION_MOVING, MV_BIT_UP,
   },
   {
-    SPR_walk + 1,                      3,
+    PLY_walk_e,                                3,
     EL_PLAYER_4,                       ACTION_MOVING, MV_BIT_RIGHT,
   },
   {
-    SPR_walk + 2,                      3,
+    PLY_walk_s,                                3,
     EL_PLAYER_4,                       ACTION_MOVING, MV_BIT_DOWN,
   },
   {
-    SPR_walk + 3,                      3,
+    PLY_walk_w,                                3,
     EL_PLAYER_4,                       ACTION_MOVING, MV_BIT_LEFT,
   },
   {
-    SPR_push + 0,                      3,
+    PLY_push_n,                                3,
     EL_PLAYER_4,                       ACTION_PUSHING, MV_BIT_UP,
   },
   {
-    SPR_push + 1,                      3,
+    PLY_push_e,                                3,
     EL_PLAYER_4,                       ACTION_PUSHING, MV_BIT_RIGHT,
   },
   {
-    SPR_push + 2,                      3,
+    PLY_push_s,                                3,
     EL_PLAYER_4,                       ACTION_PUSHING, MV_BIT_DOWN,
   },
   {
-    SPR_push + 3,                      3,
+    PLY_push_w,                                3,
     EL_PLAYER_4,                       ACTION_PUSHING, MV_BIT_LEFT,
   },
   {
-    SPR_spray + 0,                     3,
+    PLY_shoot_n,                       3,
     EL_PLAYER_4,                       ACTION_SNAPPING, MV_BIT_UP,
   },
   {
-    SPR_spray + 1,                     3,
+    PLY_shoot_e,                       3,
     EL_PLAYER_4,                       ACTION_SNAPPING, MV_BIT_RIGHT,
   },
   {
-    SPR_spray + 2,                     3,
+    PLY_shoot_s,                       3,
     EL_PLAYER_4,                       ACTION_SNAPPING, MV_BIT_DOWN,
   },
   {
-    SPR_spray + 3,                     3,
+    PLY_shoot_w,                       3,
     EL_PLAYER_4,                       ACTION_SNAPPING, MV_BIT_LEFT,
   },
   {
-    SPR_still,                         2,
+    PLY_still,                         2,
     EL_PLAYER_3,                       ACTION_DEFAULT, -1,
   },
   {
-    SPR_still,                         3,
+    PLY_still,                         3,
     EL_PLAYER_4,                       ACTION_DEFAULT, -1,
   },
 
@@ -8202,7 +8202,7 @@ unsigned int InitRND(int seed)
 }
 
 static struct Mapping_EM_to_RND_object object_mapping[TILE_MAX];
-static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][SPR_MAX];
+static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][PLY_MAX];
 
 static int get_effective_element_EM(int tile, int frame_em)
 {
@@ -8217,8 +8217,8 @@ static int get_effective_element_EM(int tile, int frame_em)
   {
     switch (tile)
     {
-      case Yacid_splash_eB:
-      case Yacid_splash_wB:
+      case Xacid_splash_e:
+      case Xacid_splash_w:
        return (frame_em > 5 ? EL_EMPTY : element);
 
       default:
@@ -8229,11 +8229,11 @@ static int get_effective_element_EM(int tile, int frame_em)
   {
     switch (tile)
     {
-      case Yacid_splash_eB:
-      case Yacid_splash_wB:
+      case Xacid_splash_e:
+      case Xacid_splash_w:
        return EL_EMPTY;
 
-      case Yemerald_stone:
+      case Ynut_stone:
        return EL_EMERALD;
 
       case Ydiamond_stone:
@@ -8241,24 +8241,24 @@ static int get_effective_element_EM(int tile, int frame_em)
 
       case Xdrip_stretch:
       case Xdrip_stretchB:
-      case Ydrip_s1:
-      case Ydrip_s1B:
-      case Xball_1B:
+      case Ydrip_1_s:
+      case Ydrip_1_sB:
+      case Yball_1:
       case Xball_2:
-      case Xball_2B:
-      case Yball_eat:
-      case Ykey_1_eat:
-      case Ykey_2_eat:
-      case Ykey_3_eat:
-      case Ykey_4_eat:
-      case Ykey_5_eat:
-      case Ykey_6_eat:
-      case Ykey_7_eat:
-      case Ykey_8_eat:
-      case Ylenses_eat:
-      case Ymagnify_eat:
-      case Ygrass_eat:
-      case Ydirt_eat:
+      case Yball_2:
+      case Yball_blank:
+      case Ykey_1_blank:
+      case Ykey_2_blank:
+      case Ykey_3_blank:
+      case Ykey_4_blank:
+      case Ykey_5_blank:
+      case Ykey_6_blank:
+      case Ykey_7_blank:
+      case Ykey_8_blank:
+      case Ylenses_blank:
+      case Ymagnify_blank:
+      case Ygrass_blank:
+      case Ydirt_blank:
       case Xsand_stonein_1:
       case Xsand_stonein_2:
       case Xsand_stonein_3:
@@ -8298,9 +8298,9 @@ static boolean check_linear_animation_EM(int tile)
     case Ytank_s_e:
     case Ytank_w_s:
     case Ytank_n_w:
-    case Yacid_splash_eB:
-    case Yacid_splash_wB:
-    case Yemerald_stone:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Ynut_stone:
       return TRUE;
   }
 
@@ -8571,7 +8571,7 @@ void InitGraphicInfo_EM(void)
   // always start with reliable default values
   for (p = 0; p < MAX_PLAYERS; p++)
   {
-    for (i = 0; i < SPR_MAX; i++)
+    for (i = 0; i < PLY_MAX; i++)
     {
       player_mapping[p][i].element_rnd = EL_UNKNOWN;
       player_mapping[p][i].action = ACTION_DEFAULT;
@@ -8628,24 +8628,24 @@ void InitGraphicInfo_EM(void)
       int effective_action = (j < 7 ? action :
                              i == Xdrip_stretch ? action :
                              i == Xdrip_stretchB ? action :
-                             i == Ydrip_s1 ? action :
-                             i == Ydrip_s1B ? action :
-                             i == Xball_1B ? action :
+                             i == Ydrip_1_s ? action :
+                             i == Ydrip_1_sB ? action :
+                             i == Yball_1 ? action :
                              i == Xball_2 ? action :
-                             i == Xball_2B ? action :
-                             i == Yball_eat ? action :
-                             i == Ykey_1_eat ? action :
-                             i == Ykey_2_eat ? action :
-                             i == Ykey_3_eat ? action :
-                             i == Ykey_4_eat ? action :
-                             i == Ykey_5_eat ? action :
-                             i == Ykey_6_eat ? action :
-                             i == Ykey_7_eat ? action :
-                             i == Ykey_8_eat ? action :
-                             i == Ylenses_eat ? action :
-                             i == Ymagnify_eat ? action :
-                             i == Ygrass_eat ? action :
-                             i == Ydirt_eat ? action :
+                             i == Yball_2 ? action :
+                             i == Yball_blank ? action :
+                             i == Ykey_1_blank ? action :
+                             i == Ykey_2_blank ? action :
+                             i == Ykey_3_blank ? action :
+                             i == Ykey_4_blank ? action :
+                             i == Ykey_5_blank ? action :
+                             i == Ykey_6_blank ? action :
+                             i == Ykey_7_blank ? action :
+                             i == Ykey_8_blank ? action :
+                             i == Ylenses_blank ? action :
+                             i == Ymagnify_blank ? action :
+                             i == Ygrass_blank ? action :
+                             i == Ydirt_blank ? action :
                              i == Xsand_stonein_1 ? action :
                              i == Xsand_stonein_2 ? action :
                              i == Xsand_stonein_3 ? action :
@@ -8676,8 +8676,8 @@ void InitGraphicInfo_EM(void)
                                   g->anim_mode & ANIM_LINEAR);
       int sync_frame = (i == Xdrip_stretch ? 7 :
                        i == Xdrip_stretchB ? 7 :
-                       i == Ydrip_s2 ? j + 8 :
-                       i == Ydrip_s2B ? j + 8 :
+                       i == Ydrip_2_s ? j + 8 :
+                       i == Ydrip_2_sB ? j + 8 :
                        i == Xacid_1 ? 0 :
                        i == Xacid_2 ? 10 :
                        i == Xacid_3 ? 20 :
@@ -8695,20 +8695,20 @@ void InitGraphicInfo_EM(void)
                        i == Xfake_acid_7 ? 60 :
                        i == Xfake_acid_8 ? 70 :
                        i == Xball_2 ? 7 :
-                       i == Xball_2B ? j + 8 :
-                       i == Yball_eat ? j + 1 :
-                       i == Ykey_1_eat ? j + 1 :
-                       i == Ykey_2_eat ? j + 1 :
-                       i == Ykey_3_eat ? j + 1 :
-                       i == Ykey_4_eat ? j + 1 :
-                       i == Ykey_5_eat ? j + 1 :
-                       i == Ykey_6_eat ? j + 1 :
-                       i == Ykey_7_eat ? j + 1 :
-                       i == Ykey_8_eat ? j + 1 :
-                       i == Ylenses_eat ? j + 1 :
-                       i == Ymagnify_eat ? j + 1 :
-                       i == Ygrass_eat ? j + 1 :
-                       i == Ydirt_eat ? j + 1 :
+                       i == Yball_2 ? j + 8 :
+                       i == Yball_blank ? j + 1 :
+                       i == Ykey_1_blank ? j + 1 :
+                       i == Ykey_2_blank ? j + 1 :
+                       i == Ykey_3_blank ? j + 1 :
+                       i == Ykey_4_blank ? j + 1 :
+                       i == Ykey_5_blank ? j + 1 :
+                       i == Ykey_6_blank ? j + 1 :
+                       i == Ykey_7_blank ? j + 1 :
+                       i == Ykey_8_blank ? j + 1 :
+                       i == Ylenses_blank ? j + 1 :
+                       i == Ymagnify_blank ? j + 1 :
+                       i == Ygrass_blank ? j + 1 :
+                       i == Ydirt_blank ? j + 1 :
                        i == Xamoeba_1 ? 0 :
                        i == Xamoeba_2 ? 1 :
                        i == Xamoeba_3 ? 2 :
@@ -8820,10 +8820,10 @@ void InitGraphicInfo_EM(void)
           effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
        int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
        int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? 1 : 0);
-       int num_steps = (i == Ydrip_s1  ? 16 :
-                        i == Ydrip_s1B ? 16 :
-                        i == Ydrip_s2  ? 16 :
-                        i == Ydrip_s2B ? 16 :
+       int num_steps = (i == Ydrip_1_s  ? 16 :
+                        i == Ydrip_1_sB ? 16 :
+                        i == Ydrip_2_s  ? 16 :
+                        i == Ydrip_2_sB ? 16 :
                         i == Xsand_stonein_1 ? 32 :
                         i == Xsand_stonein_2 ? 32 :
                         i == Xsand_stonein_3 ? 32 :
@@ -8832,8 +8832,8 @@ void InitGraphicInfo_EM(void)
                         i == Xsand_stoneout_2 ? 16 : 8);
        int cx = ABS(dx) * (TILEX / num_steps);
        int cy = ABS(dy) * (TILEY / num_steps);
-       int step_frame = (i == Ydrip_s2         ? j + 8 :
-                         i == Ydrip_s2B        ? j + 8 :
+       int step_frame = (i == Ydrip_2_s        ? j + 8 :
+                         i == Ydrip_2_sB       ? j + 8 :
                          i == Xsand_stonein_2  ? j + 8 :
                          i == Xsand_stonein_3  ? j + 16 :
                          i == Xsand_stonein_4  ? j + 24 :
@@ -8994,7 +8994,7 @@ void InitGraphicInfo_EM(void)
 
   for (p = 0; p < MAX_PLAYERS; p++)
   {
-    for (i = 0; i < SPR_MAX; i++)
+    for (i = 0; i < PLY_MAX; i++)
     {
       int element = player_mapping[p][i].element_rnd;
       int action = player_mapping[p][i].action;
Rocks'n'Diamonds