// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// game.c
// ============================================================================
#define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
(CAN_MOVE_INTO_ACID(e) && \
- Feld[x][y] == EL_ACID) || \
+ Tile[x][y] == EL_ACID) || \
(condition)))
#define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
(CAN_MOVE_INTO_ACID(e) && \
- Feld[x][y] == EL_ACID) || \
+ Tile[x][y] == EL_ACID) || \
(condition)))
#define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
(condition) || \
(CAN_MOVE_INTO_ACID(e) && \
- Feld[x][y] == EL_ACID) || \
+ Tile[x][y] == EL_ACID) || \
(DONT_COLLIDE_WITH(e) && \
IS_PLAYER(x, y) && \
!PLAYER_ENEMY_PROTECTED(x, y))))
ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
#define ANDROID_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Feld[x][y] == EL_EMC_PLANT)
+ ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
#define ANDROID_CAN_CLONE_FIELD(x, y) \
- (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Feld[x][y]) || \
+ (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
#define ENEMY_CAN_ENTER_FIELD(e, x, y) \
ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
#define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND)
+ ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
#define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y]))
+ ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
#define PACMAN_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y]))
+ ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
#define PIG_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y]))
+ ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
#define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
- ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN || \
- Feld[x][y] == EL_EM_EXIT_OPEN || \
- Feld[x][y] == EL_STEEL_EXIT_OPEN || \
- Feld[x][y] == EL_EM_STEEL_EXIT_OPEN || \
- IS_FOOD_PENGUIN(Feld[x][y])))
+ ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
+ Tile[x][y] == EL_EM_EXIT_OPEN || \
+ Tile[x][y] == EL_STEEL_EXIT_OPEN || \
+ Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
+ IS_FOOD_PENGUIN(Tile[x][y])))
#define DRAGON_CAN_ENTER_FIELD(e, x, y) \
ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
#define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
- (IN_LEV_FIELD(x, y) && (Feld[x][y] == EL_EMC_SPRING_BUMPER || \
- Feld[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
+ (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
+ Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
#define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
#define CE_ENTER_FIELD_COND(e, x, y) \
(!IS_PLAYER(x, y) && \
- IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e)))
+ IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
#define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
#define GAME_CTRL_ID_PANEL_STOP 8
#define GAME_CTRL_ID_PANEL_PAUSE 9
#define GAME_CTRL_ID_PANEL_PLAY 10
-#define SOUND_CTRL_ID_MUSIC 11
-#define SOUND_CTRL_ID_LOOPS 12
-#define SOUND_CTRL_ID_SIMPLE 13
-#define SOUND_CTRL_ID_PANEL_MUSIC 14
-#define SOUND_CTRL_ID_PANEL_LOOPS 15
-#define SOUND_CTRL_ID_PANEL_SIMPLE 16
+#define GAME_CTRL_ID_TOUCH_STOP 11
+#define GAME_CTRL_ID_TOUCH_PAUSE 12
+#define SOUND_CTRL_ID_MUSIC 13
+#define SOUND_CTRL_ID_LOOPS 14
+#define SOUND_CTRL_ID_SIMPLE 15
+#define SOUND_CTRL_ID_PANEL_MUSIC 16
+#define SOUND_CTRL_ID_PANEL_LOOPS 17
+#define SOUND_CTRL_ID_PANEL_SIMPLE 18
-#define NUM_GAME_BUTTONS 17
+#define NUM_GAME_BUTTONS 19
// forward declaration for internal use
static void HandleGameButtons(struct GadgetInfo *);
-int AmoebeNachbarNr(int, int);
-void AmoebeUmwandeln(int, int);
+int AmoebaNeighbourNr(int, int);
+void AmoebaToDiamond(int, int);
void ContinueMoving(int, int);
void Bang(int, int);
void InitMovDir(int, int);
static int getInvisibleActiveFromInvisibleElement(int);
static int getInvisibleFromInvisibleActiveElement(int);
+static void TestFieldAfterSnapping(int, int, int, int, int);
+
static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
// for detection of endless loops, caused by custom element programming
#define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
#define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
-#define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Feld[x][y]) || \
+#define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
IS_JUST_CHANGING(x, y))
#define CE_PAGE(e, ce) (element_info[e].event_page[ce])
return element;
}
-static void IncrementPlayerSokobanFieldsNeeded(struct PlayerInfo *player)
+static void IncrementSokobanFieldsNeeded(void)
{
if (level.sb_fields_needed)
- player->sokoban_fields_still_needed++;
+ game.sokoban_fields_still_needed++;
}
-static void IncrementPlayerSokobanObjectsNeeded(struct PlayerInfo *player)
+static void IncrementSokobanObjectsNeeded(void)
{
if (level.sb_objects_needed)
- player->sokoban_objects_still_needed++;
+ game.sokoban_objects_still_needed++;
}
-static void DecrementPlayerSokobanFieldsNeeded(struct PlayerInfo *player)
+static void DecrementSokobanFieldsNeeded(void)
{
- if (player->sokoban_fields_still_needed > 0)
- player->sokoban_fields_still_needed--;
+ if (game.sokoban_fields_still_needed > 0)
+ game.sokoban_fields_still_needed--;
}
-static void DecrementPlayerSokobanObjectsNeeded(struct PlayerInfo *player)
+static void DecrementSokobanObjectsNeeded(void)
{
- if (player->sokoban_objects_still_needed > 0)
- player->sokoban_objects_still_needed--;
+ if (game.sokoban_objects_still_needed > 0)
+ game.sokoban_objects_still_needed--;
}
static void InitPlayerField(int x, int y, int element, boolean init_game)
{
if (stored_player[0].present)
{
- Feld[x][y] = EL_SP_MURPHY_CLONE;
+ Tile[x][y] = EL_SP_MURPHY_CLONE;
return;
}
stored_player[0].artwork_element = EL_SP_MURPHY;
}
- Feld[x][y] = EL_PLAYER_1;
+ Tile[x][y] = EL_PLAYER_1;
}
}
if (init_game)
{
- struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1];
+ struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
int jx = player->jx, jy = player->jy;
player->present = TRUE;
player->active = TRUE;
// remove potentially duplicate players
- if (StorePlayer[jx][jy] == Feld[x][y])
+ if (StorePlayer[jx][jy] == Tile[x][y])
StorePlayer[jx][jy] = 0;
- StorePlayer[x][y] = Feld[x][y];
+ StorePlayer[x][y] = Tile[x][y];
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("- player element %d activated", player->element_nr);
- printf(" (local player is %d and currently %s)\n",
- local_player->element_nr,
- local_player->active ? "active" : "not active");
- }
+ Debug("game:init:player", "- player element %d activated",
+ player->element_nr);
+ Debug("game:init:player", " (local player is %d and currently %s)",
+ local_player->element_nr,
+ local_player->active ? "active" : "not active");
}
#endif
- Feld[x][y] = EL_EMPTY;
+ Tile[x][y] = EL_EMPTY;
player->jx = player->last_jx = x;
player->jy = player->last_jy = y;
}
- if (!init_game)
+ // always check if player was just killed and should be reanimated
{
int player_nr = GET_PLAYER_NR(element);
struct PlayerInfo *player = &stored_player[player_nr];
static void InitField(int x, int y, boolean init_game)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
switch (element)
{
break;
case EL_SOKOBAN_FIELD_PLAYER:
- element = Feld[x][y] = EL_PLAYER_1;
+ element = Tile[x][y] = EL_PLAYER_1;
InitField(x, y, init_game);
- element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY;
+ element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
InitField(x, y, init_game);
break;
case EL_SOKOBAN_FIELD_EMPTY:
- IncrementPlayerSokobanFieldsNeeded(local_player);
+ IncrementSokobanFieldsNeeded();
break;
case EL_SOKOBAN_OBJECT:
- IncrementPlayerSokobanObjectsNeeded(local_player);
+ IncrementSokobanObjectsNeeded();
break;
case EL_STONEBLOCK:
- if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID)
- Feld[x][y] = EL_ACID_POOL_TOPLEFT;
- else if (x > 0 && Feld[x-1][y] == EL_ACID)
- Feld[x][y] = EL_ACID_POOL_TOPRIGHT;
- else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT)
- Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT;
- else if (y > 0 && Feld[x][y-1] == EL_ACID)
- Feld[x][y] = EL_ACID_POOL_BOTTOM;
- else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT)
- Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
+ if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
+ Tile[x][y] = EL_ACID_POOL_TOPLEFT;
+ else if (x > 0 && Tile[x-1][y] == EL_ACID)
+ Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
+ else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
+ Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
+ else if (y > 0 && Tile[x][y-1] == EL_ACID)
+ Tile[x][y] = EL_ACID_POOL_BOTTOM;
+ else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
+ Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
break;
case EL_BUG:
case EL_MOLE_RIGHT:
case EL_MOLE_UP:
case EL_MOLE_DOWN:
+ case EL_SPRING_LEFT:
+ case EL_SPRING_RIGHT:
InitMovDir(x, y);
break;
case EL_AMOEBA_DROP:
if (y == lev_fieldy - 1)
{
- Feld[x][y] = EL_AMOEBA_GROWING;
+ Tile[x][y] = EL_AMOEBA_GROWING;
Store[x][y] = EL_AMOEBA_WET;
}
break;
break;
case EL_LAMP:
- local_player->lights_still_needed++;
+ game.lights_still_needed++;
break;
case EL_PENGUIN:
- local_player->friends_still_needed++;
+ game.friends_still_needed++;
break;
case EL_PIG:
case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
if (init_game)
{
- int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]);
- int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]);
- int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]);
+ int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
+ int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
+ int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
if (game.belt_dir_nr[belt_nr] == 3) // initial value
{
}
else // more than one switch -- set it like the first switch
{
- Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
+ Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
}
}
break;
case EL_INVISIBLE_SAND:
if (game.light_time_left > 0 ||
game.lenses_time_left > 0)
- Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
+ Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
break;
case EL_EMC_MAGIC_BALL:
- if (game.ball_state)
- Feld[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
+ if (game.ball_active)
+ Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
break;
case EL_EMC_MAGIC_BALL_SWITCH:
- if (game.ball_state)
- Feld[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
+ if (game.ball_active)
+ Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
break;
case EL_TRIGGER_PLAYER:
case EL_NEXT_CE_7:
case EL_NEXT_CE_8:
// reference elements should not be used on the playfield
- Feld[x][y] = EL_EMPTY;
+ Tile[x][y] = EL_EMPTY;
break;
default:
InitMovDir(x, y);
if (!element_info[element].use_last_ce_value || init_game)
- CustomValue[x][y] = GET_NEW_CE_VALUE(Feld[x][y]);
+ CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
}
else if (IS_GROUP_ELEMENT(element))
{
- Feld[x][y] = GetElementFromGroupElement(element);
+ Tile[x][y] = GetElementFromGroupElement(element);
InitField(x, y, init_game);
}
// not needed to call InitMovDir() -- already done by InitField()!
if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
- CAN_MOVE(Feld[x][y]))
+ CAN_MOVE(Tile[x][y]))
InitMovDir(x, y);
}
static void InitField_WithBug2(int x, int y, boolean init_game)
{
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
InitField(x, y, init_game);
int getPlayerInventorySize(int player_nr)
{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- return level.native_em_level->ply[player_nr]->dynamite;
+ return game_em.ply[player_nr]->dynamite;
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
- return level.native_sp_level->game_sp->red_disk_count;
+ return game_sp.red_disk_count;
else
return stored_player[player_nr].inventory_size;
}
if (nr != i)
{
- Error(ERR_INFO, "'game_panel_controls' structure corrupted at %d", i);
- Error(ERR_EXIT, "this should not happen -- please debug");
+ Error("'game_panel_controls' structure corrupted at %d", i);
+
+ Fail("this should not happen -- please debug");
}
// force update of game controls after initialization
SCAN_PLAYFIELD(x, y)
{
- element_info[Feld[x][y]].element_count++;
+ element_info[Tile[x][y]].element_count++;
}
for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
int time = (game.LevelSolved ?
game.LevelSolved_CountingTime :
level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->time :
+ game_em.lev->time :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
- level.native_sp_level->game_sp->time_played :
+ game_sp.time_played :
level.game_engine_type == GAME_ENGINE_TYPE_MM ?
game_mm.energy_left :
game.no_time_limit ? TimePlayed : TimeLeft);
int score = (game.LevelSolved ?
game.LevelSolved_CountingScore :
level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->score :
+ game_em.lev->score :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
- level.native_sp_level->game_sp->score :
+ game_sp.score :
level.game_engine_type == GAME_ENGINE_TYPE_MM ?
game_mm.score :
- local_player->score);
+ game.score);
int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->required :
+ game_em.lev->gems_needed :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
- level.native_sp_level->game_sp->infotrons_still_needed :
+ game_sp.infotrons_still_needed :
level.game_engine_type == GAME_ENGINE_TYPE_MM ?
game_mm.kettles_still_needed :
- local_player->gems_still_needed);
+ game.gems_still_needed);
int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->required > 0 :
+ game_em.lev->gems_needed > 0 :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
- level.native_sp_level->game_sp->infotrons_still_needed > 0 :
+ game_sp.infotrons_still_needed > 0 :
level.game_engine_type == GAME_ENGINE_TYPE_MM ?
game_mm.kettles_still_needed > 0 ||
game_mm.lights_still_needed > 0 :
- local_player->gems_still_needed > 0 ||
- local_player->sokoban_fields_still_needed > 0 ||
- local_player->sokoban_objects_still_needed > 0 ||
- local_player->lights_still_needed > 0);
+ game.gems_still_needed > 0 ||
+ game.sokoban_fields_still_needed > 0 ||
+ game.sokoban_objects_still_needed > 0 ||
+ game.lights_still_needed > 0);
int health = (game.LevelSolved ?
game.LevelSolved_CountingHealth :
level.game_engine_type == GAME_ENGINE_TYPE_MM ?
MM_HEALTH(game_mm.laser_overload_value) :
- local_player->health);
+ game.health);
+ int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
UpdatePlayfieldElementCount();
{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
- if (level.native_em_level->ply[i]->keys & (1 << k))
+ if (game_em.ply[i]->keys & (1 << k))
game_panel_controls[GAME_PANEL_KEY_1 + k].value =
get_key_element_from_nr(k);
}
{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
- if (level.native_em_level->ply[player_nr]->keys & (1 << k))
+ if (game_em.ply[player_nr]->keys & (1 << k))
game_panel_controls[GAME_PANEL_KEY_1 + k].value =
get_key_element_from_nr(k);
}
stored_player[player_nr].num_white_keys;
}
+ // re-arrange keys on game panel, if needed or if defined by style settings
+ for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
+ {
+ int nr = GAME_PANEL_KEY_1 + i;
+ struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
+ struct TextPosInfo *pos = gpc->pos;
+
+ // skip check if key is not in the player's inventory
+ if (gpc->value == EL_EMPTY)
+ continue;
+
+ // check if keys should be arranged on panel from left to right
+ if (pos->style == STYLE_LEFTMOST_POSITION)
+ {
+ // check previous key positions (left from current key)
+ for (k = 0; k < i; k++)
+ {
+ int nr_new = GAME_PANEL_KEY_1 + k;
+
+ if (game_panel_controls[nr_new].value == EL_EMPTY)
+ {
+ game_panel_controls[nr_new].value = gpc->value;
+ gpc->value = EL_EMPTY;
+
+ break;
+ }
+ }
+ }
+
+ // check if "undefined" keys can be placed at some other position
+ if (pos->x == -1 && pos->y == -1)
+ {
+ int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
+
+ // 1st try: display key at the same position as normal or EM keys
+ if (game_panel_controls[nr_new].value == EL_EMPTY)
+ {
+ game_panel_controls[nr_new].value = gpc->value;
+ }
+ else
+ {
+ // 2nd try: display key at the next free position in the key panel
+ for (k = 0; k < STD_NUM_KEYS; k++)
+ {
+ nr_new = GAME_PANEL_KEY_1 + k;
+
+ if (game_panel_controls[nr_new].value == EL_EMPTY)
+ {
+ game_panel_controls[nr_new].value = gpc->value;
+
+ break;
+ }
+ }
+ }
+ }
+ }
+
for (i = 0; i < NUM_PANEL_INVENTORY; i++)
{
game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
(exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
- (game.ball_state ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
+ (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
- (game.ball_state ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
+ (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
EL_EMC_MAGIC_BALL_SWITCH);
game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
(local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
game_panel_controls[GAME_PANEL_PENGUINS].value =
- local_player->friends_still_needed;
+ game.friends_still_needed;
game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
- local_player->sokoban_objects_still_needed;
+ game.sokoban_objects_still_needed;
game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
- local_player->sokoban_fields_still_needed;
+ game.sokoban_fields_still_needed;
game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
(game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
int last_anim_random_frame = gfx.anim_random_frame;
int element = gpc->value;
int graphic = el2panelimg(element);
+ int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
+ sync_random_frame : INIT_GFX_RANDOM());
if (gpc->value != gpc->last_value)
{
gpc->gfx_frame = 0;
- gpc->gfx_random = INIT_GFX_RANDOM();
+ gpc->gfx_random = init_gfx_random;
}
else
{
if (ANIM_MODE(graphic) == ANIM_RANDOM &&
IS_NEXT_FRAME(gpc->gfx_frame, graphic))
- gpc->gfx_random = INIT_GFX_RANDOM();
+ gpc->gfx_random = init_gfx_random;
}
if (ANIM_MODE(graphic) == ANIM_RANDOM)
if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
gpc->gfx_frame = element_info[element].collect_score;
- gpc->frame = getGraphicAnimationFrame(el2panelimg(gpc->value),
- gpc->gfx_frame);
+ gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
if (ANIM_MODE(graphic) == ANIM_RANDOM)
gfx.anim_random_frame = last_anim_random_frame;
{
int last_anim_random_frame = gfx.anim_random_frame;
int graphic = gpc->graphic;
+ int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
+ sync_random_frame : INIT_GFX_RANDOM());
if (gpc->value != gpc->last_value)
{
gpc->gfx_frame = 0;
- gpc->gfx_random = INIT_GFX_RANDOM();
+ gpc->gfx_random = init_gfx_random;
}
else
{
if (ANIM_MODE(graphic) == ANIM_RANDOM &&
IS_NEXT_FRAME(gpc->gfx_frame, graphic))
- gpc->gfx_random = INIT_GFX_RANDOM();
+ gpc->gfx_random = init_gfx_random;
}
if (ANIM_MODE(graphic) == ANIM_RANDOM)
if (PANEL_DEACTIVATED(pos))
continue;
+ if (pos->class == get_hash_from_key("extra_panel_items") &&
+ !setup.prefer_extra_panel_items)
+ continue;
+
gpc->last_value = value;
gpc->last_frame = frame;
element = value;
graphic = el2panelimg(value);
- // printf("::: %d, '%s' [%d]\n", element, EL_NAME(element), size);
+#if 0
+ Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
+ element, EL_NAME(element), size);
+#endif
if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
size = TILESIZE;
DisplayGameControlValues();
}
-#if 0
-static void UpdateGameDoorValues(void)
+void UpdateGameDoorValues(void)
{
UpdateGameControlValues();
}
-#endif
void DrawGameDoorValues(void)
{
game.team_mode = (num_players > 1);
}
+#if 0
+ Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
+ level.game_version);
+ Debug("game:init:level", " tape.file_version == %06d",
+ tape.file_version);
+ Debug("game:init:level", " tape.game_version == %06d",
+ tape.game_version);
+ Debug("game:init:level", " tape.engine_version == %06d",
+ tape.engine_version);
+ Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
+ game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
+#endif
+
// --------------------------------------------------------------------------
// set flags for bugs and changes according to active game engine version
// --------------------------------------------------------------------------
+ /*
+ Summary of bugfix:
+ Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
+
+ Bug was introduced in version:
+ 2.0.1
+
+ Bug was fixed in version:
+ 4.2.0.0
+
+ Description:
+ In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
+ but the property "can fall" was missing, which caused some levels to be
+ unsolvable. This was fixed in version 4.2.0.0.
+
+ Affected levels/tapes:
+ An example for a tape that was fixed by this bugfix is tape 029 from the
+ level set "rnd_sam_bateman".
+ The wrong behaviour will still be used for all levels or tapes that were
+ created/recorded with it. An example for this is tape 023 from the level
+ set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
+ */
+
+ boolean use_amoeba_dropping_cannot_fall_bug =
+ ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
+ game.engine_version < VERSION_IDENT(4,2,0,0)) ||
+ (tape.playing &&
+ tape.game_version >= VERSION_IDENT(2,0,1,0) &&
+ tape.game_version < VERSION_IDENT(4,2,0,0)));
+
+ /*
+ Summary of bugfix/change:
+ Fixed move speed of elements entering or leaving magic wall.
+
+ Fixed/changed in version:
+ 2.0.1
+
+ Description:
+ Before 2.0.1, move speed of elements entering or leaving magic wall was
+ twice as fast as it is now.
+ Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
+
+ Affected levels/tapes:
+ The first condition is generally needed for all levels/tapes before version
+ 2.0.1, which might use the old behaviour before it was changed; known tapes
+ that are affected: Tape 014 from the level set "rnd_conor_mancone".
+ The second condition is an exception from the above case and is needed for
+ the special case of tapes recorded with game (not engine!) version 2.0.1 or
+ above, but before it was known that this change would break tapes like the
+ above and was fixed in 4.2.0.0, so that the changed behaviour was active
+ although the engine version while recording maybe was before 2.0.1. There
+ are a lot of tapes that are affected by this exception, like tape 006 from
+ the level set "rnd_conor_mancone".
+ */
+
+ boolean use_old_move_stepsize_for_magic_wall =
+ (game.engine_version < VERSION_IDENT(2,0,1,0) &&
+ !(tape.playing &&
+ tape.game_version >= VERSION_IDENT(2,0,1,0) &&
+ tape.game_version < VERSION_IDENT(4,2,0,0)));
+
/*
Summary of bugfix/change:
Fixed handling for custom elements that change when pushed by the player.
game.use_block_last_field_bug =
(game.engine_version < VERSION_IDENT(3,1,1,0));
+ /* various special flags and settings for native Emerald Mine game engine */
+
game_em.use_single_button =
(game.engine_version > VERSION_IDENT(4,0,0,2));
game_em.use_snap_key_bug =
(game.engine_version < VERSION_IDENT(4,0,1,0));
+ game_em.use_random_bug =
+ (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
+
+ boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
+
+ game_em.use_old_explosions = use_old_em_engine;
+ game_em.use_old_android = use_old_em_engine;
+ game_em.use_old_push_elements = use_old_em_engine;
+ game_em.use_old_push_into_acid = use_old_em_engine;
+
+ game_em.use_wrap_around = !use_old_em_engine;
+
// --------------------------------------------------------------------------
// set maximal allowed number of custom element changes per game frame
// dynamically adjust element properties according to game engine version
InitElementPropertiesEngine(game.engine_version);
-#if 0
- printf("level %d: level version == %06d\n", level_nr, level.game_version);
- printf(" tape version == %06d [%s] [file: %06d]\n",
- tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
- tape.file_version);
- printf(" => game.engine_version == %06d\n", game.engine_version);
-#endif
+ // ---------- initialize special element properties -------------------------
+
+ // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
+ if (use_amoeba_dropping_cannot_fall_bug)
+ SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
// ---------- initialize player's initial move delay ------------------------
int e = move_stepsize_list[i].element;
element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
+
+ // set move stepsize value for certain elements for older engine versions
+ if (use_old_move_stepsize_for_magic_wall)
+ {
+ if (e == EL_MAGIC_WALL_FILLING ||
+ e == EL_MAGIC_WALL_EMPTYING ||
+ e == EL_BD_MAGIC_WALL_FILLING ||
+ e == EL_BD_MAGIC_WALL_EMPTYING)
+ element_info[e].move_stepsize *= 2;
+ }
}
// ---------- initialize collect score --------------------------------------
// ---------- initialize graphics engine ------------------------------------
game.scroll_delay_value =
(game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
+ level.game_engine_type == GAME_ENGINE_TYPE_EM &&
+ !setup.forced_scroll_delay ? 0 :
setup.scroll_delay ? setup.scroll_delay_value : 0);
game.scroll_delay_value =
MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
// Supaplex levels with time limit currently unsupported -- should be added
if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
level.time = 0;
+
+ // ---------- initialize flags for handling game actions --------------------
+
+ // set flags for game actions to default values
+ game.use_key_actions = TRUE;
+ game.use_mouse_actions = FALSE;
+
+ // when using Mirror Magic game engine, handle mouse events only
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ game.use_key_actions = FALSE;
+ game.use_mouse_actions = TRUE;
+ }
+
+ // check for custom elements with mouse click events
+ if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
+ HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
+ HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
+ HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
+ game.use_mouse_actions = TRUE;
+ }
+ }
}
static int get_num_special_action(int element, int action_first,
if (!options.debug)
return;
- printf("%s:\n", message);
+ Debug("game:init:player", "%s:", message);
for (i = 0; i < MAX_PLAYERS; i++)
{
struct PlayerInfo *player = &stored_player[i];
- printf("- player %d: present == %d, connected == %d [%d/%d], active == %d",
- i + 1,
- player->present,
- player->connected,
- player->connected_locally,
- player->connected_network,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
+ Debug("game:init:player",
+ "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
+ i + 1,
+ player->present,
+ player->connected,
+ player->connected_locally,
+ player->connected_network,
+ player->active,
+ (local_player == player ? " (local player)" : ""));
}
}
#endif
SetGameStatus(GAME_MODE_PLAYING);
if (level_editor_test_game)
- FadeSkipNextFadeIn();
+ FadeSkipNextFadeOut();
else
FadeSetEnterScreen();
- if (CheckIfGlobalBorderOrPlayfieldViewportHasChanged())
+ if (CheckFadeAll())
fade_mask = REDRAW_ALL;
FadeLevelSoundsAndMusic();
FadeOut(fade_mask);
+ if (level_editor_test_game)
+ FadeSkipNextFadeIn();
+
// needed if different viewport properties defined for playing
ChangeViewportPropertiesIfNeeded();
InitGameEngine();
InitGameControlValues();
+ if (tape.recording)
+ {
+ // initialize tape actions from game when recording tape
+ tape.use_key_actions = game.use_key_actions;
+ tape.use_mouse_actions = game.use_mouse_actions;
+
+ // initialize visible playfield size when recording tape (for team mode)
+ tape.scr_fieldx = SCR_FIELDX;
+ tape.scr_fieldy = SCR_FIELDY;
+ }
+
// don't play tapes over network
network_playing = (network.enabled && !tape.playing);
player->killed = FALSE;
player->reanimated = FALSE;
+ player->buried = FALSE;
player->action = 0;
player->effective_action = 0;
player->programmed_action = 0;
+ player->snap_action = 0;
player->mouse_action.lx = 0;
player->mouse_action.ly = 0;
player->effective_mouse_action.button = 0;
player->effective_mouse_action.button_hint = 0;
- player->score = 0;
- player->score_final = 0;
-
- player->health = MAX_HEALTH;
- player->health_final = MAX_HEALTH;
-
- player->gems_still_needed = level.gems_needed;
- player->sokoban_fields_still_needed = 0;
- player->sokoban_objects_still_needed = 0;
- player->lights_still_needed = 0;
- player->players_still_needed = 0;
- player->friends_still_needed = 0;
-
for (j = 0; j < MAX_NUM_KEYS; j++)
player->key[j] = FALSE;
player->shield_normal_time_left = 0;
player->shield_deadly_time_left = 0;
+ player->last_removed_element = EL_UNDEFINED;
+
player->inventory_infinite_element = EL_UNDEFINED;
player->inventory_size = 0;
DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
SnapField(player, 0, 0);
- player->GameOver = FALSE;
-
map_player_action[i] = i;
}
if (network_playing)
SendToServer_MovePlayer(MV_NONE);
- ZX = ZY = -1;
- ExitX = ExitY = -1;
-
FrameCounter = 0;
TimeFrames = 0;
TimePlayed = 0;
ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
- AllPlayersGone = FALSE;
+ game.robot_wheel_x = -1;
+ game.robot_wheel_y = -1;
+
+ game.exit_x = -1;
+ game.exit_y = -1;
+
+ game.all_players_gone = FALSE;
game.LevelSolved = FALSE;
+ game.GameOver = FALSE;
+
+ game.GamePlayed = !tape.playing;
game.LevelSolved_GameWon = FALSE;
game.LevelSolved_GameEnd = FALSE;
game.switchgate_pos = 0;
game.wind_direction = level.wind_direction_initial;
+ game.score = 0;
+ game.score_final = 0;
+
+ game.health = MAX_HEALTH;
+ game.health_final = MAX_HEALTH;
+
+ game.gems_still_needed = level.gems_needed;
+ game.sokoban_fields_still_needed = 0;
+ game.sokoban_objects_still_needed = 0;
+ game.lights_still_needed = 0;
+ game.players_still_needed = 0;
+ game.friends_still_needed = 0;
+
game.lenses_time_left = 0;
game.magnify_time_left = 0;
- game.ball_state = level.ball_state_initial;
+ game.ball_active = level.ball_active_initial;
game.ball_content_nr = 0;
game.explosions_delayed = TRUE;
SCAN_PLAYFIELD(x, y)
{
- Feld[x][y] = Last[x][y] = level.field[x][y];
+ Tile[x][y] = Last[x][y] = level.field[x][y];
MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
ChangeDelay[x][y] = 0;
ChangePage[x][y] = -1;
SCAN_PLAYFIELD(x, y)
{
- if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
+ if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
emulate_bd = FALSE;
- if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
+ if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
emulate_sb = FALSE;
- if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
+ if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
emulate_sp = FALSE;
InitField(x, y, TRUE);
game.belt_dir_nr[i] = 3; // not moving, next moving left
#if USE_NEW_PLAYER_ASSIGNMENTS
+ // use preferred player also in local single-player mode
+ if (!network.enabled && !game.team_mode)
+ {
+ int new_index_nr = setup.network_player_nr;
+
+ if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
+ {
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].connected_locally = FALSE;
+
+ stored_player[new_index_nr].connected_locally = TRUE;
+ }
+ }
+
for (i = 0; i < MAX_PLAYERS; i++)
{
stored_player[i].connected = FALSE;
#endif
#if DEBUG_INIT_PLAYER
- if (options.debug)
- printf("Reassigning players ...\n");
+ Debug("game:init:player", "Reassigning players ...");
#endif
// check if any connected player was not found in playfield
struct PlayerInfo *field_player = NULL;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- printf("- looking for field player for player %d ...\n", i + 1);
+ Debug("game:init:player",
+ "- looking for field player for player %d ...", i + 1);
#endif
// assign first free player found that is present in the playfield
int jx = field_player->jx, jy = field_player->jy;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- printf("- found player %d\n", field_player->index_nr + 1);
+ Debug("game:init:player", "- found player %d",
+ field_player->index_nr + 1);
#endif
player->present = FALSE;
field_player->mapped = TRUE;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- printf("- map_player_action[%d] == %d\n",
- field_player->index_nr + 1, i + 1);
+ Debug("game:init:player", "- map_player_action[%d] == %d",
+ field_player->index_nr + 1, i + 1);
#endif
}
}
#endif
#if 0
- printf("::: local_player->present == %d\n", local_player->present);
+ Debug("game:init:player", "local_player->present == %d",
+ local_player->present);
#endif
// set focus to local player for network games, else to all players
game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
game.centered_player_nr_next = game.centered_player_nr;
game.set_centered_player = FALSE;
+ game.set_centered_player_wrap = FALSE;
if (network_playing && tape.recording)
{
int jx = player->jx, jy = player->jy;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- printf("Removing player %d at (%d, %d)\n", i + 1, jx, jy);
+ Debug("game:init:player", "Removing player %d at (%d, %d)",
+ i + 1, jx, jy);
#endif
player->active = FALSE;
StorePlayer[jx][jy] = 0;
- Feld[jx][jy] = EL_EMPTY;
+ Tile[jx][jy] = EL_EMPTY;
}
}
}
player->active = FALSE;
StorePlayer[jx][jy] = 0;
- Feld[jx][jy] = EL_EMPTY;
+ Tile[jx][jy] = EL_EMPTY;
}
}
#endif
player->present = FALSE;
StorePlayer[jx][jy] = 0;
- Feld[jx][jy] = EL_EMPTY;
+ Tile[jx][jy] = EL_EMPTY;
}
}
}
for (i = 0; i < MAX_PLAYERS; i++)
if (stored_player[i].active)
- local_player->players_still_needed++;
+ game.players_still_needed++;
if (level.solved_by_one_player)
- local_player->players_still_needed = 1;
+ game.players_still_needed = 1;
// when recording the game, store which players take part in the game
if (tape.recording)
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int content;
int xx, yy;
boolean is_player;
game.restart_level = FALSE;
game.restart_game_message = NULL;
+
game.request_active = FALSE;
+ game.request_active_or_moving = FALSE;
if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
InitGameActions_MM();
{
// this is used for non-R'n'D game engines to update certain engine values
- if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- {
- actual_player_x = correctLevelPosX_EM(actual_player_x);
- actual_player_y = correctLevelPosY_EM(actual_player_y);
- }
-
// needed to determine if sounds are played within the visible screen area
scroll_x = actual_scroll_x;
scroll_y = actual_scroll_y;
void InitMovDir(int x, int y)
{
- int i, element = Feld[x][y];
+ int i, element = Tile[x][y];
static int xy[4][2] =
{
{ 0, +1 },
case EL_BUG_UP:
case EL_BUG_LEFT:
case EL_BUG_DOWN:
- Feld[x][y] = EL_BUG;
+ Tile[x][y] = EL_BUG;
MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
break;
case EL_SPACESHIP_UP:
case EL_SPACESHIP_LEFT:
case EL_SPACESHIP_DOWN:
- Feld[x][y] = EL_SPACESHIP;
+ Tile[x][y] = EL_SPACESHIP;
MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
break;
case EL_BD_BUTTERFLY_UP:
case EL_BD_BUTTERFLY_LEFT:
case EL_BD_BUTTERFLY_DOWN:
- Feld[x][y] = EL_BD_BUTTERFLY;
+ Tile[x][y] = EL_BD_BUTTERFLY;
MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
break;
case EL_BD_FIREFLY_UP:
case EL_BD_FIREFLY_LEFT:
case EL_BD_FIREFLY_DOWN:
- Feld[x][y] = EL_BD_FIREFLY;
+ Tile[x][y] = EL_BD_FIREFLY;
MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
break;
case EL_PACMAN_UP:
case EL_PACMAN_LEFT:
case EL_PACMAN_DOWN:
- Feld[x][y] = EL_PACMAN;
+ Tile[x][y] = EL_PACMAN;
MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
break;
case EL_YAMYAM_RIGHT:
case EL_YAMYAM_UP:
case EL_YAMYAM_DOWN:
- Feld[x][y] = EL_YAMYAM;
+ Tile[x][y] = EL_YAMYAM;
MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
break;
case EL_MOLE_RIGHT:
case EL_MOLE_UP:
case EL_MOLE_DOWN:
- Feld[x][y] = EL_MOLE;
+ Tile[x][y] = EL_MOLE;
MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
break;
+ case EL_SPRING_LEFT:
+ case EL_SPRING_RIGHT:
+ Tile[x][y] = EL_SPRING;
+ MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
+ break;
+
default:
if (IS_CUSTOM_ELEMENT(element))
{
void InitAmoebaNr(int x, int y)
{
int i;
- int group_nr = AmoebeNachbarNr(x, y);
+ int group_nr = AmoebaNeighbourNr(x, y);
if (group_nr == 0)
{
static void LevelSolved(void)
{
if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
- local_player->players_still_needed > 0)
+ game.players_still_needed > 0)
return;
game.LevelSolved = TRUE;
+ game.GameOver = TRUE;
- local_player->GameOver = TRUE;
-
- local_player->score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->score :
- level.game_engine_type == GAME_ENGINE_TYPE_MM ?
- game_mm.score :
- local_player->score);
- local_player->health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
- MM_HEALTH(game_mm.laser_overload_value) :
- local_player->health);
+ game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
+ game_em.lev->score :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.score :
+ game.score);
+ game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ MM_HEALTH(game_mm.laser_overload_value) :
+ game.health);
game.LevelSolved_CountingTime = (game.no_time_limit ? TimePlayed : TimeLeft);
- game.LevelSolved_CountingScore = local_player->score_final;
- game.LevelSolved_CountingHealth = local_player->health_final;
+ game.LevelSolved_CountingScore = game.score_final;
+ game.LevelSolved_CountingHealth = game.health_final;
}
void GameWon(void)
{
static int time_count_steps;
static int time, time_final;
- static int score, score_final;
+ static float score, score_final; // needed for time score < 10 for 10 seconds
static int health, health_final;
static int game_over_delay_1 = 0;
static int game_over_delay_2 = 0;
int game_over_delay_value_1 = 50;
int game_over_delay_value_2 = 25;
int game_over_delay_value_3 = 50;
+ int time_score_base = MIN(MAX(1, level.time_score_base), 10);
+ float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
if (!game.LevelSolved_GameWon)
{
int i;
// do not start end game actions before the player stops moving (to exit)
- if (local_player->MovPos)
+ if (local_player->active && local_player->MovPos)
return;
game.LevelSolved_GameWon = TRUE;
game_over_delay_3 = game_over_delay_value_3;
time = time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
- score = score_final = local_player->score_final;
- health = health_final = local_player->health_final;
+ score = score_final = game.score_final;
+ health = health_final = game.health_final;
- if (level.score[SC_TIME_BONUS] > 0)
+ if (time_score > 0)
{
+ int time_frames = 0;
+
if (TimeLeft > 0)
{
time_final = 0;
- score_final += TimeLeft * level.score[SC_TIME_BONUS];
+ time_frames = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
}
else if (game.no_time_limit && TimePlayed < 999)
{
time_final = 999;
- score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS];
+ time_frames = (999 - TimePlayed) * FRAMES_PER_SECOND - TimeFrames;
}
+ score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
+
time_count_steps = MAX(1, ABS(time_final - time) / 100);
game_over_delay_1 = game_over_delay_value_1;
if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
{
health_final = 0;
- score_final += health * level.score[SC_TIME_BONUS];
+ score_final += health * time_score;
game_over_delay_2 = game_over_delay_value_2;
}
- local_player->score_final = score_final;
- local_player->health_final = health_final;
+ game.score_final = score_final;
+ game.health_final = health_final;
}
if (level_editor_test_game)
if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
{
- if (ExitX >= 0 && ExitY >= 0) // local player has left the level
+ // check if last player has left the level
+ if (game.exit_x >= 0 &&
+ game.exit_y >= 0)
{
+ int x = game.exit_x;
+ int y = game.exit_y;
+ int element = Tile[x][y];
+
// close exit door after last player
- if ((AllPlayersGone &&
- (Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
- Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN ||
- Feld[ExitX][ExitY] == EL_STEEL_EXIT_OPEN)) ||
- Feld[ExitX][ExitY] == EL_EM_EXIT_OPEN ||
- Feld[ExitX][ExitY] == EL_EM_STEEL_EXIT_OPEN)
+ if ((game.all_players_gone &&
+ (element == EL_EXIT_OPEN ||
+ element == EL_SP_EXIT_OPEN ||
+ element == EL_STEEL_EXIT_OPEN)) ||
+ element == EL_EM_EXIT_OPEN ||
+ element == EL_EM_STEEL_EXIT_OPEN)
{
- int element = Feld[ExitX][ExitY];
- Feld[ExitX][ExitY] =
+ Tile[x][y] =
(element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
EL_EM_STEEL_EXIT_CLOSING);
- PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING);
+ PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
}
// player disappears
- DrawLevelField(ExitX, ExitY);
+ DrawLevelField(x, y);
}
for (i = 0; i < MAX_PLAYERS; i++)
time_count_steps = 1;
time += time_count_steps * time_count_dir;
- score += time_count_steps * level.score[SC_TIME_BONUS];
+ score += time_count_steps * time_score;
+
+ // set final score to correct rounding differences after counting score
+ if (time == time_final)
+ score = score_final;
game.LevelSolved_CountingTime = time;
game.LevelSolved_CountingScore = score;
int health_count_dir = (health < health_final ? +1 : -1);
health += health_count_dir;
- score += level.score[SC_TIME_BONUS];
+ score += time_score;
game.LevelSolved_CountingHealth = health;
game.LevelSolved_CountingScore = score;
LoadScore(level_nr);
if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
- local_player->score_final < highscore[MAX_SCORE_ENTRIES - 1].Score)
+ game.score_final < highscore[MAX_SCORE_ENTRIES - 1].Score)
return -1;
- for (k = 0; k < MAX_SCORE_ENTRIES; k++)
+ for (k = 0; k < MAX_SCORE_ENTRIES; k++)
{
- if (local_player->score_final > highscore[k].Score)
+ if (game.score_final > highscore[k].Score)
{
// player has made it to the hall of fame
strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
- highscore[k].Score = local_player->score_final;
+ highscore[k].Score = game.score_final;
position = k;
break;
static int getElementMoveStepsizeExt(int x, int y, int direction)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
int horiz_move = (dx != 0);
if (horiz_move)
{
if (CAN_FALL(element) &&
- y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
+ y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
step = sign * MOVE_STEPSIZE_NORMAL / 2;
else if (element == EL_SPRING)
step = sign * MOVE_STEPSIZE_NORMAL * 2;
if (DrawingDeactivatedField())
return;
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
if (graphic_info[graphic].anim_global_sync)
static void InitMovingField(int x, int y, int direction)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
int newx = x + dx;
if (is_moving_after)
{
- if (Feld[newx][newy] == EL_EMPTY)
- Feld[newx][newy] = EL_BLOCKED;
+ if (Tile[newx][newy] == EL_EMPTY)
+ Tile[newx][newy] = EL_BLOCKED;
MovDir[newx][newy] = MovDir[x][y];
static int MovingOrBlocked2Element(int x, int y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (element == EL_BLOCKED)
{
int oldx, oldy;
Blocked2Moving(x, y, &oldx, &oldy);
- return Feld[oldx][oldy];
+ return Tile[oldx][oldy];
}
else
return element;
// like MovingOrBlocked2Element(), but if element is moving
// and (x,y) is the field the moving element is just leaving,
// return EL_BLOCKED instead of the element value
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (IS_MOVING(x, y))
{
int oldx, oldy;
Blocked2Moving(x, y, &oldx, &oldy);
- return Feld[oldx][oldy];
+ return Tile[oldx][oldy];
}
else
return EL_BLOCKED;
static void RemoveField(int x, int y)
{
- Feld[x][y] = EL_EMPTY;
+ Tile[x][y] = EL_EMPTY;
MovPos[x][y] = 0;
MovDir[x][y] = 0;
static void RemoveMovingField(int x, int y)
{
int oldx = x, oldy = y, newx = x, newy = y;
- int element = Feld[x][y];
+ int element = Tile[x][y];
int next_element = EL_UNDEFINED;
if (element != EL_BLOCKED && !IS_MOVING(x, y))
{
Moving2Blocked(x, y, &newx, &newy);
- if (Feld[newx][newy] != EL_BLOCKED)
+ if (Tile[newx][newy] != EL_BLOCKED)
{
// element is moving, but target field is not free (blocked), but
// already occupied by something different (example: acid pool);
}
if (element == EL_BLOCKED &&
- (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
- Feld[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
- Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
- Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
- Feld[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
- Feld[oldx][oldy] == EL_AMOEBA_DROPPING))
- next_element = get_next_element(Feld[oldx][oldy]);
+ (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
+ Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
+ Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
+ Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
+ Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
+ Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
+ next_element = get_next_element(Tile[oldx][oldy]);
RemoveField(oldx, oldy);
RemoveField(newx, newy);
Store[oldx][oldy] = Store2[oldx][oldy] = 0;
if (next_element != EL_UNDEFINED)
- Feld[oldx][oldy] = next_element;
+ Tile[oldx][oldy] = next_element;
TEST_DrawLevelField(oldx, oldy);
TEST_DrawLevelField(newx, newy);
void DrawDynamite(int x, int y)
{
int sx = SCREENX(x), sy = SCREENY(y);
- int graphic = el2img(Feld[x][y]);
+ int graphic = el2img(Tile[x][y]);
int frame;
if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
{
- int dx = 0, dy = 0;
- int fx = FX, fy = FY;
-
- dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
- dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
+ int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
+ int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
if (dx == 0 && dy == 0) // no scrolling needed at all
break;
scroll_x -= dx;
scroll_y -= dy;
- fx += dx * TILEX / 2;
- fy += dy * TILEY / 2;
+ // set values for horizontal/vertical screen scrolling (half tile size)
+ int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
+ int dir_y = (dy != 0 ? MV_VERTICAL : 0);
+ int pos_x = dx * TILEX / 2;
+ int pos_y = dy * TILEY / 2;
+ int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
+ int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
ScrollLevel(dx, dy);
DrawAllPlayers();
// scroll in two steps of half tile size to make things smoother
- BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ BlitScreenToBitmapExt_RND(window, fx, fy);
// scroll second step to align at full tile size
BlitScreenToBitmap(window);
int wait_delay_value = (no_delay ? 0 : frame_delay_value);
int old_jx = player->jx;
int old_jy = player->jy;
- int old_element = Feld[old_jx][old_jy];
- int element = Feld[jx][jy];
+ int old_element = Tile[old_jx][old_jy];
+ int element = Tile[jx][jy];
boolean player_relocated = (old_jx != jx || old_jy != jy);
int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
int enter_side = enter_side_horiz | enter_side_vert;
int leave_side = leave_side_horiz | leave_side_vert;
- if (player->GameOver) // do not reanimate dead player
+ if (player->buried) // do not reanimate dead player
return;
if (!player_relocated) // no need to relocate the player
CE_PLAYER_LEAVES_X,
player->index_bit, leave_side);
- Feld[jx][jy] = el_player;
+ Tile[jx][jy] = el_player;
InitPlayerField(jx, jy, el_player, TRUE);
- /* "InitPlayerField()" above sets Feld[jx][jy] to EL_EMPTY, but it may be
+ /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
possible that the relocation target field did not contain a player element,
but a walkable element, to which the new player was relocated -- in this
case, restore that (already initialized!) element on the player field */
if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
{
- Feld[jx][jy] = element; // restore previously existing element
+ Tile[jx][jy] = element; // restore previously existing element
}
// only visually relocate centered player
if (phase == EX_PHASE_START) // initialize 'Store[][]' field
{
- int center_element = Feld[ex][ey];
+ int center_element = Tile[ex][ey];
int artwork_element, explosion_element; // set these values later
// remove things displayed in background while burning dynamite
// put moving element to center field (and let it explode there)
center_element = MovingOrBlocked2Element(ex, ey);
RemoveMovingField(ex, ey);
- Feld[ex][ey] = center_element;
+ Tile[ex][ey] = center_element;
}
// now "center_element" is finally determined -- set related values now
(mode == EX_TYPE_CROSS && (x != ex && y != ey)))
continue;
- element = Feld[x][y];
+ element = Tile[x][y];
if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
{
if (IS_ACTIVE_BOMB(element))
{
// re-activate things under the bomb like gate or penguin
- Feld[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
+ Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
Back[x][y] = 0;
}
center_element == EL_AMOEBA_TO_DIAMOND)
Store2[x][y] = element;
- Feld[x][y] = EL_EXPLOSION;
+ Tile[x][y] = EL_EXPLOSION;
GfxElement[x][y] = artwork_element;
ExplodePhase[x][y] = 1;
}
else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
{
- Feld[x][y] = Store2[x][y];
+ Tile[x][y] = Store2[x][y];
Store2[x][y] = 0;
Bang(x, y);
border_explosion = TRUE;
}
else if (border_element == EL_AMOEBA_TO_DIAMOND)
{
- AmoebeUmwandeln(x, y);
+ AmoebaToDiamond(x, y);
Store2[x][y] = 0;
border_explosion = TRUE;
}
{
int element;
- element = Feld[x][y] = Store[x][y];
+ element = Tile[x][y] = Store[x][y];
Store[x][y] = Store2[x][y] = 0;
GfxElement[x][y] = EL_UNDEFINED;
if (level.use_explosion_element[player_nr])
explosion_element = level.explosion_element[player_nr];
- Feld[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
+ Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
element_info[explosion_element].content.e[xx][yy]);
}
// restore probably existing indestructible background element
if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
- element = Feld[x][y] = Back[x][y];
+ element = Tile[x][y] = Back[x][y];
Back[x][y] = 0;
MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
static void DynaExplode(int ex, int ey)
{
int i, j;
- int dynabomb_element = Feld[ex][ey];
+ int dynabomb_element = Tile[ex][ey];
int dynabomb_size = 1;
boolean dynabomb_xl = FALSE;
struct PlayerInfo *player;
int y = ey + j * xy[i][1];
int element;
- if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
+ if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
break;
- element = Feld[x][y];
+ element = Tile[x][y];
// do not restart explosions of fields with active bombs
if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
{
struct PlayerInfo *player = PLAYERINFO(x, y);
- element = Feld[x][y] = player->initial_element;
+ element = Tile[x][y] = player->initial_element;
if (level.use_explosion_element[player->index_nr])
{
if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
(!IN_LEV_FIELD(x - 1, y - 2) ||
!CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
- Feld[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
+ Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
(!IN_LEV_FIELD(x + 1, y - 2) ||
!CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
- Feld[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
+ Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
PlayLevelSound(x, y, SND_ACID_SPLASHING);
}
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
for (i = 0; i < NUM_BELTS; i++)
{
if (e_belt_nr == belt_nr)
{
- int belt_part = Feld[x][y] - belt_base_element[belt_nr];
+ int belt_part = Tile[x][y] - belt_base_element[belt_nr];
- Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
+ Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
}
}
}
MV_NONE,
};
- int element = Feld[x][y];
+ int element = Tile[x][y];
int belt_nr = getBeltNrFromBeltSwitchElement(element);
int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
int belt_dir = belt_move_dir[belt_dir_nr];
SCAN_PLAYFIELD(xx, yy)
{
- int element = Feld[xx][yy];
+ int element = Tile[xx][yy];
if (IS_BELT_SWITCH(element))
{
if (e_belt_nr == belt_nr)
{
- Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
+ Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
TEST_DrawLevelField(xx, yy);
}
}
if (e_belt_nr == belt_nr)
{
- int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
+ int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
- Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
+ Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
TEST_DrawLevelField(xx, yy);
}
}
if (e_belt_nr == belt_nr)
{
- int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
+ int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
- Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
+ Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
TEST_DrawLevelField(xx, yy);
}
}
SCAN_PLAYFIELD(xx, yy)
{
- int element = Feld[xx][yy];
+ int element = Tile[xx][yy];
if (element == EL_SWITCHGATE_SWITCH_UP)
{
- Feld[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
+ Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
TEST_DrawLevelField(xx, yy);
}
else if (element == EL_SWITCHGATE_SWITCH_DOWN)
{
- Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
+ Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
TEST_DrawLevelField(xx, yy);
}
else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
{
- Feld[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
+ Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
TEST_DrawLevelField(xx, yy);
}
else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
{
- Feld[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
+ Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
TEST_DrawLevelField(xx, yy);
}
else if (element == EL_SWITCHGATE_OPEN ||
element == EL_SWITCHGATE_OPENING)
{
- Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
+ Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
}
else if (element == EL_SWITCHGATE_CLOSED ||
element == EL_SWITCHGATE_CLOSING)
{
- Feld[xx][yy] = EL_SWITCHGATE_OPENING;
+ Tile[xx][yy] = EL_SWITCHGATE_OPENING;
PlayLevelSoundAction(xx, yy, ACTION_OPENING);
}
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (element == EL_LIGHT_SWITCH &&
game.light_time_left > 0)
{
- Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
+ Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
TEST_DrawLevelField(x, y);
}
else if (element == EL_LIGHT_SWITCH_ACTIVE &&
game.light_time_left == 0)
{
- Feld[x][y] = EL_LIGHT_SWITCH;
+ Tile[x][y] = EL_LIGHT_SWITCH;
TEST_DrawLevelField(x, y);
}
else if (element == EL_EMC_DRIPPER &&
game.light_time_left > 0)
{
- Feld[x][y] = EL_EMC_DRIPPER_ACTIVE;
+ Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
TEST_DrawLevelField(x, y);
}
else if (element == EL_EMC_DRIPPER_ACTIVE &&
game.light_time_left == 0)
{
- Feld[x][y] = EL_EMC_DRIPPER;
+ Tile[x][y] = EL_EMC_DRIPPER;
TEST_DrawLevelField(x, y);
}
else if (element == EL_INVISIBLE_STEELWALL ||
element == EL_INVISIBLE_SAND)
{
if (game.light_time_left > 0)
- Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
+ Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
TEST_DrawLevelField(x, y);
element == EL_INVISIBLE_SAND_ACTIVE)
{
if (game.light_time_left == 0)
- Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
+ Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
TEST_DrawLevelField(x, y);
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (element == EL_EMC_DRIPPER &&
game.lenses_time_left > 0)
{
- Feld[x][y] = EL_EMC_DRIPPER_ACTIVE;
+ Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
TEST_DrawLevelField(x, y);
}
else if (element == EL_EMC_DRIPPER_ACTIVE &&
game.lenses_time_left == 0)
{
- Feld[x][y] = EL_EMC_DRIPPER;
+ Tile[x][y] = EL_EMC_DRIPPER;
TEST_DrawLevelField(x, y);
}
else if (element == EL_INVISIBLE_STEELWALL ||
element == EL_INVISIBLE_SAND)
{
if (game.lenses_time_left > 0)
- Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
+ Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
TEST_DrawLevelField(x, y);
element == EL_INVISIBLE_SAND_ACTIVE)
{
if (game.lenses_time_left == 0)
- Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
+ Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
TEST_DrawLevelField(x, y);
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (element == EL_EMC_FAKE_GRASS &&
game.magnify_time_left > 0)
{
- Feld[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
+ Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
TEST_DrawLevelField(x, y);
}
else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
game.magnify_time_left == 0)
{
- Feld[x][y] = EL_EMC_FAKE_GRASS;
+ Tile[x][y] = EL_EMC_FAKE_GRASS;
TEST_DrawLevelField(x, y);
}
else if (IS_GATE_GRAY(element) &&
game.magnify_time_left > 0)
{
- Feld[x][y] = (IS_RND_GATE_GRAY(element) ?
+ Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
IS_EM_GATE_GRAY(element) ?
element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
else if (IS_GATE_GRAY_ACTIVE(element) &&
game.magnify_time_left == 0)
{
- Feld[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
+ Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
IS_EM_GATE_GRAY_ACTIVE(element) ?
element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
static void ToggleLightSwitch(int x, int y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
game.light_time_left =
(element == EL_LIGHT_SWITCH ?
SCAN_PLAYFIELD(xx, yy)
{
- int element = Feld[xx][yy];
+ int element = Tile[xx][yy];
if (element == EL_TIMEGATE_CLOSED ||
element == EL_TIMEGATE_CLOSING)
{
- Feld[xx][yy] = EL_TIMEGATE_OPENING;
+ Tile[xx][yy] = EL_TIMEGATE_OPENING;
PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
}
/*
else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
{
- Feld[xx][yy] = EL_TIMEGATE_SWITCH;
+ Tile[xx][yy] = EL_TIMEGATE_SWITCH;
TEST_DrawLevelField(xx, yy);
}
*/
}
- Feld[x][y] = (Feld[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
+ Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
EL_DC_TIMEGATE_SWITCH_ACTIVE);
}
boolean last_line = (y == lev_fieldy - 1);
boolean object_hit = FALSE;
boolean impact = (last_line || object_hit);
- int element = Feld[x][y];
+ int element = Tile[x][y];
int smashed = EL_STEELWALL;
if (!last_line) // check if element below was hit
{
- if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
+ if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
return;
object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
object_hit = FALSE;
#if USE_QUICKSAND_IMPACT_BUGFIX
- if (Feld[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
+ if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
{
RemoveMovingField(x, y + 1);
- Feld[x][y + 1] = EL_QUICKSAND_EMPTY;
- Feld[x][y + 2] = EL_ROCK;
+ Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
+ Tile[x][y + 2] = EL_ROCK;
TEST_DrawLevelField(x, y + 2);
object_hit = TRUE;
}
- if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
+ if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
{
RemoveMovingField(x, y + 1);
- Feld[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
- Feld[x][y + 2] = EL_ROCK;
+ Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
+ Tile[x][y + 2] = EL_ROCK;
TEST_DrawLevelField(x, y + 2);
object_hit = TRUE;
{
ResetGfxAnimation(x, y);
- Feld[x][y] = EL_PEARL_BREAKING;
+ Tile[x][y] = EL_PEARL_BREAKING;
PlayLevelSound(x, y, SND_PEARL_BREAKING);
return;
}
Bang(x, y + 1);
else
{
- Feld[x][y] = EL_AMOEBA_GROWING;
+ Tile[x][y] = EL_AMOEBA_GROWING;
Store[x][y] = EL_AMOEBA_WET;
ResetRandomAnimationValue(x, y);
// activate magic wall / mill
SCAN_PLAYFIELD(xx, yy)
{
- if (Feld[xx][yy] == smashed)
- Feld[xx][yy] = activated_magic_wall;
+ if (Tile[xx][yy] == smashed)
+ Tile[xx][yy] = activated_magic_wall;
}
game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
}
else if (smashed == EL_NUT)
{
- Feld[x][y + 1] = EL_NUT_BREAKING;
+ Tile[x][y + 1] = EL_NUT_BREAKING;
PlayLevelSound(x, y, SND_NUT_BREAKING);
RaiseScoreElement(EL_NUT);
return;
{
ResetGfxAnimation(x, y);
- Feld[x][y + 1] = EL_PEARL_BREAKING;
+ Tile[x][y + 1] = EL_PEARL_BREAKING;
PlayLevelSound(x, y, SND_PEARL_BREAKING);
return;
}
else if (smashed == EL_DIAMOND)
{
- Feld[x][y + 1] = EL_DIAMOND_BREAKING;
+ Tile[x][y + 1] = EL_DIAMOND_BREAKING;
PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
return;
}
// play sound of magic wall / mill
if (!last_line &&
- (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
- Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
- Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
+ (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
+ Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
+ Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
{
- if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
+ if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
- else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
+ else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
- else if (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
+ else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
return;
{ MV_RIGHT, MV_LEFT, MV_UP }
};
- int element = Feld[x][y];
+ int element = Tile[x][y];
int move_pattern = element_info[element].move_pattern;
int old_move_dir = MovDir[x][y];
yy = y + move_xy[MovDir[x][y]].dy;
if (!IN_LEV_FIELD(xx, yy) ||
- (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy])))
+ (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
MovDir[x][y] = old_move_dir;
MovDelay[x][y] = 0;
{
boolean can_move_on =
(MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
- IS_AMOEBOID(Feld[move_x][move_y]) ||
- Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
+ IS_AMOEBOID(Tile[move_x][move_y]) ||
+ Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
if (!can_move_on)
{
boolean can_turn_left =
(MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
- IS_AMOEBOID(Feld[left_x][left_y])));
+ IS_AMOEBOID(Tile[left_x][left_y])));
boolean can_turn_right =
(MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
- IS_AMOEBOID(Feld[right_x][right_y])));
+ IS_AMOEBOID(Tile[right_x][right_y])));
if (can_turn_left && can_turn_right)
MovDir[x][y] = (RND(2) ? left_dir : right_dir);
if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
!SPRING_CAN_ENTER_FIELD(element, x, y + 1))
{
- Feld[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
+ Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
ResetGfxAnimation(move_x, move_y);
TEST_DrawLevelField(move_x, move_y);
{
int attr_x = -1, attr_y = -1;
- if (AllPlayersGone)
+ if (game.all_players_gone)
{
- attr_x = ExitX;
- attr_y = ExitY;
+ attr_x = game.exit_x;
+ attr_y = game.exit_y;
}
else
{
}
}
- if (element == EL_ROBOT && ZX >= 0 && ZY >= 0 &&
- (Feld[ZX][ZY] == EL_ROBOT_WHEEL_ACTIVE ||
+ if (element == EL_ROBOT &&
+ game.robot_wheel_x >= 0 &&
+ game.robot_wheel_y >= 0 &&
+ (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
game.engine_version < VERSION_IDENT(3,1,0,0)))
{
- attr_x = ZX;
- attr_y = ZY;
+ attr_x = game.robot_wheel_x;
+ attr_y = game.robot_wheel_y;
}
if (element == EL_PENGUIN)
int ex = x + xy[i][0];
int ey = y + xy[i][1];
- if (IN_LEV_FIELD(ex, ey) && (Feld[ex][ey] == EL_EXIT_OPEN ||
- Feld[ex][ey] == EL_EM_EXIT_OPEN ||
- Feld[ex][ey] == EL_STEEL_EXIT_OPEN ||
- Feld[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
+ if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
+ Tile[ex][ey] == EL_EM_EXIT_OPEN ||
+ Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
+ Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
{
attr_x = ex;
attr_y = ey;
MovDir[x][y] = MV_NONE;
if (attr_x < x)
- MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
+ MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
else if (attr_x > x)
- MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
+ MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
if (attr_y < y)
- MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
+ MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
else if (attr_y > y)
- MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
+ MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
if (element == EL_ROBOT)
{
element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
- Store[x][y] = Feld[newx][newy];
+ Store[x][y] = Tile[newx][newy];
can_clone = TRUE;
int newx, newy;
boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
- if (AllPlayersGone)
+ if (game.all_players_gone)
{
- attr_x = ExitX;
- attr_y = ExitY;
+ attr_x = game.exit_x;
+ attr_y = game.exit_y;
}
else
{
yy = y + test_xy[start_test + i][1];
if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
- (IS_PLAYER(xx, yy) || Feld[xx][yy] == EL_PLAYER_IS_LEAVING))
+ (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
{
new_move_dir = move_dir;
static void StartMoving(int x, int y)
{
boolean started_moving = FALSE; // some elements can fall _and_ move
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (Stop[x][y])
return;
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_QUICKSAND_EMPTYING;
+ Tile[x][y] = EL_QUICKSAND_EMPTYING;
#if USE_QUICKSAND_BD_ROCK_BUGFIX
if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
Store[x][y] = EL_ROCK;
PlayLevelSoundAction(x, y, ACTION_EMPTYING);
}
- else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
+ else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
{
if (!MovDelay[x][y])
{
return;
}
- Feld[x][y] = EL_QUICKSAND_EMPTY;
- Feld[x][y + 1] = EL_QUICKSAND_FULL;
+ Tile[x][y] = EL_QUICKSAND_EMPTY;
+ Tile[x][y + 1] = EL_QUICKSAND_FULL;
Store[x][y + 1] = Store[x][y];
Store[x][y] = 0;
PlayLevelSoundAction(x, y, ACTION_FILLING);
}
- else if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
+ else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
{
if (!MovDelay[x][y])
{
return;
}
- Feld[x][y] = EL_QUICKSAND_EMPTY;
- Feld[x][y + 1] = EL_QUICKSAND_FAST_FULL;
+ Tile[x][y] = EL_QUICKSAND_EMPTY;
+ Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
Store[x][y + 1] = Store[x][y];
Store[x][y] = 0;
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_QUICKSAND_FAST_EMPTYING;
+ Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
#if USE_QUICKSAND_BD_ROCK_BUGFIX
if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
Store[x][y] = EL_ROCK;
PlayLevelSoundAction(x, y, ACTION_EMPTYING);
}
- else if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
+ else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
{
if (!MovDelay[x][y])
{
return;
}
- Feld[x][y] = EL_QUICKSAND_FAST_EMPTY;
- Feld[x][y + 1] = EL_QUICKSAND_FAST_FULL;
+ Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
+ Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
Store[x][y + 1] = Store[x][y];
Store[x][y] = 0;
PlayLevelSoundAction(x, y, ACTION_FILLING);
}
- else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
+ else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
{
if (!MovDelay[x][y])
{
return;
}
- Feld[x][y] = EL_QUICKSAND_FAST_EMPTY;
- Feld[x][y + 1] = EL_QUICKSAND_FULL;
+ Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
+ Tile[x][y + 1] = EL_QUICKSAND_FULL;
Store[x][y + 1] = Store[x][y];
Store[x][y] = 0;
}
}
else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
- Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
+ Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
{
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_QUICKSAND_FILLING;
+ Tile[x][y] = EL_QUICKSAND_FILLING;
Store[x][y] = element;
PlayLevelSoundAction(x, y, ACTION_FILLING);
}
else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
- Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
+ Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
{
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_QUICKSAND_FAST_FILLING;
+ Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
Store[x][y] = element;
PlayLevelSoundAction(x, y, ACTION_FILLING);
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
+ Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
Store[x][y] = EL_CHANGED(Store[x][y]);
}
- else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
+ else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
{
if (!MovDelay[x][y])
MovDelay[x][y] = TILEY / 4 + 1;
return;
}
- Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
- Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
+ Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
+ Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
Store[x][y + 1] = EL_CHANGED(Store[x][y]);
Store[x][y] = 0;
}
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
+ Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
Store[x][y] = EL_CHANGED_BD(Store[x][y]);
}
- else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
+ else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
{
if (!MovDelay[x][y])
MovDelay[x][y] = TILEY / 4 + 1;
return;
}
- Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
- Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
+ Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
+ Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
Store[x][y] = 0;
}
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
+ Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
Store[x][y] = EL_CHANGED_DC(Store[x][y]);
}
- else if (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
+ else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
{
if (!MovDelay[x][y])
MovDelay[x][y] = TILEY / 4 + 1;
return;
}
- Feld[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
- Feld[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
+ Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
+ Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
Store[x][y] = 0;
}
}
else if ((CAN_PASS_MAGIC_WALL(element) &&
- (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
- Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
+ (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
+ Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
(CAN_PASS_DC_MAGIC_WALL(element) &&
- (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
+ (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
{
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
- Feld[x][y] =
- (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
- Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
+ Tile[x][y] =
+ (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
+ Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
EL_DC_MAGIC_WALL_FILLING);
Store[x][y] = element;
}
- else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
+ else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
{
SplashAcid(x, y + 1);
CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
(game.engine_version >= VERSION_IDENT(3,0,7,0) &&
CAN_FALL(element) && WasJustFalling[x][y] &&
- (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
+ (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
(game.engine_version < VERSION_IDENT(2,2,0,7) &&
CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
- (Feld[x][y + 1] == EL_BLOCKED)))
+ (Tile[x][y + 1] == EL_BLOCKED)))
{
/* this is needed for a special case not covered by calling "Impact()"
from "ContinueMoving()": if an element moves to a tile directly below
started_moving = TRUE;
}
}
- else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
+ else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
{
if (WasJustFalling[x][y]) // prevent animation from being restarted
MovDir[x][y] = MV_DOWN;
}
else if (element == EL_AMOEBA_DROP)
{
- Feld[x][y] = EL_AMOEBA_GROWING;
+ Tile[x][y] = EL_AMOEBA_GROWING;
Store[x][y] = EL_AMOEBA_WET;
}
- else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
- (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
+ else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
+ (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
!IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
{
boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
(IS_FREE(x - 1, y + 1) ||
- Feld[x - 1][y + 1] == EL_ACID));
+ Tile[x - 1][y + 1] == EL_ACID));
boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
(IS_FREE(x + 1, y + 1) ||
- Feld[x + 1][y + 1] == EL_ACID));
+ Tile[x + 1][y + 1] == EL_ACID));
boolean can_fall_any = (can_fall_left || can_fall_right);
boolean can_fall_both = (can_fall_left && can_fall_right);
- int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
+ int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
{
started_moving = TRUE;
}
}
- else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
+ else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
{
boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
- int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
+ int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
int belt_dir = game.belt_dir[belt_nr];
if ((belt_dir == MV_LEFT && left_is_free) ||
TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
- if (Feld[x][y] != element) // element has changed
+ if (Tile[x][y] != element) // element has changed
return;
}
int sy = SCREENY(yy);
int flame_graphic = graphic + (i - 1);
- if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
+ if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
break;
if (MovDelay[x][y])
ChangeDelay[xx][yy] = 0;
- Feld[xx][yy] = EL_FLAMES;
+ Tile[xx][yy] = EL_FLAMES;
if (IN_SCR_FIELD(sx, sy))
{
}
else
{
- if (Feld[xx][yy] == EL_FLAMES)
- Feld[xx][yy] = EL_EMPTY;
+ if (Tile[xx][yy] == EL_FLAMES)
+ Tile[xx][yy] = EL_EMPTY;
TEST_DrawLevelField(xx, yy);
}
}
}
else if (CAN_MOVE_INTO_ACID(element) &&
- IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID &&
+ IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
!IS_MV_DIAGONAL(MovDir[x][y]) &&
(MovDir[x][y] == MV_DOWN ||
game.engine_version >= VERSION_IDENT(3,1,0,0)))
}
else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
{
- if (Feld[newx][newy] == EL_EXIT_OPEN ||
- Feld[newx][newy] == EL_EM_EXIT_OPEN ||
- Feld[newx][newy] == EL_STEEL_EXIT_OPEN ||
- Feld[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
+ if (Tile[newx][newy] == EL_EXIT_OPEN ||
+ Tile[newx][newy] == EL_EM_EXIT_OPEN ||
+ Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
+ Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
{
RemoveField(x, y);
TEST_DrawLevelField(x, y);
if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
- local_player->friends_still_needed--;
- if (!local_player->friends_still_needed &&
- !local_player->GameOver && AllPlayersGone)
+ game.friends_still_needed--;
+ if (!game.friends_still_needed &&
+ !game.GameOver &&
+ game.all_players_gone)
LevelSolved();
return;
}
- else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
+ else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
{
if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
TEST_DrawLevelField(newx, newy);
}
else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
{
- if (IS_FOOD_PIG(Feld[newx][newy]))
+ if (IS_FOOD_PIG(Tile[newx][newy]))
{
if (IS_MOVING(newx, newy))
RemoveMovingField(newx, newy);
else
{
- Feld[newx][newy] = EL_EMPTY;
+ Tile[newx][newy] = EL_EMPTY;
TEST_DrawLevelField(newx, newy);
}
// check if element to clone is still there
for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
{
- if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == Store[x][y])
+ if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
{
can_clone = TRUE;
DrawLevelGraphicAnimation(x, y, graphic);
PlayLevelSoundAction(x, y, ACTION_SHRINKING);
- if (Feld[newx][newy] == EL_ACID)
+ if (Tile[newx][newy] == EL_ACID)
{
SplashAcid(newx, newy);
}
else
{
- Feld[newx][newy] = EL_EMPTY;
+ Tile[newx][newy] = EL_EMPTY;
TEST_DrawLevelField(newx, newy);
PlayLevelSoundAction(x, y, ACTION_DIGGING);
MovDelay[x][y] = 50;
- Feld[newx][newy] = EL_FLAMES;
- if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
- Feld[newx1][newy1] = EL_FLAMES;
- if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
- Feld[newx2][newy2] = EL_FLAMES;
+ Tile[newx][newy] = EL_FLAMES;
+ if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
+ Tile[newx1][newy1] = EL_FLAMES;
+ if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
+ Tile[newx2][newy2] = EL_FLAMES;
return;
}
}
}
else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
- Feld[newx][newy] == EL_DIAMOND)
+ Tile[newx][newy] == EL_DIAMOND)
{
if (IS_MOVING(newx, newy))
RemoveMovingField(newx, newy);
else
{
- Feld[newx][newy] = EL_EMPTY;
+ Tile[newx][newy] = EL_EMPTY;
TEST_DrawLevelField(newx, newy);
}
PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
}
else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
- IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
+ IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
{
if (AmoebaNr[newx][newy])
{
AmoebaCnt2[AmoebaNr[newx][newy]]--;
- if (Feld[newx][newy] == EL_AMOEBA_FULL ||
- Feld[newx][newy] == EL_BD_AMOEBA)
+ if (Tile[newx][newy] == EL_AMOEBA_FULL ||
+ Tile[newx][newy] == EL_BD_AMOEBA)
AmoebaCnt[AmoebaNr[newx][newy]]--;
}
}
else
{
- Feld[newx][newy] = EL_EMPTY;
+ Tile[newx][newy] = EL_EMPTY;
TEST_DrawLevelField(newx, newy);
}
PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
}
else if ((element == EL_PACMAN || element == EL_MOLE)
- && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
+ && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
{
if (AmoebaNr[newx][newy])
{
AmoebaCnt2[AmoebaNr[newx][newy]]--;
- if (Feld[newx][newy] == EL_AMOEBA_FULL ||
- Feld[newx][newy] == EL_BD_AMOEBA)
+ if (Tile[newx][newy] == EL_AMOEBA_FULL ||
+ Tile[newx][newy] == EL_BD_AMOEBA)
AmoebaCnt[AmoebaNr[newx][newy]]--;
}
if (element == EL_MOLE)
{
- Feld[newx][newy] = EL_AMOEBA_SHRINKING;
+ Tile[newx][newy] = EL_AMOEBA_SHRINKING;
PlayLevelSound(x, y, SND_MOLE_DIGGING);
ResetGfxAnimation(x, y);
}
else // element == EL_PACMAN
{
- Feld[newx][newy] = EL_EMPTY;
+ Tile[newx][newy] = EL_EMPTY;
TEST_DrawLevelField(newx, newy);
PlayLevelSound(x, y, SND_PACMAN_DIGGING);
}
}
else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
- (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
- (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
+ (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
+ (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
{
// wait for shrinking amoeba to completely disappear
return;
void ContinueMoving(int x, int y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
struct ElementInfo *ei = &element_info[element];
int direction = MovDir[x][y];
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
// element reached destination field
- Feld[x][y] = EL_EMPTY;
- Feld[newx][newy] = element;
+ Tile[x][y] = EL_EMPTY;
+ Tile[newx][newy] = element;
MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
if (Store[x][y] == EL_ACID) // element is moving into acid pool
{
- element = Feld[newx][newy] = EL_ACID;
+ element = Tile[newx][newy] = EL_ACID;
}
else if (element == EL_MOLE)
{
- Feld[x][y] = EL_SAND;
+ Tile[x][y] = EL_SAND;
TEST_DrawLevelFieldCrumbledNeighbours(x, y);
}
else if (element == EL_QUICKSAND_FILLING)
{
- element = Feld[newx][newy] = get_next_element(element);
+ element = Tile[newx][newy] = get_next_element(element);
Store[newx][newy] = Store[x][y];
}
else if (element == EL_QUICKSAND_EMPTYING)
{
- Feld[x][y] = get_next_element(element);
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = get_next_element(element);
+ element = Tile[newx][newy] = Store[x][y];
}
else if (element == EL_QUICKSAND_FAST_FILLING)
{
- element = Feld[newx][newy] = get_next_element(element);
+ element = Tile[newx][newy] = get_next_element(element);
Store[newx][newy] = Store[x][y];
}
else if (element == EL_QUICKSAND_FAST_EMPTYING)
{
- Feld[x][y] = get_next_element(element);
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = get_next_element(element);
+ element = Tile[newx][newy] = Store[x][y];
}
else if (element == EL_MAGIC_WALL_FILLING)
{
- element = Feld[newx][newy] = get_next_element(element);
+ element = Tile[newx][newy] = get_next_element(element);
if (!game.magic_wall_active)
- element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
Store[newx][newy] = Store[x][y];
}
else if (element == EL_MAGIC_WALL_EMPTYING)
{
- Feld[x][y] = get_next_element(element);
+ Tile[x][y] = get_next_element(element);
if (!game.magic_wall_active)
- Feld[x][y] = EL_MAGIC_WALL_DEAD;
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = EL_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = Store[x][y];
InitField(newx, newy, FALSE);
}
else if (element == EL_BD_MAGIC_WALL_FILLING)
{
- element = Feld[newx][newy] = get_next_element(element);
+ element = Tile[newx][newy] = get_next_element(element);
if (!game.magic_wall_active)
- element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
Store[newx][newy] = Store[x][y];
}
else if (element == EL_BD_MAGIC_WALL_EMPTYING)
{
- Feld[x][y] = get_next_element(element);
+ Tile[x][y] = get_next_element(element);
if (!game.magic_wall_active)
- Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = Store[x][y];
InitField(newx, newy, FALSE);
}
else if (element == EL_DC_MAGIC_WALL_FILLING)
{
- element = Feld[newx][newy] = get_next_element(element);
+ element = Tile[newx][newy] = get_next_element(element);
if (!game.magic_wall_active)
- element = Feld[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
Store[newx][newy] = Store[x][y];
}
else if (element == EL_DC_MAGIC_WALL_EMPTYING)
{
- Feld[x][y] = get_next_element(element);
+ Tile[x][y] = get_next_element(element);
if (!game.magic_wall_active)
- Feld[x][y] = EL_DC_MAGIC_WALL_DEAD;
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
+ element = Tile[newx][newy] = Store[x][y];
InitField(newx, newy, FALSE);
}
else if (element == EL_AMOEBA_DROPPING)
{
- Feld[x][y] = get_next_element(element);
- element = Feld[newx][newy] = Store[x][y];
+ Tile[x][y] = get_next_element(element);
+ element = Tile[newx][newy] = Store[x][y];
}
else if (element == EL_SOKOBAN_OBJECT)
{
if (Back[x][y])
- Feld[x][y] = Back[x][y];
+ Tile[x][y] = Back[x][y];
if (Back[newx][newy])
- Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
+ Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
Back[x][y] = Back[newx][newy] = 0;
}
if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
- Feld[x][y] = move_leave_element;
+ Tile[x][y] = move_leave_element;
- if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
+ if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
MovDir[x][y] = direction;
InitField(x, y, FALSE);
- if (GFX_CRUMBLED(Feld[x][y]))
+ if (GFX_CRUMBLED(Tile[x][y]))
TEST_DrawLevelFieldCrumbledNeighbours(x, y);
if (ELEM_IS_PLAYER(move_leave_element))
MV_DIR_OPPOSITE(direction));
}
-int AmoebeNachbarNr(int ax, int ay)
+int AmoebaNeighbourNr(int ax, int ay)
{
int i;
- int element = Feld[ax][ay];
+ int element = Tile[ax][ay];
int group_nr = 0;
static int xy[4][2] =
{
if (!IN_LEV_FIELD(x, y))
continue;
- if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
+ if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
group_nr = AmoebaNr[x][y];
}
return group_nr;
}
-static void AmoebenVereinigen(int ax, int ay)
+static void AmoebaMerge(int ax, int ay)
{
int i, x, y, xx, yy;
int new_group_nr = AmoebaNr[ax][ay];
if (!IN_LEV_FIELD(x, y))
continue;
- if ((Feld[x][y] == EL_AMOEBA_FULL ||
- Feld[x][y] == EL_BD_AMOEBA ||
- Feld[x][y] == EL_AMOEBA_DEAD) &&
+ if ((Tile[x][y] == EL_AMOEBA_FULL ||
+ Tile[x][y] == EL_BD_AMOEBA ||
+ Tile[x][y] == EL_AMOEBA_DEAD) &&
AmoebaNr[x][y] != new_group_nr)
{
int old_group_nr = AmoebaNr[x][y];
}
}
-void AmoebeUmwandeln(int ax, int ay)
+void AmoebaToDiamond(int ax, int ay)
{
int i, x, y;
- if (Feld[ax][ay] == EL_AMOEBA_DEAD)
+ if (Tile[ax][ay] == EL_AMOEBA_DEAD)
{
int group_nr = AmoebaNr[ax][ay];
#ifdef DEBUG
if (group_nr == 0)
{
- printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
- printf("AmoebeUmwandeln(): This should never happen!\n");
+ Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
+ Debug("game:playing:AmoebaToDiamond", "This should never happen!");
+
return;
}
#endif
SCAN_PLAYFIELD(x, y)
{
- if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
+ if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
{
AmoebaNr[x][y] = 0;
- Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
+ Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
}
}
if (!IN_LEV_FIELD(x, y))
continue;
- if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
+ if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
{
PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
SND_AMOEBA_TURNING_TO_GEM :
}
}
-static void AmoebeUmwandelnBD(int ax, int ay, int new_element)
+static void AmoebaToDiamondBD(int ax, int ay, int new_element)
{
int x, y;
int group_nr = AmoebaNr[ax][ay];
#ifdef DEBUG
if (group_nr == 0)
{
- printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
- printf("AmoebeUmwandelnBD(): This should never happen!\n");
+ Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
+ Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
+
return;
}
#endif
SCAN_PLAYFIELD(x, y)
{
if (AmoebaNr[x][y] == group_nr &&
- (Feld[x][y] == EL_AMOEBA_DEAD ||
- Feld[x][y] == EL_BD_AMOEBA ||
- Feld[x][y] == EL_AMOEBA_GROWING))
+ (Tile[x][y] == EL_AMOEBA_DEAD ||
+ Tile[x][y] == EL_BD_AMOEBA ||
+ Tile[x][y] == EL_AMOEBA_GROWING))
{
AmoebaNr[x][y] = 0;
- Feld[x][y] = new_element;
+ Tile[x][y] = new_element;
InitField(x, y, FALSE);
TEST_DrawLevelField(x, y);
done = TRUE;
SND_BD_AMOEBA_TURNING_TO_GEM));
}
-static void AmoebeWaechst(int x, int y)
+static void AmoebaGrowing(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
if (!MovDelay[x][y])
{
- Feld[x][y] = Store[x][y];
+ Tile[x][y] = Store[x][y];
Store[x][y] = 0;
TEST_DrawLevelField(x, y);
}
}
}
-static void AmoebaDisappearing(int x, int y)
+static void AmoebaShrinking(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
if (!MovDelay[x][y])
{
- Feld[x][y] = EL_EMPTY;
+ Tile[x][y] = EL_EMPTY;
TEST_DrawLevelField(x, y);
// don't let mole enter this field in this cycle;
}
}
-static void AmoebeAbleger(int ax, int ay)
+static void AmoebaReproduce(int ax, int ay)
{
int i;
- int element = Feld[ax][ay];
+ int element = Tile[ax][ay];
int graphic = el2img(element);
int newax = ax, neway = ay;
boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
{
- Feld[ax][ay] = EL_AMOEBA_DEAD;
+ Tile[ax][ay] = EL_AMOEBA_DEAD;
TEST_DrawLevelField(ax, ay);
return;
}
return;
if (IS_FREE(x, y) ||
- CAN_GROW_INTO(Feld[x][y]) ||
- Feld[x][y] == EL_QUICKSAND_EMPTY ||
- Feld[x][y] == EL_QUICKSAND_FAST_EMPTY)
+ CAN_GROW_INTO(Tile[x][y]) ||
+ Tile[x][y] == EL_QUICKSAND_EMPTY ||
+ Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
{
newax = x;
neway = y;
continue;
if (IS_FREE(x, y) ||
- CAN_GROW_INTO(Feld[x][y]) ||
- Feld[x][y] == EL_QUICKSAND_EMPTY ||
- Feld[x][y] == EL_QUICKSAND_FAST_EMPTY)
+ CAN_GROW_INTO(Tile[x][y]) ||
+ Tile[x][y] == EL_QUICKSAND_EMPTY ||
+ Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
{
newax = x;
neway = y;
{
if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
{
- Feld[ax][ay] = EL_AMOEBA_DEAD;
+ Tile[ax][ay] = EL_AMOEBA_DEAD;
TEST_DrawLevelField(ax, ay);
AmoebaCnt[AmoebaNr[ax][ay]]--;
if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
{
if (element == EL_AMOEBA_FULL)
- AmoebeUmwandeln(ax, ay);
+ AmoebaToDiamond(ax, ay);
else if (element == EL_BD_AMOEBA)
- AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
+ AmoebaToDiamondBD(ax, ay, level.amoeba_content);
}
}
return;
#ifdef DEBUG
if (new_group_nr == 0)
{
- printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
- printf("AmoebeAbleger(): This should never happen!\n");
+ Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
+ newax, neway);
+ Debug("game:playing:AmoebaReproduce", "This should never happen!");
+
return;
}
#endif
AmoebaCnt2[new_group_nr]++;
// if amoeba touches other amoeba(s) after growing, unify them
- AmoebenVereinigen(newax, neway);
+ AmoebaMerge(newax, neway);
if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
{
- AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
+ AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
return;
}
}
if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
(neway == lev_fieldy - 1 && newax != ax))
{
- Feld[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
+ Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
Store[newax][neway] = element;
}
else if (neway == ay || element == EL_EMC_DRIPPER)
{
- Feld[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
+ Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
PlayLevelSoundAction(newax, neway, ACTION_GROWING);
}
else
{
InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
- Feld[ax][ay] = EL_AMOEBA_DROPPING;
+ Tile[ax][ay] = EL_AMOEBA_DROPPING;
Store[ax][ay] = EL_AMOEBA_DROP;
ContinueMoving(ax, ay);
return;
{
int x1, y1, x2, y2;
int life_time = 40;
- int element = Feld[ax][ay];
+ int element = Tile[ax][ay];
int graphic = el2img(element);
int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
level.biomaze);
for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
{
int xx = ax+x1, yy = ay+y1;
- int old_element = Feld[xx][yy];
+ int old_element = Tile[xx][yy];
int num_neighbours = 0;
if (!IN_LEV_FIELD(xx, yy))
if (level.use_life_bugs)
is_neighbour =
- (((Feld[x][y] == element || is_player_cell) && !Stop[x][y]) ||
+ (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
(IS_FREE(x, y) && Stop[x][y]));
else
is_neighbour =
if (num_neighbours < life_parameter[0] ||
num_neighbours > life_parameter[1])
{
- Feld[xx][yy] = EL_EMPTY;
- if (Feld[xx][yy] != old_element)
+ Tile[xx][yy] = EL_EMPTY;
+ if (Tile[xx][yy] != old_element)
TEST_DrawLevelField(xx, yy);
Stop[xx][yy] = TRUE;
changed = TRUE;
}
}
- else if (is_free || CAN_GROW_INTO(Feld[xx][yy]))
+ else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
{ // free border field
if (num_neighbours >= life_parameter[2] &&
num_neighbours <= life_parameter[3])
{
- Feld[xx][yy] = element;
+ Tile[xx][yy] = element;
MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
- if (Feld[xx][yy] != old_element)
+ if (Tile[xx][yy] != old_element)
TEST_DrawLevelField(xx, yy);
Stop[xx][yy] = TRUE;
changed = TRUE;
static void StopRobotWheel(int x, int y)
{
- if (ZX == x && ZY == y)
+ if (game.robot_wheel_x == x &&
+ game.robot_wheel_y == y)
{
- ZX = ZY = -1;
-
+ game.robot_wheel_x = -1;
+ game.robot_wheel_y = -1;
game.robot_wheel_active = FALSE;
}
}
x = bx - 1 + xx;
y = by - 1 + yy;
- if (IN_LEV_FIELD(x, y) && Feld[x][y] == EL_EMPTY)
+ if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
}
else
int xx = x - bx + 1;
int yy = y - by + 1;
- if (IN_LEV_FIELD(x, y) && Feld[x][y] == EL_EMPTY)
+ if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
}
}
static void CheckExit(int x, int y)
{
- if (local_player->gems_still_needed > 0 ||
- local_player->sokoban_fields_still_needed > 0 ||
- local_player->sokoban_objects_still_needed > 0 ||
- local_player->lights_still_needed > 0)
+ if (game.gems_still_needed > 0 ||
+ game.sokoban_fields_still_needed > 0 ||
+ game.sokoban_objects_still_needed > 0 ||
+ game.lights_still_needed > 0)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el2img(element);
if (IS_ANIMATED(graphic))
return;
}
- if (AllPlayersGone) // do not re-open exit door closed after last player
+ // do not re-open exit door closed after last player
+ if (game.all_players_gone)
return;
- Feld[x][y] = EL_EXIT_OPENING;
+ Tile[x][y] = EL_EXIT_OPENING;
PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
}
static void CheckExitEM(int x, int y)
{
- if (local_player->gems_still_needed > 0 ||
- local_player->sokoban_fields_still_needed > 0 ||
- local_player->sokoban_objects_still_needed > 0 ||
- local_player->lights_still_needed > 0)
+ if (game.gems_still_needed > 0 ||
+ game.sokoban_fields_still_needed > 0 ||
+ game.sokoban_objects_still_needed > 0 ||
+ game.lights_still_needed > 0)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el2img(element);
if (IS_ANIMATED(graphic))
return;
}
- if (AllPlayersGone) // do not re-open exit door closed after last player
+ // do not re-open exit door closed after last player
+ if (game.all_players_gone)
return;
- Feld[x][y] = EL_EM_EXIT_OPENING;
+ Tile[x][y] = EL_EM_EXIT_OPENING;
PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
}
static void CheckExitSteel(int x, int y)
{
- if (local_player->gems_still_needed > 0 ||
- local_player->sokoban_fields_still_needed > 0 ||
- local_player->sokoban_objects_still_needed > 0 ||
- local_player->lights_still_needed > 0)
+ if (game.gems_still_needed > 0 ||
+ game.sokoban_fields_still_needed > 0 ||
+ game.sokoban_objects_still_needed > 0 ||
+ game.lights_still_needed > 0)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el2img(element);
if (IS_ANIMATED(graphic))
return;
}
- if (AllPlayersGone) // do not re-open exit door closed after last player
+ // do not re-open exit door closed after last player
+ if (game.all_players_gone)
return;
- Feld[x][y] = EL_STEEL_EXIT_OPENING;
+ Tile[x][y] = EL_STEEL_EXIT_OPENING;
PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
}
static void CheckExitSteelEM(int x, int y)
{
- if (local_player->gems_still_needed > 0 ||
- local_player->sokoban_fields_still_needed > 0 ||
- local_player->sokoban_objects_still_needed > 0 ||
- local_player->lights_still_needed > 0)
+ if (game.gems_still_needed > 0 ||
+ game.sokoban_fields_still_needed > 0 ||
+ game.sokoban_objects_still_needed > 0 ||
+ game.lights_still_needed > 0)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el2img(element);
if (IS_ANIMATED(graphic))
return;
}
- if (AllPlayersGone) // do not re-open exit door closed after last player
+ // do not re-open exit door closed after last player
+ if (game.all_players_gone)
return;
- Feld[x][y] = EL_EM_STEEL_EXIT_OPENING;
+ Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
}
static void CheckExitSP(int x, int y)
{
- if (local_player->gems_still_needed > 0)
+ if (game.gems_still_needed > 0)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int graphic = el2img(element);
if (IS_ANIMATED(graphic))
return;
}
- if (AllPlayersGone) // do not re-open exit door closed after last player
+ // do not re-open exit door closed after last player
+ if (game.all_players_gone)
return;
- Feld[x][y] = EL_SP_EXIT_OPENING;
+ Tile[x][y] = EL_SP_EXIT_OPENING;
PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
}
SCAN_PLAYFIELD(x, y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
{
- Feld[x][y] = EL_TIMEGATE_CLOSING;
+ Tile[x][y] = EL_TIMEGATE_CLOSING;
PlayLevelSoundAction(x, y, ACTION_CLOSING);
}
if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
return;
- if (Feld[x][y] == EL_BD_DIAMOND)
+ if (Tile[x][y] == EL_BD_DIAMOND)
return;
if (MovDelay[x][y] == 0) // next animation frame
{
MovDelay[x][y]--;
- DrawLevelElementAnimation(x, y, Feld[x][y]);
+ DrawLevelElementAnimation(x, y, Tile[x][y]);
if (MovDelay[x][y] != 0)
{
if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
{
- int graphic = el_dir2img(Feld[x][y], GfxDir[x][y]);
+ int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
{
if (MovDir[x][y] == MV_LEFT)
{
- if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
+ if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
TEST_DrawLevelField(x - 1, y);
}
else if (MovDir[x][y] == MV_RIGHT)
{
- if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
+ if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
TEST_DrawLevelField(x + 1, y);
}
else if (MovDir[x][y] == MV_UP)
{
- if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
+ if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
TEST_DrawLevelField(x, y - 1);
}
else
{
- if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
+ if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
TEST_DrawLevelField(x, y + 1);
}
- Feld[x][y] = Store[x][y];
+ Tile[x][y] = Store[x][y];
Store[x][y] = 0;
GfxDir[x][y] = MovDir[x][y] = MV_NONE;
TEST_DrawLevelField(x, y);
static void MauerAbleger(int ax, int ay)
{
- int element = Feld[ax][ay];
+ int element = Tile[ax][ay];
int graphic = el2img(element);
boolean oben_frei = FALSE, unten_frei = FALSE;
boolean links_frei = FALSE, rechts_frei = FALSE;
{
if (oben_frei)
{
- Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
+ Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
Store[ax][ay-1] = element;
GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
}
if (unten_frei)
{
- Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
+ Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
Store[ax][ay+1] = element;
GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
{
if (links_frei)
{
- Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
+ Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
Store[ax-1][ay] = element;
GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
if (rechts_frei)
{
- Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
+ Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
Store[ax+1][ay] = element;
GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
TEST_DrawLevelField(ax, ay);
- if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
+ if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
oben_massiv = TRUE;
- if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
+ if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
unten_massiv = TRUE;
- if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
+ if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
links_massiv = TRUE;
- if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
+ if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
rechts_massiv = TRUE;
if (((oben_massiv && unten_massiv) ||
element == EL_EXPANDABLE_WALL) &&
((links_massiv && rechts_massiv) ||
element == EL_EXPANDABLE_WALL_VERTICAL))
- Feld[ax][ay] = EL_WALL;
+ Tile[ax][ay] = EL_WALL;
if (new_wall)
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
static void MauerAblegerStahl(int ax, int ay)
{
- int element = Feld[ax][ay];
+ int element = Tile[ax][ay];
int graphic = el2img(element);
boolean oben_frei = FALSE, unten_frei = FALSE;
boolean links_frei = FALSE, rechts_frei = FALSE;
{
if (oben_frei)
{
- Feld[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
+ Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
Store[ax][ay-1] = element;
GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
}
if (unten_frei)
{
- Feld[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
+ Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
Store[ax][ay+1] = element;
GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
{
if (links_frei)
{
- Feld[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
+ Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
Store[ax-1][ay] = element;
GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
if (rechts_frei)
{
- Feld[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
+ Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
Store[ax+1][ay] = element;
GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
}
}
- if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
+ if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
oben_massiv = TRUE;
- if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
+ if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
unten_massiv = TRUE;
- if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
+ if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
links_massiv = TRUE;
- if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
+ if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
rechts_massiv = TRUE;
if (((oben_massiv && unten_massiv) ||
element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
((links_massiv && rechts_massiv) ||
element == EL_EXPANDABLE_STEELWALL_VERTICAL))
- Feld[ax][ay] = EL_STEELWALL;
+ Tile[ax][ay] = EL_STEELWALL;
if (new_wall)
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
if (IN_LEV_FIELD(xx, yy) &&
- (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
+ (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
{
- if (Feld[xx][yy] == EL_DRAGON)
+ if (Tile[xx][yy] == EL_DRAGON)
dragon_found = TRUE;
}
else
{
int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
- if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
+ if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
{
- Feld[xx][yy] = EL_EMPTY;
+ Tile[xx][yy] = EL_EMPTY;
TEST_DrawLevelField(xx, yy);
}
else
static void InitBuggyBase(int x, int y)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
int activating_delay = FRAMES_PER_SECOND / 4;
ChangeDelay[x][y] =
action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
- action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? local_player->gems_still_needed :
- action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? local_player->score :
+ action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
+ action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
-1);
int action_arg_number_old =
- (action_type == CA_SET_LEVEL_GEMS ? local_player->gems_still_needed :
+ (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
action_type == CA_SET_LEVEL_TIME ? TimeLeft :
- action_type == CA_SET_LEVEL_SCORE ? local_player->score :
+ action_type == CA_SET_LEVEL_SCORE ? game.score :
action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
action_type == CA_SET_CE_SCORE ? ei->collect_score :
0);
case CA_SET_LEVEL_SCORE:
{
- local_player->score = action_arg_number_new;
+ game.score = action_arg_number_new;
- game_panel_controls[GAME_PANEL_SCORE].value = local_player->score;
+ game_panel_controls[GAME_PANEL_SCORE].value = game.score;
DisplayGameControlValues();
case CA_SET_LEVEL_GEMS:
{
- local_player->gems_still_needed = action_arg_number_new;
+ game.gems_still_needed = action_arg_number_new;
game.snapshot.collected_item = TRUE;
- game_panel_controls[GAME_PANEL_GEMS].value =
- local_player->gems_still_needed;
+ game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
DisplayGameControlValues();
// ---------- player actions ---------------------------------------------
case CA_MOVE_PLAYER:
+ case CA_MOVE_PLAYER_NEW:
{
// automatically move to the next field in specified direction
for (i = 0; i < MAX_PLAYERS; i++)
if (trigger_player_bits & (1 << i))
- stored_player[i].programmed_action = action_arg_direction;
+ if (action_type == CA_MOVE_PLAYER ||
+ stored_player[i].MovPos == 0)
+ stored_player[i].programmed_action = action_arg_direction;
break;
}
if (action_arg_player_bits & (1 << i))
ExitPlayer(&stored_player[i]);
- if (AllPlayersGone)
+ if (game.players_still_needed == 0)
LevelSolved();
break;
if (CustomValue[x][y] == 0)
{
+ // reset change counter (else CE_VALUE_GETS_ZERO would not work)
+ ChangeCount[x][y] = 0; // allow at least one more change
+
CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
}
{
int xx, yy;
+ // reset change counter (else CE_SCORE_GETS_ZERO would not work)
+ ChangeCount[x][y] = 0; // allow at least one more change
+
CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
*/
SCAN_PLAYFIELD(xx, yy)
{
- if (Feld[xx][yy] == element)
+ if (Tile[xx][yy] == element)
CheckElementChange(xx, yy, element, EL_UNDEFINED,
CE_SCORE_GETS_ZERO);
}
SCAN_PLAYFIELD(xx, yy)
{
- if (Feld[xx][yy] == element)
+ if (Tile[xx][yy] == element)
{
if (reset_frame)
{
static void CreateFieldExt(int x, int y, int element, boolean is_change)
{
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
int new_element = GetElementFromGroupElement(element);
int previous_move_direction = MovDir[x][y];
int last_ce_value = CustomValue[x][y];
else
RemoveField(x, y);
- Feld[x][y] = new_element;
+ Tile[x][y] = new_element;
if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
MovDir[x][y] = previous_move_direction;
InitField_WithBug1(x, y, FALSE);
- new_element = Feld[x][y]; // element may have changed
+ new_element = Tile[x][y]; // element may have changed
ResetGfxAnimation(x, y);
ResetRandomAnimationValue(x, y);
if (game.engine_version >= VERSION_IDENT(3,2,0,7))
{
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
// prevent changed element from moving in same engine frame
// unless both old and new element can either fall or move
int ce_value = CustomValue[x][y];
int ce_score = ei->collect_score;
int target_element;
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
// always use default change event to prevent running into a loop
if (ChangeEvent[x][y] == -1)
continue;
}
- e = Feld[ex][ey];
+ e = Tile[ex][ey];
if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
e = MovingOrBlocked2Element(ex, ey);
if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
!CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
{
- printf("\n\n");
- printf("HandleElementChange(): %d,%d: element = %d ('%s')\n",
- x, y, element, element_info[element].token_name);
- printf("HandleElementChange(): This should never happen!\n");
- printf("\n\n");
+ Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
+ x, y, element, element_info[element].token_name);
+ Debug("game:playing:HandleElementChange", "This should never happen!");
}
#endif
SCAN_PLAYFIELD(x, y)
{
- if (Feld[x][y] == element)
+ if (Tile[x][y] == element)
{
if (change->can_change && !change_done)
{
!HAS_ANY_CHANGE_EVENT(element, trigger_event))
return FALSE;
- if (Feld[x][y] == EL_BLOCKED)
+ if (Tile[x][y] == EL_BLOCKED)
{
Blocked2Moving(x, y, &x, &y);
- element = Feld[x][y];
+ element = Tile[x][y];
}
// check if element has already changed or is about to change after moving
if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
- Feld[x][y] != element) ||
+ Tile[x][y] != element) ||
(game.engine_version >= VERSION_IDENT(3,2,0,7) &&
(ChangeCount[x][y] >= game.max_num_changes_per_frame ||
// special case for sleeping Murphy when leaning against non-free tile
if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
- (Feld[player->jx - 1][player->jy] != EL_EMPTY &&
+ (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
!IS_MOVING(player->jx - 1, player->jy)))
move_dir = MV_LEFT;
else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
- (Feld[player->jx + 1][player->jy] != EL_EMPTY &&
+ (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
!IS_MOVING(player->jx + 1, player->jy)))
move_dir = MV_RIGHT;
else
if (!player->is_dropping)
player->was_dropping = FALSE;
}
+
+ static struct MouseActionInfo mouse_action_last = { 0 };
+ struct MouseActionInfo mouse_action = player->effective_mouse_action;
+ boolean new_released = (!mouse_action.button && mouse_action_last.button);
+
+ if (new_released)
+ CheckSaveEngineSnapshotToList();
+
+ mouse_action_last = mouse_action;
}
static void CheckSingleStepMode(struct PlayerInfo *player)
{
if (tape.single_step && tape.recording && !tape.pausing)
{
- /* as it is called "single step mode", just return to pause mode when the
- player stopped moving after one tile (or never starts moving at all) */
- if (!player->is_moving &&
- !player->is_pushing &&
- !player->is_dropping_pressed)
- {
- TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
- SnapField(player, 0, 0); // stop snapping
- }
+ // as it is called "single step mode", just return to pause mode when the
+ // player stopped moving after one tile (or never starts moving at all)
+ // (reverse logic needed here in case single step mode used in team mode)
+ if (player->is_moving ||
+ player->is_pushing ||
+ player->is_dropping_pressed ||
+ player->effective_mouse_action.button)
+ game.enter_single_step_mode = FALSE;
}
CheckSaveEngineSnapshot(player);
static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
byte *tape_action)
{
- if (!tape.use_mouse)
+ if (!tape.use_mouse_actions)
return;
mouse_action->lx = tape_action[TAPE_ACTION_LX];
static void SetTapeActionFromMouseAction(byte *tape_action,
struct MouseActionInfo *mouse_action)
{
- if (!tape.use_mouse)
+ if (!tape.use_mouse_actions)
return;
tape_action[TAPE_ACTION_LX] = mouse_action->lx;
game_em.game_over = TRUE;
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
if (game_em.game_over) // game lost
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
{
game_sp.game_over = TRUE;
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
if (game_sp.game_over) // game lost
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
{
game_mm.game_over = TRUE;
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
if (game_mm.game_over) // game lost
- AllPlayersGone = TRUE;
+ game.all_players_gone = TRUE;
}
}
if (!TimeLeft && setup.time_limit)
{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- level.native_em_level->lev->killed_out_of_time = TRUE;
+ game_em.lev->killed_out_of_time = TRUE;
else
for (i = 0; i < MAX_PLAYERS; i++)
KillPlayer(&stored_player[i]);
}
}
- else if (game.no_time_limit && !AllPlayersGone) // level w/o time limit
+ else if (game.no_time_limit && !game.all_players_gone)
{
game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
}
- level.native_em_level->lev->time =
- (game.no_time_limit ? TimePlayed : TimeLeft);
+ game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
}
if (tape.recording || tape.playing)
unsigned int game_frame_delay_value;
byte *recorded_player_action;
byte summarized_player_action = 0;
- byte tape_action[MAX_PLAYERS];
+ byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
int i;
// detect endless loops, caused by custom element programming
EL_NAME(recursion_loop_element),
" caused endless loop! Quit the game?");
- Error(ERR_WARN, "element '%s' caused endless loop in game engine",
- EL_NAME(recursion_loop_element));
+ Warn("element '%s' caused endless loop in game engine",
+ EL_NAME(recursion_loop_element));
RequestQuitGameExt(FALSE, level_editor_test_game, message);
if (game.LevelSolved && !game.LevelSolved_GameEnd)
GameWon();
- if (AllPlayersGone && !TAPE_IS_STOPPED(tape))
+ if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
TapeStop();
if (game_status != GAME_MODE_PLAYING) // status might have changed
SetVideoFrameDelay(game_frame_delay_value);
+ // (de)activate virtual buttons depending on current game status
+ if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
+ {
+ if (game.all_players_gone) // if no players there to be controlled anymore
+ SetOverlayActive(FALSE);
+ else if (!tape.playing) // if game continues after tape stopped playing
+ SetOverlayActive(TRUE);
+ }
+
#if 0
#if 0
// ---------- main game synchronization point ----------
int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
- printf("::: skip == %d\n", skip);
+ Debug("game:playing:skip", "skip == %d", skip);
#else
// ---------- main game synchronization point ----------
stored_player[map_player_action[local_player->index_nr]].effective_action =
summarized_player_action;
+ // summarize all actions at centered player in local team mode
if (tape.recording &&
- setup.team_mode &&
+ setup.team_mode && !network.enabled &&
setup.input_on_focus &&
game.centered_player_nr != -1)
{
for (i = 0; i < MAX_PLAYERS; i++)
- stored_player[i].effective_action =
+ stored_player[map_player_action[i]].effective_action =
(i == game.centered_player_nr ? summarized_player_action : 0);
}
if (tape.recording)
TapeRecordAction(tape_action);
+ // remember if game was played (especially after tape stopped playing)
+ if (!tape.playing && summarized_player_action)
+ game.GamePlayed = TRUE;
+
#if USE_NEW_PLAYER_ASSIGNMENTS
// !!! also map player actions in single player mode !!!
// if (game.team_mode)
byte mapped_action[MAX_PLAYERS];
#if DEBUG_PLAYER_ACTIONS
- printf(":::");
for (i = 0; i < MAX_PLAYERS; i++)
- printf(" %d, ", stored_player[i].effective_action);
+ DebugContinued("", "%d, ", stored_player[i].effective_action);
#endif
for (i = 0; i < MAX_PLAYERS; i++)
stored_player[i].effective_action = mapped_action[i];
#if DEBUG_PLAYER_ACTIONS
- printf(" =>");
+ DebugContinued("", "=> ");
for (i = 0; i < MAX_PLAYERS; i++)
- printf(" %d, ", stored_player[i].effective_action);
- printf("\n");
+ DebugContinued("", "%d, ", stored_player[i].effective_action);
+ DebugContinued("game:playing:player", "\n");
#endif
}
#if DEBUG_PLAYER_ACTIONS
else
{
- printf(":::");
for (i = 0; i < MAX_PLAYERS; i++)
- printf(" %d, ", stored_player[i].effective_action);
- printf("\n");
+ DebugContinued("", "%d, ", stored_player[i].effective_action);
+ DebugContinued("game:playing:player", "\n");
}
#endif
#endif
void GameActions_RND(void)
{
+ static struct MouseActionInfo mouse_action_last = { 0 };
+ struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
int magic_wall_x = 0, magic_wall_y = 0;
int i, x, y, element, graphic, last_gfx_frame;
DrawGameDoorValues();
}
+ // check single step mode (set flag and clear again if any player is active)
+ game.enter_single_step_mode =
+ (tape.single_step && tape.recording && !tape.pausing);
+
for (i = 0; i < MAX_PLAYERS; i++)
{
int actual_player_action = stored_player[i].effective_action;
ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
}
+ // single step pause mode may already have been toggled by "ScrollPlayer()"
+ if (game.enter_single_step_mode && !tape.pausing)
+ TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
+
ScrollScreen(NULL, SCROLL_GO_ON);
/* for backwards compatibility, the following code emulates a fixed bug that
if (player->active && player->is_pushing && player->is_moving &&
IS_MOVING(x, y) &&
(game.engine_version < VERSION_IDENT(2,2,0,7) ||
- Feld[x][y] == EL_SPRING))
+ Tile[x][y] == EL_SPRING))
{
ContinueMoving(x, y);
SCAN_PLAYFIELD(x, y)
{
- Last[x][y] = Feld[x][y];
+ Last[x][y] = Tile[x][y];
ChangeCount[x][y] = 0;
ChangeEvent[x][y] = -1;
// this must be handled before main playfield loop
- if (Feld[x][y] == EL_PLAYER_IS_LEAVING)
+ if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
{
MovDelay[x][y]--;
if (MovDelay[x][y] <= 0)
RemoveField(x, y);
}
- if (Feld[x][y] == EL_ELEMENT_SNAPPING)
+ if (Tile[x][y] == EL_ELEMENT_SNAPPING)
{
MovDelay[x][y]--;
if (MovDelay[x][y] <= 0)
{
+ int element = Store[x][y];
+ int move_direction = MovDir[x][y];
+ int player_index_bit = Store2[x][y];
+
+ Store[x][y] = 0;
+ Store2[x][y] = 0;
+
RemoveField(x, y);
TEST_DrawLevelField(x, y);
- TestIfElementTouchesCustomElement(x, y); // for empty space
+ TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
}
}
#if DEBUG
if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
{
- printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
- printf("GameActions(): This should never happen!\n");
+ Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
+ x, y);
+ Debug("game:playing:GameActions_RND", "This should never happen!");
ChangePage[x][y] = -1;
}
Blocked2Moving(x, y, &oldx, &oldy);
if (!IS_MOVING(oldx, oldy))
{
- printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
- printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
- printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
- printf("GameActions(): This should never happen!\n");
+ Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
+ Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
+ Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
+ Debug("game:playing:GameActions_RND", "This should never happen!");
}
}
#endif
}
+ if (mouse_action.button)
+ {
+ int new_button = (mouse_action.button && mouse_action_last.button == 0);
+
+ x = mouse_action.lx;
+ y = mouse_action.ly;
+ element = Tile[x][y];
+
+ if (new_button)
+ {
+ CheckElementChange(x, y, element, EL_UNDEFINED, CE_CLICKED_BY_MOUSE);
+ CheckTriggeredElementChange(x, y, element, CE_MOUSE_CLICKED_ON_X);
+ }
+
+ CheckElementChange(x, y, element, EL_UNDEFINED, CE_PRESSED_BY_MOUSE);
+ CheckTriggeredElementChange(x, y, element, CE_MOUSE_PRESSED_ON_X);
+ }
+
SCAN_PLAYFIELD(x, y)
{
- element = Feld[x][y];
+ element = Tile[x][y];
graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
last_gfx_frame = GfxFrame[x][y];
HandleElementChange(x, y, page);
- element = Feld[x][y];
+ element = Tile[x][y];
graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
}
{
StartMoving(x, y);
- element = Feld[x][y];
+ element = Tile[x][y];
graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
if (IS_ANIMATED(graphic) &&
else if (IS_ACTIVE_BOMB(element))
CheckDynamite(x, y);
else if (element == EL_AMOEBA_GROWING)
- AmoebeWaechst(x, y);
+ AmoebaGrowing(x, y);
else if (element == EL_AMOEBA_SHRINKING)
- AmoebaDisappearing(x, y);
+ AmoebaShrinking(x, y);
#if !USE_NEW_AMOEBA_CODE
else if (IS_AMOEBALIVE(element))
- AmoebeAbleger(x, y);
+ AmoebaReproduce(x, y);
#endif
else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
element == EL_DC_MAGIC_WALL_FULL ||
element == EL_DC_MAGIC_WALL_ACTIVE ||
element == EL_DC_MAGIC_WALL_EMPTYING) &&
- ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
+ ABS(x - jx) + ABS(y - jy) <
+ ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
{
magic_wall_x = x;
magic_wall_y = y;
{
x = RND(lev_fieldx);
y = RND(lev_fieldy);
- element = Feld[x][y];
+ element = Tile[x][y];
if (!IS_PLAYER(x,y) &&
(element == EL_EMPTY ||
element == EL_ACID_SPLASH_LEFT ||
element == EL_ACID_SPLASH_RIGHT))
{
- if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
- (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
- (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
- (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
- Feld[x][y] = EL_AMOEBA_DROP;
+ if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
+ (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
+ (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
+ (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
+ Tile[x][y] = EL_AMOEBA_DROP;
}
random = random * 129 + 1;
SCAN_PLAYFIELD(x, y)
{
- element = Feld[x][y];
+ element = Tile[x][y];
if (ExplodeField[x][y])
Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
{
if (!(game.magic_wall_time_left % 4))
{
- int element = Feld[magic_wall_x][magic_wall_y];
+ int element = Tile[magic_wall_x][magic_wall_y];
if (element == EL_BD_MAGIC_WALL_FULL ||
element == EL_BD_MAGIC_WALL_ACTIVE ||
{
SCAN_PLAYFIELD(x, y)
{
- element = Feld[x][y];
+ element = Tile[x][y];
if (element == EL_MAGIC_WALL_ACTIVE ||
element == EL_MAGIC_WALL_FULL)
{
- Feld[x][y] = EL_MAGIC_WALL_DEAD;
+ Tile[x][y] = EL_MAGIC_WALL_DEAD;
TEST_DrawLevelField(x, y);
}
else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
element == EL_BD_MAGIC_WALL_FULL)
{
- Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
+ Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
TEST_DrawLevelField(x, y);
}
else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
element == EL_DC_MAGIC_WALL_FULL)
{
- Feld[x][y] = EL_DC_MAGIC_WALL_DEAD;
+ Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
TEST_DrawLevelField(x, y);
}
}
DrawAllPlayers();
PlayAllPlayersSound();
- if (local_player->show_envelope != 0 && local_player->MovPos == 0)
+ for (i = 0; i < MAX_PLAYERS; i++)
{
- ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
+ struct PlayerInfo *player = &stored_player[i];
+
+ if (player->show_envelope != 0 && (!player->active ||
+ player->MovPos == 0))
+ {
+ ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
- local_player->show_envelope = 0;
+ player->show_envelope = 0;
+ }
}
// use random number generator in every frame to make it less predictable
if (game.engine_version >= VERSION_IDENT(3,1,1,0))
RND(1);
+
+ mouse_action_last = mouse_action;
}
static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
{
int min_x = x, min_y = y, max_x = x, max_y = y;
+ int scr_fieldx = getScreenFieldSizeX();
+ int scr_fieldy = getScreenFieldSizeY();
int i;
for (i = 0; i < MAX_PLAYERS; i++)
max_y = MAX(max_y, jy);
}
- return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
+ return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
}
static boolean AllPlayersInVisibleScreen(void)
return (IN_LEV_FIELD(jx, jy + 1) &&
(IS_FREE(jx, jy + 1) ||
- (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
- IS_WALKABLE_FROM(Feld[jx][jy], MV_DOWN) &&
- !IS_WALKABLE_INSIDE(Feld[jx][jy]));
+ (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
+ IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
+ !IS_WALKABLE_INSIDE(Tile[jx][jy]));
}
static boolean canPassField(int x, int y, int move_dir)
int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
int nextx = x + dx;
int nexty = y + dy;
- int element = Feld[x][y];
+ int element = Tile[x][y];
return (IS_PASSABLE_FROM(element, opposite_dir) &&
!CAN_MOVE(element) &&
IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
- IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) &&
+ IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
(level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
}
int newy = y + dy;
return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
- IS_GRAVITY_REACHABLE(Feld[newx][newy]) &&
- (IS_DIGGABLE(Feld[newx][newy]) ||
- IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) ||
+ IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
+ (IS_DIGGABLE(Tile[newx][newy]) ||
+ IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
canPassField(newx, newy, move_dir)));
}
boolean field_under_player_is_free =
(IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
boolean player_is_standing_on_valid_field =
- (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
- (IS_WALKABLE(Feld[jx][jy]) &&
- !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
+ (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
+ (IS_WALKABLE(Tile[jx][jy]) &&
+ !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
if (field_under_player_is_free && !player_is_standing_on_valid_field)
player->programmed_action = MV_DOWN;
int original_move_delay_value = player->move_delay_value;
#if DEBUG
- printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]\n",
- tape.counter);
+ Debug("game:playing:MovePlayer",
+ "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
+ tape.counter);
#endif
// scroll remaining steps with finest movement resolution
game.centered_player_nr == -1))
{
int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
- int offset = game.scroll_delay_value;
if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
{
}
else
{
+ int offset_raw = game.scroll_delay_value;
+
if (jx != old_jx) // player has moved horizontally
{
- if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
- (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
- scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
+ int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
+ int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
+ int new_scroll_x = jx - MIDPOSX + offset_x;
+
+ if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
+ (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
+ scroll_x = new_scroll_x;
// don't scroll over playfield boundaries
- if (scroll_x < SBX_Left || scroll_x > SBX_Right)
- scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
+ scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
// don't scroll more than one field at a time
scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
}
else // player has moved vertically
{
- if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
- (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
- scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
+ int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
+ int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
+ int new_scroll_y = jy - MIDPOSY + offset_y;
+
+ if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
+ (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
+ scroll_y = new_scroll_y;
// don't scroll over playfield boundaries
- if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
- scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
+ scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
// don't scroll more than one field at a time
scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
if ((player->block_last_field || player->block_delay_adjustment > 0) &&
- Feld[last_jx][last_jy] == EL_EMPTY)
+ Tile[last_jx][last_jy] == EL_EMPTY)
{
int last_field_block_delay = 0; // start with no blocking at all
int block_delay_adjustment = player->block_delay_adjustment;
// add block delay adjustment (also possible when not blocking)
last_field_block_delay += block_delay_adjustment;
- Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
+ Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
}
player->last_jx = jx;
player->last_jy = jy;
- if (Feld[jx][jy] == EL_EXIT_OPEN ||
- Feld[jx][jy] == EL_EM_EXIT_OPEN ||
- Feld[jx][jy] == EL_EM_EXIT_OPENING ||
- Feld[jx][jy] == EL_STEEL_EXIT_OPEN ||
- Feld[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
- Feld[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
- Feld[jx][jy] == EL_SP_EXIT_OPEN ||
- Feld[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
+ if (Tile[jx][jy] == EL_EXIT_OPEN ||
+ Tile[jx][jy] == EL_EM_EXIT_OPEN ||
+ Tile[jx][jy] == EL_EM_EXIT_OPENING ||
+ Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
+ Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
+ Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
+ Tile[jx][jy] == EL_SP_EXIT_OPEN ||
+ Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
{
ExitPlayer(player);
- if ((local_player->friends_still_needed == 0 ||
- IS_SP_ELEMENT(Feld[jx][jy])) &&
- AllPlayersGone)
+ if (game.players_still_needed == 0 &&
+ (game.friends_still_needed == 0 ||
+ IS_SP_ELEMENT(Tile[jx][jy])))
LevelSolved();
}
int leave_side = move_direction;
int old_jx = last_jx;
int old_jy = last_jy;
- int old_element = Feld[old_jx][old_jy];
- int new_element = Feld[jx][jy];
+ int old_element = Tile[old_jx][old_jy];
+ int new_element = Tile[jx][jy];
if (IS_CUSTOM_ELEMENT(old_element))
CheckElementChangeByPlayer(old_jx, old_jy, old_element,
if (!player->is_pushing)
TestIfElementTouchesCustomElement(jx, jy); // for empty space
+ if (level.finish_dig_collect &&
+ (player->is_digging || player->is_collecting))
+ {
+ int last_element = player->last_removed_element;
+ int move_direction = player->MovDir;
+ int enter_side = MV_DIR_OPPOSITE(move_direction);
+ int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
+ CE_PLAYER_COLLECTS_X);
+
+ CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
+ player->index_bit, enter_side);
+
+ player->last_removed_element = EL_UNDEFINED;
+ }
+
if (!player->active)
RemovePlayer(player);
}
for (i = 0; i < MAX_PLAYERS; i++)
KillPlayer(&stored_player[i]);
}
- else if (game.no_time_limit && !AllPlayersGone) // level w/o time limit
+ else if (game.no_time_limit && !game.all_players_gone)
{
game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
MV_UP | MV_DOWN,
MV_LEFT | MV_RIGHT
};
- int center_element = Feld[x][y]; // should always be non-moving!
+ int center_element = Tile[x][y]; // should always be non-moving!
int i;
for (i = 0; i < NUM_DIRECTIONS; i++)
struct PlayerInfo *player = PLAYERINFO(x, y);
if (game.engine_version < VERSION_IDENT(3,0,7,0))
- border_element = Feld[xx][yy]; // may be moving!
+ border_element = Tile[xx][yy]; // may be moving!
else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
- border_element = Feld[xx][yy];
+ border_element = Tile[xx][yy];
else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
border_element = MovingOrBlocked2Element(xx, yy);
else
MV_LEFT | MV_RIGHT
};
boolean change_center_element = FALSE;
- int center_element = Feld[x][y]; // should always be non-moving!
+ int center_element = Tile[x][y]; // should always be non-moving!
int border_element_old[NUM_DIRECTIONS];
int i;
continue;
if (game.engine_version < VERSION_IDENT(3,0,7,0))
- border_element = Feld[xx][yy]; // may be moving!
+ border_element = Tile[xx][yy]; // may be moving!
else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
- border_element = Feld[xx][yy];
+ border_element = Tile[xx][yy];
else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
border_element = MovingOrBlocked2Element(xx, yy);
else
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
int hitx = x + dx, hity = y + dy;
- int hitting_element = Feld[x][y];
+ int hitting_element = Tile[x][y];
int touched_element;
if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
{
int i, kill_x = -1, kill_y = -1;
- int bad_element = Feld[bad_x][bad_y];
+ int bad_element = Tile[bad_x][bad_y];
static int test_xy[4][2] =
{
{ 0, -1 },
test_move_dir =
(IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
- test_element = Feld[test_x][test_y];
+ test_element = Tile[test_x][test_y];
/* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
2nd case: DONT_TOUCH style bad thing does not move away from good thing
void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
{
- int bad_element = Feld[bad_x][bad_y];
+ int bad_element = Tile[bad_x][bad_y];
int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
int test_x = bad_x + dx, test_y = bad_y + dy;
test_move_dir =
(IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
- test_element = Feld[test_x][test_y];
+ test_element = Tile[test_x][test_y];
if (test_move_dir != bad_move_dir)
{
if (!IN_LEV_FIELD(x, y))
continue;
- element = Feld[x][y];
+ element = Tile[x][y];
if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
{
return;
#if 0
- printf("::: 0: killed == %d, active == %d, reanimated == %d\n",
- player->killed, player->active, player->reanimated);
+ Debug("game:playing:KillPlayer",
+ "0: killed == %d, active == %d, reanimated == %d",
+ player->killed, player->active, player->reanimated);
#endif
/* the following code was introduced to prevent an infinite loop when calling
player->killed = TRUE;
// remove accessible field at the player's position
- Feld[jx][jy] = EL_EMPTY;
+ Tile[jx][jy] = EL_EMPTY;
// deactivate shield (else Bang()/Explode() would not work right)
player->shield_normal_time_left = 0;
player->shield_deadly_time_left = 0;
#if 0
- printf("::: 1: killed == %d, active == %d, reanimated == %d\n",
- player->killed, player->active, player->reanimated);
+ Debug("game:playing:KillPlayer",
+ "1: killed == %d, active == %d, reanimated == %d",
+ player->killed, player->active, player->reanimated);
#endif
Bang(jx, jy);
#if 0
- printf("::: 2: killed == %d, active == %d, reanimated == %d\n",
- player->killed, player->active, player->reanimated);
+ Debug("game:playing:KillPlayer",
+ "2: killed == %d, active == %d, reanimated == %d",
+ player->killed, player->active, player->reanimated);
#endif
if (player->reanimated) // killed player may have been reanimated
PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
PlayLevelSound(jx, jy, SND_GAME_LOSING);
- player->GameOver = TRUE;
RemovePlayer(player);
+
+ player->buried = TRUE;
+
+ if (game.all_players_gone)
+ game.GameOver = TRUE;
}
void RemovePlayer(struct PlayerInfo *player)
player->present = FALSE;
player->active = FALSE;
+ // required for some CE actions (even if the player is not active anymore)
+ player->MovPos = 0;
+
if (!ExplodeField[jx][jy])
StorePlayer[jx][jy] = 0;
found = TRUE;
if (!found)
- AllPlayersGone = TRUE;
+ {
+ game.all_players_gone = TRUE;
+ game.GameOver = TRUE;
+ }
- ExitX = ZX = jx;
- ExitY = ZY = jy;
+ game.exit_x = game.robot_wheel_x = jx;
+ game.exit_y = game.robot_wheel_y = jy;
}
void ExitPlayer(struct PlayerInfo *player)
DrawPlayer(player); // needed here only to cleanup last field
RemovePlayer(player);
- if (local_player->players_still_needed > 0)
- local_player->players_still_needed--;
-
- // also set if some players not yet gone, but not needed to solve level
- if (local_player->players_still_needed == 0)
- AllPlayersGone = TRUE;
+ if (game.players_still_needed > 0)
+ game.players_still_needed--;
}
-static void setFieldForSnapping(int x, int y, int element, int direction)
+static void SetFieldForSnapping(int x, int y, int element, int direction,
+ int player_index_bit)
{
struct ElementInfo *ei = &element_info[element];
int direction_bit = MV_DIR_TO_BIT(direction);
int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
- Feld[x][y] = EL_ELEMENT_SNAPPING;
+ Tile[x][y] = EL_ELEMENT_SNAPPING;
MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
+ MovDir[x][y] = direction;
+ Store[x][y] = element;
+ Store2[x][y] = player_index_bit;
ResetGfxAnimation(x, y);
GfxFrame[x][y] = -1;
}
+static void TestFieldAfterSnapping(int x, int y, int element, int direction,
+ int player_index_bit)
+{
+ TestIfElementTouchesCustomElement(x, y); // for empty space
+
+ if (level.finish_dig_collect)
+ {
+ int dig_side = MV_DIR_OPPOSITE(direction);
+
+ CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+ player_index_bit, dig_side);
+ }
+}
+
/*
=============================================================================
checkDiagonalPushing()
xx = jx + (dx == 0 ? real_dx : 0);
yy = jy + (dy == 0 ? real_dy : 0);
- return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
+ return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
}
/*
dy == +1 ? MV_DOWN : MV_NONE);
int opposite_direction = MV_DIR_OPPOSITE(move_direction);
int dig_side = MV_DIR_OPPOSITE(move_direction);
- int old_element = Feld[jx][jy];
+ int old_element = Tile[jx][jy];
int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
int collect_count;
{
SplashAcid(x, y);
- Feld[jx][jy] = player->artwork_element;
+ Tile[jx][jy] = player->artwork_element;
InitMovingField(jx, jy, MV_DOWN);
Store[jx][jy] = EL_ACID;
ContinueMoving(jx, jy);
if (element == EL_DC_LANDMINE)
Bang(x, y);
- if (Feld[x][y] != element) // field changed by snapping
+ if (Tile[x][y] != element) // field changed by snapping
return MP_ACTION;
return MP_NO_ACTION;
PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
- CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
- player->index_bit, dig_side);
+ // use old behaviour for old levels (digging)
+ if (!level.finish_dig_collect)
+ {
+ CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
+ player->index_bit, dig_side);
+
+ // if digging triggered player relocation, finish digging tile
+ if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
+ SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
+ }
if (mode == DF_SNAP)
{
if (level.block_snap_field)
- setFieldForSnapping(x, y, element, move_direction);
+ SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
else
- TestIfElementTouchesCustomElement(x, y); // for empty space
+ TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
- CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
- player->index_bit, dig_side);
+ // use old behaviour for old levels (snapping)
+ if (!level.finish_dig_collect)
+ CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+ player->index_bit, dig_side);
}
}
else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
}
else if (collect_count > 0)
{
- local_player->gems_still_needed -= collect_count;
- if (local_player->gems_still_needed < 0)
- local_player->gems_still_needed = 0;
+ game.gems_still_needed -= collect_count;
+ if (game.gems_still_needed < 0)
+ game.gems_still_needed = 0;
game.snapshot.collected_item = TRUE;
- game_panel_controls[GAME_PANEL_GEMS].value = local_player->gems_still_needed;
+ game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
DisplayGameControlValues();
}
RaiseScoreElement(element);
PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
- if (is_player)
+ // use old behaviour for old levels (collecting)
+ if (!level.finish_dig_collect && is_player)
+ {
CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
player->index_bit, dig_side);
+ // if collecting triggered player relocation, finish collecting tile
+ if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
+ SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
+ }
+
if (mode == DF_SNAP)
{
if (level.block_snap_field)
- setFieldForSnapping(x, y, element, move_direction);
+ SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
else
- TestIfElementTouchesCustomElement(x, y); // for empty space
+ TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
- CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
- player->index_bit, dig_side);
+ // use old behaviour for old levels (snapping)
+ if (!level.finish_dig_collect)
+ CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+ player->index_bit, dig_side);
}
}
else if (player_can_move_or_snap && IS_PUSHABLE(element))
if (!(IN_LEV_FIELD(nextx, nexty) &&
(IS_FREE(nextx, nexty) ||
(IS_SB_ELEMENT(element) &&
- Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
+ Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
(IS_CUSTOM_ELEMENT(element) &&
CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
return MP_NO_ACTION;
{
Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
- IncrementPlayerSokobanFieldsNeeded(local_player);
- IncrementPlayerSokobanObjectsNeeded(local_player);
+ IncrementSokobanFieldsNeeded();
+ IncrementSokobanObjectsNeeded();
}
- if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
+ if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
{
Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
- DecrementPlayerSokobanFieldsNeeded(local_player);
- DecrementPlayerSokobanObjectsNeeded(local_player);
+ DecrementSokobanFieldsNeeded();
+ DecrementSokobanObjectsNeeded();
// sokoban object was pushed from empty field to sokoban field
if (Back[x][y] == EL_EMPTY)
sokoban_task_solved = TRUE;
}
- Feld[x][y] = EL_SOKOBAN_OBJECT;
+ Tile[x][y] = EL_SOKOBAN_OBJECT;
if (Back[x][y] == Back[nextx][nexty])
PlayLevelSoundAction(x, y, ACTION_PUSHING);
ACTION_FILLING);
if (sokoban_task_solved &&
- local_player->sokoban_fields_still_needed == 0 &&
- local_player->sokoban_objects_still_needed == 0 &&
+ game.sokoban_fields_still_needed == 0 &&
+ game.sokoban_objects_still_needed == 0 &&
(game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
{
- local_player->players_still_needed = 0;
+ game.players_still_needed = 0;
LevelSolved();
if (element == EL_ROBOT_WHEEL)
{
- Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
- ZX = x;
- ZY = y;
+ Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
+ game.robot_wheel_x = x;
+ game.robot_wheel_y = y;
game.robot_wheel_active = TRUE;
TEST_DrawLevelField(x, y);
SCAN_PLAYFIELD(xx, yy)
{
- if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
+ if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
{
Bang(xx, yy);
}
- else if (Feld[xx][yy] == EL_SP_TERMINAL)
+ else if (Tile[xx][yy] == EL_SP_TERMINAL)
{
- Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
+ Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
ResetGfxAnimation(xx, yy);
TEST_DrawLevelField(xx, yy);
}
else if (element == EL_LAMP)
{
- Feld[x][y] = EL_LAMP_ACTIVE;
- local_player->lights_still_needed--;
+ Tile[x][y] = EL_LAMP_ACTIVE;
+ game.lights_still_needed--;
ResetGfxAnimation(x, y);
TEST_DrawLevelField(x, y);
}
else if (element == EL_TIME_ORB_FULL)
{
- Feld[x][y] = EL_TIME_ORB_EMPTY;
+ Tile[x][y] = EL_TIME_ORB_EMPTY;
if (level.time > 0 || level.use_time_orb_bug)
{
{
int xx, yy;
- game.ball_state = !game.ball_state;
+ game.ball_active = !game.ball_active;
SCAN_PLAYFIELD(xx, yy)
{
- int e = Feld[xx][yy];
+ int e = Tile[xx][yy];
- if (game.ball_state)
+ if (game.ball_active)
{
if (e == EL_EMC_MAGIC_BALL)
CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
if (is_player) // function can also be called by EL_PENGUIN
{
- if (Feld[x][y] != element) // really digged/collected something
+ if (Tile[x][y] != element) // really digged/collected something
{
player->is_collecting = !player->is_digging;
player->is_active = TRUE;
+
+ player->last_removed_element = element;
}
}
static boolean DigFieldByCE(int x, int y, int digging_element)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
if (!IS_FREE(x, y))
{
pressed without moving, dropped element must move away before the next
element can be dropped (this is especially important if the next element
is dynamite, which can be placed on background for historical reasons) */
- if (PLAYER_DROPPING(player, dropx, dropy) && Feld[dropx][dropy] != EL_EMPTY)
+ if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
return MP_ACTION;
if (IS_THROWABLE(drop_element))
return FALSE;
}
- old_element = Feld[dropx][dropy]; // old element at dropping position
+ old_element = Tile[dropx][dropy]; // old element at dropping position
new_element = drop_element; // default: no change when dropping
// check if player is active, not moving and ready to drop
new_element = EL_SP_DISK_RED_ACTIVE;
}
- Feld[dropx][dropy] = new_element;
+ Tile[dropx][dropy] = new_element;
if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
- el2img(Feld[dropx][dropy]), 0);
+ el2img(Tile[dropx][dropy]), 0);
PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
{
player->dynabombs_left--;
- Feld[dropx][dropy] = new_element;
+ Tile[dropx][dropy] = new_element;
if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
- el2img(Feld[dropx][dropy]), 0);
+ el2img(Tile[dropx][dropy]), 0);
PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
}
- if (Feld[dropx][dropy] == new_element) // uninitialized unless CE change
+ if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
InitField_WithBug1(dropx, dropy, FALSE);
- new_element = Feld[dropx][dropy]; // element might have changed
+ new_element = Tile[dropx][dropy]; // element might have changed
if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
element_info[new_element].move_pattern == MV_WHEN_DROPPED)
static void PlayLevelSoundAction(int x, int y, int action)
{
- PlayLevelSoundElementAction(x, y, Feld[x][y], action);
+ PlayLevelSoundElementAction(x, y, Tile[x][y], action);
}
static void PlayLevelSoundElementAction(int x, int y, int element, int action)
static void PlayLevelSoundActionIfLoop(int x, int y, int action)
{
- int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
+ int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
PlayLevelSound(x, y, sound_effect);
static void StopLevelSoundActionIfLoop(int x, int y, int action)
{
- int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
+ int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
StopSound(sound_effect);
void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
{
- int element = (element_em > -1 ? map_element_EM_to_RND(element_em) : 0);
- int offset = (BorderElement == EL_STEELWALL ? 1 : 0);
- int x = xx - 1 - offset;
- int y = yy - 1 - offset;
+ int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
+ int offset = 0;
+ int x = xx - offset;
+ int y = yy - offset;
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);
#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_slide:
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;
void RaiseScore(int value)
{
- local_player->score += value;
+ game.score += value;
- game_panel_controls[GAME_PANEL_SCORE].value = local_player->score;
+ game_panel_controls[GAME_PANEL_SCORE].value = game.score;
DisplayGameControlValues();
}
{
// closing door required in case of envelope style request dialogs
if (!skip_request)
+ {
+ // prevent short reactivation of overlay buttons while closing door
+ SetOverlayActive(FALSE);
+
CloseDoor(DOOR_CLOSE_1);
+ }
if (network.enabled)
SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
void RequestQuitGame(boolean ask_if_really_quit)
{
boolean quick_quit = (!ask_if_really_quit || level_editor_test_game);
- boolean skip_request = AllPlayersGone || quick_quit;
+ boolean skip_request = game.all_players_gone || quick_quit;
RequestQuitGameExt(skip_request, quick_quit,
"Do you really want to quit the game?");
}
else
{
+ // needed in case of envelope request to close game panel
+ CloseDoor(DOOR_CLOSE_1);
+
SetGameStatus(GAME_MODE_MAIN);
DrawMainMenu();
if (game.request_active)
return;
+ // do not ask to play again if game was never actually played
+ if (!game.GamePlayed)
+ return;
+
if (!game_over)
{
last_game_over = FALSE;
boolean checkGameFailed(void)
{
- if (!AllPlayersGone)
- return FALSE;
-
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
return (game_em.game_over && !game_em.level_solved);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
return (game_mm.game_over && !game_mm.level_solved);
else // GAME_ENGINE_TYPE_RND
- return (local_player->GameOver && !game.LevelSolved);
+ return (game.GameOver && !game.LevelSolved);
}
boolean checkGameEnded(void)
if (game.num_random_calls != num_random_calls)
{
- Error(ERR_INFO, "number of random calls out of sync");
- Error(ERR_INFO, "number of random calls should be %d", num_random_calls);
- Error(ERR_INFO, "number of random calls is %d", game.num_random_calls);
- Error(ERR_EXIT, "this should not happen -- please debug");
+ Error("number of random calls out of sync");
+ Error("number of random calls should be %d", num_random_calls);
+ Error("number of random calls is %d", game.num_random_calls);
+
+ Fail("this should not happen -- please debug");
}
}
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ZX));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ZY));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExitX));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExitY));
-
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AllPlayersGone));
-
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
- SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Feld));
+ SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
node = node->next;
}
- printf("::: size of engine snapshot: %d bytes\n", num_bytes);
+ Debug("game:playing:SaveEngineSnapshotBuffers",
+ "size of engine snapshot: %d bytes", num_bytes);
#endif
return buffers;
int gadget_id;
boolean *setup_value;
boolean allowed_on_tape;
+ boolean is_touch_button;
char *infotext;
} gamebutton_info[NUM_GAME_BUTTONS] =
{
{
IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
GAME_CTRL_ID_STOP, NULL,
- TRUE, "stop game"
+ TRUE, FALSE, "stop game"
},
{
IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
GAME_CTRL_ID_PAUSE, NULL,
- TRUE, "pause game"
+ TRUE, FALSE, "pause game"
},
{
IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
GAME_CTRL_ID_PLAY, NULL,
- TRUE, "play game"
+ TRUE, FALSE, "play game"
},
{
IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
GAME_CTRL_ID_UNDO, NULL,
- TRUE, "undo step"
+ TRUE, FALSE, "undo step"
},
{
IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
GAME_CTRL_ID_REDO, NULL,
- TRUE, "redo step"
+ TRUE, FALSE, "redo step"
},
{
IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
GAME_CTRL_ID_SAVE, NULL,
- TRUE, "save game"
+ TRUE, FALSE, "save game"
},
{
IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
GAME_CTRL_ID_PAUSE2, NULL,
- TRUE, "pause game"
+ TRUE, FALSE, "pause game"
},
{
IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
GAME_CTRL_ID_LOAD, NULL,
- TRUE, "load game"
+ TRUE, FALSE, "load game"
},
{
IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
GAME_CTRL_ID_PANEL_STOP, NULL,
- FALSE, "stop game"
+ FALSE, FALSE, "stop game"
},
{
IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
GAME_CTRL_ID_PANEL_PAUSE, NULL,
- FALSE, "pause game"
+ FALSE, FALSE, "pause game"
},
{
IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
GAME_CTRL_ID_PANEL_PLAY, NULL,
- FALSE, "play game"
+ FALSE, FALSE, "play game"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
+ GAME_CTRL_ID_TOUCH_STOP, NULL,
+ FALSE, TRUE, "stop game"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
+ GAME_CTRL_ID_TOUCH_PAUSE, NULL,
+ FALSE, TRUE, "pause game"
},
{
IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
SOUND_CTRL_ID_MUSIC, &setup.sound_music,
- TRUE, "background music on/off"
+ TRUE, FALSE, "background music on/off"
},
{
IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
- TRUE, "sound loops on/off"
+ TRUE, FALSE, "sound loops on/off"
},
{
IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
- TRUE, "normal sounds on/off"
+ TRUE, FALSE, "normal sounds on/off"
},
{
IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
- FALSE, "background music on/off"
+ FALSE, FALSE, "background music on/off"
},
{
IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
- FALSE, "sound loops on/off"
+ FALSE, FALSE, "sound loops on/off"
},
{
IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
- FALSE, "normal sounds on/off"
+ FALSE, FALSE, "normal sounds on/off"
}
};
int button_type;
boolean checked;
unsigned int event_mask;
+ boolean is_touch_button = gamebutton_info[i].is_touch_button;
boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
- int base_x = (on_tape ? VX : DX);
- int base_y = (on_tape ? VY : DY);
+ int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
+ int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
int gd_x = gfx->src_x;
int gd_y = gfx->src_y;
int gd_xp = gfx->src_x + gfx->pressed_xoffset;
int gd_ya = gfx->src_y + gfx->active_yoffset;
int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
+ int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
+ int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
int id = i;
if (gfx->bitmap == NULL)
if (id == GAME_CTRL_ID_STOP ||
id == GAME_CTRL_ID_PANEL_STOP ||
+ id == GAME_CTRL_ID_TOUCH_STOP ||
id == GAME_CTRL_ID_PLAY ||
id == GAME_CTRL_ID_PANEL_PLAY ||
id == GAME_CTRL_ID_SAVE ||
gi = CreateGadget(GDI_CUSTOM_ID, id,
GDI_IMAGE_ID, graphic,
GDI_INFO_TEXT, gamebutton_info[i].infotext,
- GDI_X, base_x + GDI_ACTIVE_POS(pos->x),
- GDI_Y, base_y + GDI_ACTIVE_POS(pos->y),
+ GDI_X, base_x + x,
+ GDI_Y, base_y + y,
GDI_WIDTH, gfx->width,
GDI_HEIGHT, gfx->height,
GDI_TYPE, button_type,
GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
GDI_DIRECT_DRAW, FALSE,
+ GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
GDI_EVENT_MASK, event_mask,
GDI_CALLBACK_ACTION, HandleGameButtons,
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
game_gadget[id] = gi;
}
MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
-
- ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, TRUE, GDI_END);
}
void UnmapUndoRedoButtons(void)
MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
+}
- ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, FALSE, GDI_END);
+void ModifyPauseButtons(void)
+{
+ static int ids[] =
+ {
+ GAME_CTRL_ID_PAUSE,
+ GAME_CTRL_ID_PAUSE2,
+ GAME_CTRL_ID_PANEL_PAUSE,
+ GAME_CTRL_ID_TOUCH_PAUSE,
+ -1
+ };
+ int i;
+
+ for (i = 0; ids[i] > -1; i++)
+ ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
}
static void MapGameButtonsExt(boolean on_tape)
for (i = 0; i < NUM_GAME_BUTTONS; i++)
if (!on_tape || gamebutton_info[i].allowed_on_tape)
RedrawGadget(game_gadget[i]);
-
- // RedrawGadget() may have set REDRAW_ALL if buttons are defined off-area
- redraw_mask &= ~REDRAW_ALL;
}
static void SetGadgetState(struct GadgetInfo *gi, boolean state)
{
case GAME_CTRL_ID_STOP:
case GAME_CTRL_ID_PANEL_STOP:
+ case GAME_CTRL_ID_TOUCH_STOP:
if (game_status == GAME_MODE_MAIN)
break;
case GAME_CTRL_ID_PAUSE:
case GAME_CTRL_ID_PAUSE2:
case GAME_CTRL_ID_PANEL_PAUSE:
+ case GAME_CTRL_ID_TOUCH_PAUSE:
if (network.enabled && game_status == GAME_MODE_PLAYING)
{
if (tape.pausing)
projects / rocksndiamonds.git / blobdiff