#define USE_GFX_RESET_WHEN_NOT_MOVING (USE_NEW_STUFF * 1)
+#define USE_NEW_PLAYER_ASSIGNMENTS (USE_NEW_STUFF * 1)
+
#define USE_DELAYED_GFX_REDRAW (USE_NEW_STUFF * 0)
#if USE_DELAYED_GFX_REDRAW
static boolean recursion_loop_detected;
static boolean recursion_loop_element;
+static int map_player_action[MAX_PLAYERS];
+
/* ------------------------------------------------------------------------- */
/* definition of elements that automatically change to other elements after */
int player_nr = GET_PLAYER_NR(element);
struct PlayerInfo *player = &stored_player[player_nr];
- if (player->active)
- player->killed = FALSE; /* if player was just killed, reanimate him */
+ if (player->active && player->killed)
+ player->reanimated = TRUE; /* if player was just killed, reanimate him */
}
#endif
}
for (j = 0; j < ei->num_change_pages; j++)
{
ei->change_page[j].actual_trigger_element = EL_EMPTY;
- ei->change_page[j].actual_trigger_player = EL_PLAYER_1;
- ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_1;
+ ei->change_page[j].actual_trigger_player = EL_EMPTY;
+ ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
ei->change_page[j].actual_trigger_ce_value = 0;
ei->change_page[j].actual_trigger_ce_score = 0;
player->present = FALSE;
player->active = FALSE;
+ player->mapped = FALSE;
+
player->killed = FALSE;
+ player->reanimated = FALSE;
player->action = 0;
player->effective_action = 0;
player->LevelSolved_SaveScore = FALSE;
player->LevelSolved_CountingTime = 0;
player->LevelSolved_CountingScore = 0;
+
+ map_player_action[i] = i;
}
network_player_action_received = FALSE;
if (game.belt_dir[i] == MV_NONE)
game.belt_dir_nr[i] = 3; /* not moving, next moving left */
+#if USE_NEW_PLAYER_ASSIGNMENTS
+ /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
+ /* choose default local player */
+ local_player = &stored_player[0];
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].connected = FALSE;
+
+ local_player->connected = TRUE;
+ /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
+
+ if (tape.playing)
+ {
+ /* try to guess locally connected team mode players (needed for correct
+ assignment of player figures from level to locally playing players) */
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (tape.player_participates[i])
+ stored_player[i].connected = TRUE;
+ }
+ else if (setup.team_mode && !options.network)
+ {
+ /* try to guess locally connected team mode players (needed for correct
+ assignment of player figures from level to locally playing players) */
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (setup.input[i].use_joystick ||
+ setup.input[i].key.left != KSYM_UNDEFINED)
+ stored_player[i].connected = TRUE;
+ }
+
+#if 0
+ for (i = 0; i < MAX_PLAYERS; i++)
+ printf("::: player %d: %s\n", i,
+ (stored_player[i].connected ? "connected" : "not connected"));
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ printf("::: player %d: %s\n", i,
+ (stored_player[i].present ? "present" : "not present"));
+#endif
+
+ /* check if any connected player was not found in playfield */
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ struct PlayerInfo *player = &stored_player[i];
+
+ if (player->connected && !player->present)
+ {
+ struct PlayerInfo *field_player = NULL;
+
+#if 0
+ printf("::: looking for field player for player %d ...\n", i);
+#endif
+
+ /* assign first free player found that is present in the playfield */
+
+ /* first try: look for unmapped playfield player that is not connected */
+ if (field_player == NULL)
+ for (j = 0; j < MAX_PLAYERS; j++)
+ if (stored_player[j].present &&
+ !stored_player[j].mapped &&
+ !stored_player[j].connected)
+ field_player = &stored_player[j];
+
+ /* second try: look for *any* unmapped playfield player */
+ if (field_player == NULL)
+ for (j = 0; j < MAX_PLAYERS; j++)
+ if (stored_player[j].present &&
+ !stored_player[j].mapped)
+ field_player = &stored_player[j];
+
+ if (field_player != NULL)
+ {
+ int jx = field_player->jx, jy = field_player->jy;
+
+#if 0
+ printf("::: found player figure %d\n", field_player->index_nr);
+#endif
+
+ player->present = FALSE;
+ player->active = FALSE;
+
+ field_player->present = TRUE;
+ field_player->active = TRUE;
+
+ /*
+ player->initial_element = field_player->initial_element;
+ player->artwork_element = field_player->artwork_element;
+
+ player->block_last_field = field_player->block_last_field;
+ player->block_delay_adjustment = field_player->block_delay_adjustment;
+ */
+
+ StorePlayer[jx][jy] = field_player->element_nr;
+
+ field_player->jx = field_player->last_jx = jx;
+ field_player->jy = field_player->last_jy = jy;
+
+ if (local_player == player)
+ local_player = field_player;
+
+ map_player_action[field_player->index_nr] = i;
+
+ field_player->mapped = TRUE;
+
+#if 0
+ printf("::: map_player_action[%d] == %d\n",
+ field_player->index_nr, i);
+#endif
+ }
+ }
+
+ if (player->connected && player->present)
+ player->mapped = TRUE;
+ }
+
+#else
+
/* check if any connected player was not found in playfield */
for (i = 0; i < MAX_PLAYERS; i++)
{
{
for (j = 0; j < MAX_PLAYERS; j++)
{
- struct PlayerInfo *some_player = &stored_player[j];
- int jx = some_player->jx, jy = some_player->jy;
+ struct PlayerInfo *field_player = &stored_player[j];
+ int jx = field_player->jx, jy = field_player->jy;
/* assign first free player found that is present in the playfield */
- if (some_player->present && !some_player->connected)
+ if (field_player->present && !field_player->connected)
{
player->present = TRUE;
player->active = TRUE;
- some_player->present = FALSE;
- some_player->active = FALSE;
+ field_player->present = FALSE;
+ field_player->active = FALSE;
- player->initial_element = some_player->initial_element;
- player->artwork_element = some_player->artwork_element;
+ player->initial_element = field_player->initial_element;
+ player->artwork_element = field_player->artwork_element;
- player->block_last_field = some_player->block_last_field;
- player->block_delay_adjustment = some_player->block_delay_adjustment;
+ player->block_last_field = field_player->block_last_field;
+ player->block_delay_adjustment = field_player->block_delay_adjustment;
StorePlayer[jx][jy] = player->element_nr;
+
player->jx = player->last_jx = jx;
player->jy = player->last_jy = jy;
}
}
}
+#endif
+
+#if 0
+ printf("::: local_player->present == %d\n", local_player->present);
+#endif
if (tape.playing)
{
/* when playing a tape, eliminate all players who do not participate */
+#if USE_NEW_PLAYER_ASSIGNMENTS
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (stored_player[i].active &&
+ !tape.player_participates[map_player_action[i]])
+ {
+ struct PlayerInfo *player = &stored_player[i];
+ int jx = player->jx, jy = player->jy;
+
+ player->active = FALSE;
+ StorePlayer[jx][jy] = 0;
+ Feld[jx][jy] = EL_EMPTY;
+ }
+ }
+#else
for (i = 0; i < MAX_PLAYERS; i++)
{
if (stored_player[i].active && !tape.player_participates[i])
Feld[jx][jy] = EL_EMPTY;
}
}
+#endif
}
else if (!options.network && !setup.team_mode) /* && !tape.playing */
{
/* when recording the game, store which players take part in the game */
if (tape.recording)
{
+#if USE_NEW_PLAYER_ASSIGNMENTS
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].connected)
+ tape.player_participates[i] = TRUE;
+#else
for (i = 0; i < MAX_PLAYERS; i++)
if (stored_player[i].active)
tape.player_participates[i] = TRUE;
+#endif
}
if (options.debug)
CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
player->index_bit, enter_side);
+
+#if 1
+ if (player->is_switching)
+ {
+ /* ensure that relocation while still switching an element does not cause
+ a new element to be treated as also switched directly after relocation
+ (this is important for teleporter switches that teleport the player to
+ a place where another teleporter switch is in the same direction, which
+ would then incorrectly be treated as immediately switched before the
+ direction key that caused the switch was released) */
+
+ player->switch_x += jx - old_jx;
+ player->switch_y += jy - old_jy;
+ }
+#endif
}
void Explode(int ex, int ey, int phase, int mode)
action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
+ action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
+ action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
+ action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
EL_EMPTY);
int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
action_arg_number_min, action_arg_number_max);
#if 1
- int trigger_player_bits = change->actual_trigger_player_bits;
+ int trigger_player_bits =
+ (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
+ change->actual_trigger_player_bits : change->trigger_player);
#else
int trigger_player_bits =
(change->actual_trigger_player >= EL_PLAYER_1 &&
break;
}
+ case CA_SET_LEVEL_RANDOM_SEED:
+ {
+#if 1
+ /* ensure that setting a new random seed while playing is predictable */
+ InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
+#else
+ InitRND(action_arg_number_new);
+#endif
+
+#if 0
+ printf("::: %d -> %d\n", action_arg_number_new, RND(10));
+#endif
+
+#if 0
+ {
+ int i;
+
+ printf("::: ");
+ for (i = 0; i < 9; i++)
+ printf("%d, ", RND(2));
+ printf("\n");
+ }
+#endif
+
+ break;
+ }
+
/* ---------- player actions ------------------------------------------ */
case CA_MOVE_PLAYER:
case CA_SET_PLAYER_SPEED:
{
+#if 0
+ printf("::: trigger_player_bits == %d\n", trigger_player_bits);
+#endif
+
for (i = 0; i < MAX_PLAYERS; i++)
{
if (trigger_player_bits & (1 << i))
break;
}
+ case CA_SET_PLAYER_INVENTORY:
+ {
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ struct PlayerInfo *player = &stored_player[i];
+ int j, k;
+
+ if (trigger_player_bits & (1 << i))
+ {
+ int inventory_element = action_arg_element;
+
+ if (action_arg == CA_ARG_ELEMENT_TARGET ||
+ action_arg == CA_ARG_ELEMENT_TRIGGER ||
+ action_arg == CA_ARG_ELEMENT_ACTION)
+ {
+ int element = inventory_element;
+ int collect_count = element_info[element].collect_count_initial;
+
+ if (!IS_CUSTOM_ELEMENT(element))
+ collect_count = 1;
+
+ if (collect_count == 0)
+ player->inventory_infinite_element = element;
+ else
+ for (k = 0; k < collect_count; k++)
+ if (player->inventory_size < MAX_INVENTORY_SIZE)
+ player->inventory_element[player->inventory_size++] =
+ element;
+ }
+ else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
+ action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
+ action_arg == CA_ARG_INVENTORY_RM_ACTION)
+ {
+ if (player->inventory_infinite_element != EL_UNDEFINED &&
+ IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
+ action_arg_element_raw))
+ player->inventory_infinite_element = EL_UNDEFINED;
+
+ for (k = 0, j = 0; j < player->inventory_size; j++)
+ {
+ if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
+ action_arg_element_raw))
+ player->inventory_element[k++] = player->inventory_element[j];
+ }
+
+ player->inventory_size = k;
+ }
+ else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
+ {
+ if (player->inventory_size > 0)
+ {
+ for (j = 0; j < player->inventory_size - 1; j++)
+ player->inventory_element[j] = player->inventory_element[j + 1];
+
+ player->inventory_size--;
+ }
+ }
+ else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
+ {
+ if (player->inventory_size > 0)
+ player->inventory_size--;
+ }
+ else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
+ {
+ player->inventory_infinite_element = EL_UNDEFINED;
+ player->inventory_size = 0;
+ }
+ else if (action_arg == CA_ARG_INVENTORY_RESET)
+ {
+ player->inventory_infinite_element = EL_UNDEFINED;
+ player->inventory_size = 0;
+
+ if (level.use_initial_inventory[i])
+ {
+ for (j = 0; j < level.initial_inventory_size[i]; j++)
+ {
+ int element = level.initial_inventory_content[i][j];
+ int collect_count = element_info[element].collect_count_initial;
+
+ if (!IS_CUSTOM_ELEMENT(element))
+ collect_count = 1;
+
+ if (collect_count == 0)
+ player->inventory_infinite_element = element;
+ else
+ for (k = 0; k < collect_count; k++)
+ if (player->inventory_size < MAX_INVENTORY_SIZE)
+ player->inventory_element[player->inventory_size++] =
+ element;
+ }
+ }
+ }
+ }
+ }
+
+ break;
+ }
+
/* ---------- CE actions ---------------------------------------------- */
case CA_SET_CE_VALUE:
{
/* reset actual trigger element, trigger player and action element */
change->actual_trigger_element = EL_EMPTY;
- change->actual_trigger_player = EL_PLAYER_1;
- change->actual_trigger_player_bits = CH_PLAYER_1;
+ change->actual_trigger_player = EL_EMPTY;
+ change->actual_trigger_player_bits = CH_PLAYER_NONE;
change->actual_trigger_side = CH_SIDE_NONE;
change->actual_trigger_ce_value = 0;
change->actual_trigger_ce_score = 0;
int element = MovingOrBlocked2Element(x, y);
struct ElementInfo *ei = &element_info[element];
struct ElementChangeInfo *change = &ei->change_page[page];
+ boolean handle_action_before_change = FALSE;
#ifdef DEBUG
if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
return;
}
+#if 1
+ /* special case: set new level random seed before changing element */
+ if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
+ handle_action_before_change = TRUE;
+
+ if (change->has_action && handle_action_before_change)
+ ExecuteCustomElementAction(x, y, element, page);
+#endif
+
if (change->can_change)
{
if (ChangeElement(x, y, element, page))
}
}
- if (change->has_action)
+ if (change->has_action && !handle_action_before_change)
ExecuteCustomElementAction(x, y, element, page);
}
}
RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
+#if 0
+ printf("::: X: trigger_player_bits == %d\n", trigger_player);
+#endif
+
for (p = 0; p < element_info[element].num_change_pages; p++)
{
struct ElementChangeInfo *change = &element_info[element].change_page[p];
}
if (game.restart_level)
- StartGameActions(options.network, setup.autorecord, NEW_RANDOMIZE);
+ StartGameActions(options.network, setup.autorecord, level.random_seed);
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
game.set_centered_player = TRUE;
}
+#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ summarized_player_action |= stored_player[i].mapped_action;
+
+ if (!network_playing)
+ stored_player[i].effective_action = stored_player[i].mapped_action;
+ }
+#else
for (i = 0; i < MAX_PLAYERS; i++)
{
summarized_player_action |= stored_player[i].action;
if (!network_playing)
stored_player[i].effective_action = stored_player[i].action;
}
+#endif
#if defined(NETWORK_AVALIABLE)
if (network_playing)
(i == game.centered_player_nr ? summarized_player_action : 0);
}
+#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */
if (recorded_player_action != NULL)
for (i = 0; i < MAX_PLAYERS; i++)
- stored_player[i].effective_action = recorded_player_action[i];
+ stored_player[i].effective_action =
+ recorded_player_action[map_player_action[i]];
+#else
+ if (recorded_player_action != NULL)
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].effective_action =
+ recorded_player_action[i];
+#endif
for (i = 0; i < MAX_PLAYERS; i++)
{
+#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */
+ tape_action[i] = stored_player[i].action;
+#else
tape_action[i] = stored_player[i].effective_action;
+#endif
/* (this can only happen in the R'n'D game engine) */
if (tape.recording && tape_action[i] && !tape.player_participates[i])
if (tape.recording)
TapeRecordAction(tape_action);
+#if USE_NEW_PLAYER_ASSIGNMENTS
+ {
+#if 0
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].mapped_action = stored_player[map_player_action[i]].action;
+
+#else
+
+#if 1
+ byte unmapped_action[MAX_PLAYERS];
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ unmapped_action[i] = stored_player[i].effective_action;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].effective_action = unmapped_action[map_player_action[i]];
+#endif
+
+#if 0
+ for (i = 0; i < MAX_PLAYERS; i++)
+ printf("::: %d: %d [%d]\n", i, stored_player[i].effective_action,
+ map_player_action[i]);
+#endif
+#endif
+ }
+#else
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].mapped_action = stored_player[i].action;
+#endif
+
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
GameActions_EM_Main();
if (Feld[jx][jy] == EL_EXIT_OPEN ||
Feld[jx][jy] == EL_EM_EXIT_OPEN ||
+#if 1
+ Feld[jx][jy] == EL_EM_EXIT_OPENING ||
+#endif
Feld[jx][jy] == EL_STEEL_EXIT_OPEN ||
Feld[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
+#if 1
+ Feld[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
+#endif
Feld[jx][jy] == EL_SP_EXIT_OPEN ||
Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
{
if (!player->active)
return;
+#if 0
+ printf("::: 0: killed == %d, active == %d, reanimated == %d\n",
+ player->killed, player->active, player->reanimated);
+#endif
+
/* the following code was introduced to prevent an infinite loop when calling
-> Bang()
-> CheckTriggeredElementChangeExt()
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);
+#endif
+
Bang(jx, jy);
+#if 0
+ printf("::: 2: killed == %d, active == %d, reanimated == %d\n",
+ player->killed, player->active, player->reanimated);
+#endif
+
#if USE_PLAYER_REANIMATION
+#if 1
+ if (player->reanimated) /* killed player may have been reanimated */
+ player->killed = player->reanimated = FALSE;
+ else
+ BuryPlayer(player);
+#else
if (player->killed) /* player may have been reanimated */
BuryPlayer(player);
+#endif
#else
BuryPlayer(player);
#endif
}
else if (element == EL_EXIT_OPEN ||
element == EL_EM_EXIT_OPEN ||
+#if 1
+ element == EL_EM_EXIT_OPENING ||
+#endif
element == EL_STEEL_EXIT_OPEN ||
element == EL_EM_STEEL_EXIT_OPEN ||
+#if 1
+ element == EL_EM_STEEL_EXIT_OPENING ||
+#endif
element == EL_SP_EXIT_OPEN ||
element == EL_SP_EXIT_OPENING)
{