* graphics manipulation crap
*/
-#include "global.h"
-#include "display.h"
-#include "level.h"
+#include "main_em.h"
#define MIN_SCREEN_XPOS 1
#define MIN_SCREEN_YPOS 1
#define VALID_SCREEN_Y(y) ((y) < MIN_SCREEN_Y ? MIN_SCREEN_Y : \
(y) > MAX_SCREEN_Y ? MAX_SCREEN_Y : (y))
-#define PLAYER_SCREEN_X_F(p,f) ((( f) * ply[p].oldx + \
- (8 - f) * ply[p].x) * TILEX / 8 \
+#define PLAYER_SCREEN_X(p) ((( frame) * ply[p].oldx + \
+ (8 - frame) * ply[p].x) * TILEX / 8 \
- ((SCR_FIELDX - 1) * TILEX) / 2)
-#define PLAYER_SCREEN_Y_F(p,f) ((( f) * ply[p].oldy + \
- (8 - f) * ply[p].y) * TILEY / 8 \
+#define PLAYER_SCREEN_Y(p) ((( frame) * ply[p].oldy + \
+ (8 - frame) * ply[p].y) * TILEY / 8 \
- ((SCR_FIELDY - 1) * TILEY) / 2)
-#define PLAYER_SCREEN_X(p) PLAYER_SCREEN_X_F(p, frame)
-#define PLAYER_SCREEN_Y(p) PLAYER_SCREEN_Y_F(p, frame)
-
+#define USE_EXTENDED_GRAPHICS_ENGINE 0
int frame; /* current screen frame */
int screen_x; /* current scroll position */
static boolean redraw[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
+#if 0
+#if 1
+int centered_player_nr;
+#else
static int centered_player_nr;
+#endif
+#endif
-/* copy the entire screen to the window at the scroll position
- *
- * perhaps use mit-shm to speed this up
- */
+/* copy the entire screen to the window at the scroll position */
void BlitScreenToBitmap_EM(Bitmap *target_bitmap)
{
}
}
-void blitscreen(void)
+void BackToFront_EM(void)
{
-#if 1
-
static boolean scrolling_last = FALSE;
int left = screen_x / TILEX;
int top = screen_y / TILEY;
boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
int x, y;
-#if 0
SyncDisplay();
-#endif
if (redraw_tiles > REDRAWTILES_THRESHOLD || scrolling || scrolling_last)
{
}
}
+ FlushDisplay();
+
for (x = 0; x < MAX_BUF_XSIZE; x++)
for (y = 0; y < MAX_BUF_YSIZE; y++)
redraw[x][y] = FALSE;
redraw_tiles = 0;
scrolling_last = scrolling;
+}
-#else
-
- /* blit all (up to four) parts of the scroll buffer to the window */
- BlitScreenToBitmap_EM(window);
-
-#endif
+void blitscreen(void)
+{
+ BackToFront_EM();
}
static void DrawLevelField_EM(int x, int y, int sx, int sy,
{
int tile = Draw[y][x];
struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
+
+#if USE_EXTENDED_GRAPHICS_ENGINE
+ getGraphicSourceObjectExt_EM(tile, frame, &g->bitmap, &g->src_x, &g->src_y,
+ x - 2, y - 2);
+#endif
+
int src_x = g->src_x + g->src_offset_x;
int src_y = g->src_y + g->src_offset_y;
int dst_x = sx * TILEX + g->dst_offset_x;
int dst_y = sy * TILEY + g->dst_offset_y;
int width = g->width;
int height = g->height;
-
-#if 1
int left = screen_x / TILEX;
int top = screen_y / TILEY;
+ /* do not draw fields that are outside the visible screen area */
if (x < left || x >= left + MAX_BUF_XSIZE ||
y < top || y >= top + MAX_BUF_YSIZE)
return;
-#endif
if (draw_masked)
{
{
int tile = Draw[y][x];
struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
- int i;
-
-#if 1
int left = screen_x / TILEX;
int top = screen_y / TILEY;
+ int i;
+ /* do not draw fields that are outside the visible screen area */
if (x < left || x >= left + MAX_BUF_XSIZE ||
y < top || y >= top + MAX_BUF_YSIZE)
return;
-#endif
if (crm == 0) /* no crumbled edges for this tile */
return;
{
struct GraphicInfo_EM *g = &graphic_info_em_player[player_nr][anim][frame];
+#if USE_EXTENDED_GRAPHICS_ENGINE
+ getGraphicSourcePlayerExt_EM(player_nr, anim, frame,
+ &g->bitmap, &g->src_x, &g->src_y);
+#endif
+
int src_x = g->src_x, src_y = g->src_y;
int dst_x, dst_y;
-#if 1
+ /* do not draw fields that are outside the visible screen area */
if (x1 < screen_x - TILEX || x1 >= screen_x + MAX_BUF_XSIZE * TILEX ||
y1 < screen_y - TILEY || y1 >= screen_y + MAX_BUF_YSIZE * TILEY)
return;
x1 %= MAX_BUF_XSIZE * TILEX;
y1 %= MAX_BUF_YSIZE * TILEY;
-#endif
if (draw_masked)
{
/* draw differences between game tiles and screen tiles
*
* implicitly handles scrolling and restoring background under the sprites
- *
- * perhaps use mit-shm to speed this up
*/
static void animscreen(void)
}
/* only redraw screen tiles if they (or their crumbled state) changed */
+#if USE_EXTENDED_GRAPHICS_ENGINE
+ // if (screentiles[sy][sx] != obj || crumbled_state[sy][sx] != crm)
+#else
if (screentiles[sy][sx] != obj || crumbled_state[sy][sx] != crm)
+#endif
{
DrawLevelField_EM(x, y, sx, sy, FALSE);
DrawLevelFieldCrumbled_EM(x, y, sx, sy, crm, FALSE);
DrawLevelField_EM(new_x, new_y, new_sx, new_sy, TRUE);
}
- /* mark screen tiles as dirty */
+ /* redraw screen tiles in the next frame (player may have left the tiles) */
screentiles[old_sy][old_sx] = -1;
screentiles[new_sy][new_sx] = -1;
+
+ /* mark screen tiles as dirty (force screen refresh with changed content) */
+ redraw[old_sx][old_sy] = TRUE;
+ redraw[new_sx][new_sy] = TRUE;
+ redraw_tiles += 2;
}
}
int x,y;
int dynamite_state = ply[0].dynamite; /* !!! ONLY PLAYER 1 !!! */
int all_keys_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
-#if 1
int player_nr;
-#else
-#if 1
- int player_nr = getCenteredPlayerNr_EM();
-#else
- int player_nr = 0; /* !!! FIX THIS (CENTERED TO PLAYER 1) !!! */
-#endif
-#endif
- centered_player_nr = getCenteredPlayerNr_EM();
+ frame = 6;
- player_nr = (centered_player_nr != -1 ? centered_player_nr : 0);
+#if 0
+ game.centered_player_nr = getCenteredPlayerNr_EM();
+#endif
+
+ player_nr = (game.centered_player_nr != -1 ? game.centered_player_nr : 0);
- frame = 6;
-#if 1
screen_x = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
screen_y = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
-#else
- screen_x = 0;
- screen_y = 0;
-#endif
for (y = 0; y < MAX_BUF_YSIZE; y++)
{
}
}
-#if 1
DrawAllGameValues(lev.required, dynamite_state, lev.score,
lev.time, all_keys_state);
-#else
- DrawAllGameValues(lev.required, ply1.dynamite, lev.score,
- DISPLAY_TIME(lev.time + 4), ply1.keys | ply2.keys);
-#endif
}
#if 0
if (quick_relocation)
{
- int offset = (setup.scroll_delay ? 3 : 0);
+ int offset = game.scroll_delay_value;
if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
{
}
#endif
-void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
+static int getMaxCenterDistancePlayerNr(int center_x, int center_y)
{
- boolean num_checked_players = 0;
+ int max_dx = 0, max_dy = 0;
+ int player_nr = game_em.last_moving_player;
int i;
for (i = 0; i < MAX_PLAYERS; i++)
{
if (ply[i].alive)
{
-#if 0
- int sx = PLAYER_SCREEN_X_F(i, 0);
- int sy = PLAYER_SCREEN_Y_F(i, 0);
-#else
int sx = PLAYER_SCREEN_X(i);
int sy = PLAYER_SCREEN_Y(i);
-#endif
-#if 0
- /* round player position to full tile */
- sx = (sx / TILEX) * TILEX;
- sy = (sy / TILEY) * TILEY;
-#endif
+ if (game_em.last_player_direction[i] != MV_NONE &&
+ (ABS(sx - center_x) > max_dx ||
+ ABS(sy - center_y) > max_dy))
+ {
+ max_dx = MAX(max_dx, ABS(sx - center_x));
+ max_dy = MAX(max_dy, ABS(sy - center_y));
+
+ player_nr = i;
+ }
+ }
+ }
+
+ return player_nr;
+}
+
+static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
+{
+ boolean num_checked_players = 0;
+ int i;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (ply[i].alive)
+ {
+ int sx = PLAYER_SCREEN_X(i);
+ int sy = PLAYER_SCREEN_Y(i);
if (num_checked_players == 0)
{
sy2 - sy1 <= SCR_FIELDY * TILEY);
}
-void setScreenCenteredToAllPlayers(int *sx, int *sy)
+static void setScreenCenteredToAllPlayers(int *sx, int *sy)
{
int sx1 = screen_x, sy1 = screen_y, sx2 = screen_x, sy2 = screen_y;
*sy = (sy1 + sy2) / 2;
}
-void setMaxCenterDistanceForAllPlayers(int *max_dx, int *max_dy)
+static void setMaxCenterDistanceForAllPlayers(int *max_dx, int *max_dy,
+ int center_x, int center_y)
{
- int sx1 = screen_x, sy1 = screen_y, sx2 = screen_x, sy2 = screen_y;
+ int sx1 = center_x, sy1 = center_y, sx2 = center_x, sy2 = center_y;
setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
- *max_dx = MAX(ABS(sx1 - screen_x), ABS(sx2 - screen_x));
- *max_dy = MAX(ABS(sy1 - screen_y), ABS(sy2 - screen_y));
+ *max_dx = MAX(ABS(sx1 - center_x), ABS(sx2 - center_x));
+ *max_dy = MAX(ABS(sy1 - center_y), ABS(sy2 - center_y));
}
-boolean checkIfAllPlayersAreVisible()
+static boolean checkIfAllPlayersAreVisible(int center_x, int center_y)
{
int max_dx, max_dy;
- setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy);
+ setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy, center_x, center_y);
return (max_dx <= SCR_FIELDX * TILEX / 2 &&
max_dy <= SCR_FIELDY * TILEY / 2);
void RedrawPlayfield_EM(boolean force_redraw)
{
-#if 1
- int centered_player_nr_next = getCenteredPlayerNr_EM();
#if 0
- int player_nr;
-#endif
boolean all_players_visible = checkIfAllPlayersAreVisible();
- boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen();
+#endif
boolean draw_new_player_location = FALSE;
boolean quick_relocation = setup.quick_switch;
+#if 0
+ boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
+#endif
+#if 0
+ boolean game.set_centered_player = getSetCenteredPlayer_EM();
+ int game.centered_player_nr_next = getCenteredPlayerNr_EM();
+#endif
+#if 1
+ int max_center_distance_player_nr =
+ getMaxCenterDistancePlayerNr(screen_x, screen_y);
#else
- int player_nr = 0; /* !!! FIX THIS (CENTERED TO PLAYER 1) !!! */
+ int player_nr = game_em.last_moving_player;
#endif
- int offset = (setup.scroll_delay ? 3 : 0) * TILEX;
+ int stepsize = TILEX / 8;
+ int offset = game.scroll_delay_value * TILEX;
int offset_x = offset;
int offset_y = offset;
int screen_x_old = screen_x;
int x, y, sx, sy;
int i;
-#if 0
- player_nr = (centered_player_nr_next != -1 ? centered_player_nr_next :0);
-
- sx = PLAYER_SCREEN_X(player_nr);
- sy = PLAYER_SCREEN_Y(player_nr);
-#endif
-
- if (centered_player_nr_next == -1 && !all_players_fit_to_screen)
+ if (game.set_centered_player)
{
- setCenteredPlayerNr_EM(centered_player_nr);
+ boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen();
+
+ /* switching to "all players" only possible if all players fit to screen */
+ if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
+ {
+ game.centered_player_nr_next = game.centered_player_nr;
+ game.set_centered_player = FALSE;
+ }
- centered_player_nr_next = centered_player_nr;
+ /* do not switch focus to non-existing (or non-active) player */
+ if (game.centered_player_nr_next >= 0 &&
+ !ply[game.centered_player_nr_next].alive)
+ {
+ game.centered_player_nr_next = game.centered_player_nr;
+ game.set_centered_player = FALSE;
+ }
}
#if 1
- boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
-
-#if 0
+ /* also allow focus switching when screen is scrolled to half tile */
+#else
if (!scrolling) /* screen currently aligned at tile position */
#endif
{
- if (centered_player_nr != centered_player_nr_next)
+#if 1
+ if (game.set_centered_player)
+#else
+ if (game.centered_player_nr != game.centered_player_nr_next)
+#endif
{
- centered_player_nr = centered_player_nr_next;
+ game.centered_player_nr = game.centered_player_nr_next;
draw_new_player_location = TRUE;
force_redraw = TRUE;
+
+ game.set_centered_player = FALSE;
}
}
-#endif
-#if 1
- if (centered_player_nr == -1)
+ if (game.centered_player_nr == -1)
{
- int max_dx, max_dy;
-
#if 1
+ if (draw_new_player_location || offset == 0)
+#else
if (draw_new_player_location)
+#endif
+ {
setScreenCenteredToAllPlayers(&sx, &sy);
+ }
else
{
+#if 1
+ sx = PLAYER_SCREEN_X(max_center_distance_player_nr);
+ sy = PLAYER_SCREEN_Y(max_center_distance_player_nr);
+#else
sx = PLAYER_SCREEN_X(game_em.last_moving_player);
sy = PLAYER_SCREEN_Y(game_em.last_moving_player);
- }
-
-#else
-
-#if 0
- setScreenCenteredToAllPlayers(&sx, &sy);
#endif
-
-#if 1
- sx = PLAYER_SCREEN_X(game_em.last_moving_player);
- sy = PLAYER_SCREEN_Y(game_em.last_moving_player);
-#endif
-#endif
-
-#if 0
- printf("::: %d\n", all_players_visible);
-
- if (!all_players_visible)
- {
- sx = screen_x;
- sy = screen_y;
-
- offset_x = 0;
- offset_y = 0;
}
-#endif
+ }
+ else
+ {
+ sx = PLAYER_SCREEN_X(game.centered_player_nr);
+ sy = PLAYER_SCREEN_Y(game.centered_player_nr);
+ }
+
+ if (draw_new_player_location && quick_relocation)
+ {
+ screen_x = VALID_SCREEN_X(sx);
+ screen_y = VALID_SCREEN_Y(sy);
+ screen_x_old = screen_x;
+ screen_y_old = screen_y;
#if 0
-#if 1
offset_x = 0;
offset_y = 0;
-#else
- setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy);
-
- if (max_dx > offset_x)
- offset_x = MAX(0, offset_x - (max_dx - offset_x));
- if (max_dy > offset_y)
- offset_y = MAX(0, offset_y - (max_dy - offset_y));
-#endif
#endif
}
- else
- {
- sx = PLAYER_SCREEN_X(centered_player_nr);
- sy = PLAYER_SCREEN_Y(centered_player_nr);
- }
-#endif
if (draw_new_player_location && !quick_relocation)
{
unsigned long game_frame_delay_value = getGameFrameDelay_EM(25);
#endif
int wait_delay_value = game_frame_delay_value;
-#if 1
int screen_xx = VALID_SCREEN_X(sx);
int screen_yy = VALID_SCREEN_Y(sy);
-#else
- int screen_xx = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
- int screen_yy = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
-#endif
while (screen_x != screen_xx || screen_y != screen_yy)
{
if (dx == 0 && dy == 0) /* no scrolling needed at all */
break;
+#if 1
+
+ if (ABS(screen_xx - screen_x) >= TILEX)
+ {
+ screen_x -= dx * TILEX;
+ dxx = dx * TILEX / 2;
+ }
+ else
+ {
+ screen_x = screen_xx;
+ dxx = 0;
+ }
+
+ if (ABS(screen_yy - screen_y) >= TILEY)
+ {
+ screen_y -= dy * TILEY;
+ dyy = dy * TILEY / 2;
+ }
+ else
+ {
+ screen_y = screen_yy;
+ dyy = 0;
+ }
+
+#else
+
#if 1
if (ABS(screen_xx - screen_x) >= TILEX ||
ABS(screen_yy - screen_y) >= TILEY)
dxx += dx * TILEX / 2;
dyy += dy * TILEY / 2;
+#endif
+
#endif
/* scroll in two steps of half tile size to make things smoother */
blitplayer(&ply[i]);
blitscreen();
- FlushDisplay();
+
Delay(wait_delay_value);
/* scroll second step to align at full tile size */
screen_x -= dxx;
screen_y -= dyy;
+#if 0
SyncDisplay();
+#endif
animscreen();
blitplayer(&ply[i]);
blitscreen();
- FlushDisplay();
+
Delay(wait_delay_value);
}
sy - offset_y > screen_y ? sy - offset_y :
screen_y);
+#if 0
+ printf("::: (%d, %d) => (%d, %d) [(%d, %d), (%d, %d)] [%d, %d] [%d / %d]\n",
+ screen_x_old, screen_y_old,
+ screen_x, screen_y,
+ ply[max_center_distance_player_nr].oldx,
+ ply[max_center_distance_player_nr].x,
+ ply[max_center_distance_player_nr].oldy,
+ ply[max_center_distance_player_nr].y,
+ sx, sy,
+ ABS(screen_x - screen_x_old),
+ ABS(screen_y - screen_y_old));
+#endif
+
+#if 1
+
#if 1
- /* prevent scrolling further than player step size screen when scrolling */
- if (ABS(screen_x - screen_x_old) > TILEX / 8 ||
- ABS(screen_y - screen_y_old) > TILEY / 8)
+ /* prevent scrolling further than double player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > 2 * stepsize)
+ {
+ int dx = SIGN(screen_x - screen_x_old);
+
+ screen_x = screen_x_old + dx * 2 * stepsize;
+ }
+ if (ABS(screen_y - screen_y_old) > 2 * stepsize)
+ {
+ int dy = SIGN(screen_y - screen_y_old);
+
+ screen_y = screen_y_old + dy * 2 * stepsize;
+ }
+#else
+ /* prevent scrolling further than double player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > 2 * stepsize ||
+ ABS(screen_y - screen_y_old) > 2 * stepsize)
{
int dx = SIGN(screen_x - screen_x_old);
int dy = SIGN(screen_y - screen_y_old);
- screen_x = screen_x_old + dx * TILEX / 8;
- screen_y = screen_y_old + dy * TILEY / 8;
+ screen_x = screen_x_old + dx * 2 * stepsize;
+ screen_y = screen_y_old + dy * 2 * stepsize;
}
#endif
-#if 1
- if (centered_player_nr == -1)
+#else
+ /* prevent scrolling further than player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > stepsize ||
+ ABS(screen_y - screen_y_old) > stepsize)
{
- boolean all_players_visible_old = all_players_visible;
-
- all_players_visible = checkIfAllPlayersAreVisible();
+ int dx = SIGN(screen_x - screen_x_old);
+ int dy = SIGN(screen_y - screen_y_old);
-#if 0
- printf("::: OLD(%d) -> NEW(%d) / OLD(%d, %d) -> NEW(%d, %d)\n",
- all_players_visible_old,
- all_players_visible,
- screen_x_old, screen_y_old,
- screen_x, screen_y);
+ screen_x = screen_x_old + dx * stepsize;
+ screen_y = screen_y_old + dy * stepsize;
+ }
#endif
+ /* prevent scrolling away from the other players when focus on all players */
+ if (game.centered_player_nr == -1)
+ {
+#if 1
+ /* check if all players are still visible with new scrolling position */
+ if (checkIfAllPlayersAreVisible(screen_x_old, screen_y_old) &&
+ !checkIfAllPlayersAreVisible(screen_x, screen_y))
+ {
+ /* reset horizontal scroll position to last value, if needed */
+ if (!checkIfAllPlayersAreVisible(screen_x, screen_y_old))
+ screen_x = screen_x_old;
+
+ /* reset vertical scroll position to last value, if needed */
+ if (!checkIfAllPlayersAreVisible(screen_x_old, screen_y))
+ screen_y = screen_y_old;
+ }
+#else
+ boolean all_players_visible = checkIfAllPlayersAreVisible();
+
if (!all_players_visible)
{
+ printf("::: not all players visible\n");
+
screen_x = screen_x_old;
screen_y = screen_y_old;
}
- }
#endif
+ }
-#if 1
- /* prevent scrolling if no player is moving */
+ /* prevent scrolling (for screen correcting) if no player is moving */
if (!game_em.any_player_moving)
{
screen_x = screen_x_old;
else
{
/* prevent scrolling against the players move direction */
+#if 0
int player_nr = game_em.last_moving_player;
+#endif
+ int player_nr = (game.centered_player_nr == -1 ?
+ max_center_distance_player_nr : game.centered_player_nr);
int player_move_dir = game_em.last_player_direction[player_nr];
int dx = SIGN(screen_x - screen_x_old);
int dy = SIGN(screen_y - screen_y_old);
- if (dx < 0 && player_move_dir == MV_RIGHT ||
- dx > 0 && player_move_dir == MV_LEFT)
+ if ((dx < 0 && player_move_dir != MV_LEFT) ||
+ (dx > 0 && player_move_dir != MV_RIGHT))
screen_x = screen_x_old;
- if (dy < 0 && player_move_dir == MV_DOWN ||
- dy > 0 && player_move_dir == MV_UP)
+ if ((dy < 0 && player_move_dir != MV_UP) ||
+ (dy > 0 && player_move_dir != MV_DOWN))
screen_y = screen_y_old;
}
-#endif
animscreen();
for (i = 0; i < MAX_PLAYERS; i++)
blitplayer(&ply[i]);
+#if 0
+#if 0
SyncDisplay();
+#endif
blitscreen();
-
- FlushDisplay();
+#endif
}
void game_animscreen(void)
void DrawGameDoorValues_EM()
{
+#if 1
+ int dynamite_state;
+ int key_state;
+#else
int dynamite_state = ply[0].dynamite; /* !!! ONLY PLAYER 1 !!! */
- int all_keys_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
+ int key_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
+#endif
+
+#if 1
+ if (game.centered_player_nr == -1)
+ {
+#if 1
+ int i;
+
+ dynamite_state = 0;
+ key_state = 0;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ dynamite_state += ply[i].dynamite;
+ key_state |= ply[i].keys;
+ }
+
+#else
+
+ dynamite_state = ply[0].dynamite; /* !!! ONLY PLAYER 1 !!! */
+ key_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
+#endif
+ }
+ else
+ {
+ int player_nr = game.centered_player_nr;
+
+ dynamite_state = ply[player_nr].dynamite;
+ key_state = ply[player_nr].keys;
+ }
+#endif
#if 1
DrawAllGameValues(lev.required, dynamite_state, lev.score,
- lev.time, all_keys_state);
+ lev.time, key_state);
#else
DrawAllGameValues(lev.required, ply1.dynamite, lev.score,
DISPLAY_TIME(lev.time), ply1.keys | ply2.keys);
projects / rocksndiamonds.git / blobdiff