#define NUM_TOOL_BUTTONS 7
/* forward declaration for internal use */
+static int getGraphicAnimationPhase(int, int, int);
static void UnmapToolButtons();
static void HandleToolButtons(struct GadgetInfo *);
if (redraw_mask & REDRAW_FIELD)
redraw_mask &= ~REDRAW_TILES;
- /*
- if (redraw_mask & REDRAW_FIELD ||
- (ScreenGfxPos && setup.soft_scrolling && game_status == PLAYING))
- redraw_mask &= ~REDRAW_TILES;
- */
-
if (!redraw_mask)
return;
XSync(display, FALSE);
- /*
-#ifdef MSDOS
- wait_for_vsync = TRUE;
-#endif
- */
-
if (redraw_mask & REDRAW_ALL)
{
- XCopyArea(display,backbuffer,window,gc,
- 0,0, WIN_XSIZE,WIN_YSIZE,
- 0,0);
+ XCopyArea(display, backbuffer, window, gc,
+ 0, 0, WIN_XSIZE, WIN_YSIZE,
+ 0, 0);
redraw_mask = 0;
}
{
if (game_status != PLAYING || redraw_mask & REDRAW_FROM_BACKBUFFER)
{
- XCopyArea(display,backbuffer,window,gc,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
+ XCopyArea(display, backbuffer, window, gc,
+ REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
+ REAL_SX, REAL_SY);
}
else
{
if (redraw_mask & REDRAW_DOORS)
{
if (redraw_mask & REDRAW_DOOR_1)
- XCopyArea(display,backbuffer,window,gc,
- DX,DY, DXSIZE,DYSIZE,
- DX,DY);
+ XCopyArea(display, backbuffer, window, gc,
+ DX, DY, DXSIZE, DYSIZE,
+ DX, DY);
if (redraw_mask & REDRAW_DOOR_2)
{
if ((redraw_mask & REDRAW_DOOR_2) == REDRAW_DOOR_2)
redraw_mask |= REDRAW_FIELD;
}
+int getFontWidth(int font_size, int font_type)
+{
+ return (font_size == FS_BIG ? FONT1_XSIZE :
+ font_type == FC_SPECIAL1 ? FONT3_XSIZE :
+ font_type == FC_SPECIAL2 ? FONT4_XSIZE :
+ font_type == FC_SPECIAL3 ? FONT5_XSIZE :
+ FONT2_XSIZE);
+}
+
+int getFontHeight(int font_size, int font_type)
+{
+ return (font_size == FS_BIG ? FONT1_YSIZE :
+ font_type == FC_SPECIAL1 ? FONT3_YSIZE :
+ font_type == FC_SPECIAL2 ? FONT4_YSIZE :
+ font_type == FC_SPECIAL3 ? FONT5_YSIZE :
+ FONT2_YSIZE);
+}
+
void DrawTextFCentered(int y, int font_type, char *format, ...)
{
- char buffer[FULL_SXSIZE / FONT3_XSIZE + 10];
- int font_xsize;
+ char buffer[FULL_SXSIZE / FONT5_XSIZE + 10];
+ int font_width = getFontWidth(FS_SMALL, font_type);
va_list ap;
- font_xsize = (font_type < FC_SPECIAL1 ? FONT2_XSIZE :
- font_type < FC_SPECIAL2 ? FONT3_XSIZE : FONT4_XSIZE);
-
va_start(ap, format);
vsprintf(buffer, format, ap);
va_end(ap);
- DrawText(SX + (SXSIZE - strlen(buffer) * font_xsize) / 2, SY + y,
+ DrawText(SX + (SXSIZE - strlen(buffer) * font_width) / 2, SY + y,
buffer, FS_SMALL, font_type);
}
void DrawTextF(int x, int y, int font_type, char *format, ...)
{
- char buffer[FULL_SXSIZE / FONT3_XSIZE + 10];
+ char buffer[FULL_SXSIZE / FONT5_XSIZE + 10];
va_list ap;
va_start(ap, format);
if (font_size != FS_SMALL && font_size != FS_BIG)
font_size = FS_SMALL;
- if (font_type < FC_RED || font_type > FC_SPECIAL2)
+ if (font_type < FC_RED || font_type > FC_SPECIAL3)
font_type = FC_RED;
- font_width = (font_size == FS_BIG ? FONT1_XSIZE :
- font_type < FC_SPECIAL1 ? FONT2_XSIZE :
- font_type < FC_SPECIAL2 ? FONT3_XSIZE : FONT4_XSIZE);
- font_height = (font_size == FS_BIG ? FONT1_XSIZE :
- font_type < FC_SPECIAL2 ? FONT2_XSIZE : FONT4_XSIZE);
+ font_width = getFontWidth(font_size, font_type);
+ font_height = getFontHeight(font_size, font_type);
+
font_pixmap = (font_size == FS_BIG ? PIX_BIGFONT : PIX_SMALLFONT);
font_start = (font_type * (font_size == FS_BIG ? FONT1_YSIZE : FONT2_YSIZE) *
FONT_LINES_PER_FONT);
+ if (font_type == FC_SPECIAL3)
+ font_start += (FONT4_YSIZE - FONT2_YSIZE) * FONT_LINES_PER_FONT;
+
while (*text)
{
char c = *text++;
- if (c == '~' && font_size == FS_SMALL && font_type <= FC_YELLOW)
+ if (c == '~' && font_size == FS_SMALL)
{
print_inverse = TRUE;
continue;
XSetClipOrigin(display, clip_gc[font_pixmap],
dest_x - src_x, dest_y - src_y);
- XCopyArea(display, pix[font_pixmap], drawto, clip_gc[font_pixmap],
+ XCopyArea(display, pix[font_pixmap], d, clip_gc[font_pixmap],
0, 0, font_width, font_height, dest_x, dest_y);
}
else
void DrawPlayerField(int x, int y)
{
- if (!IS_PLAYER(x,y))
+ if (!IS_PLAYER(x, y))
return;
- DrawPlayer(PLAYERINFO(x,y));
+ DrawPlayer(PLAYERINFO(x, y));
}
void DrawPlayer(struct PlayerInfo *player)
int next_jx = jx + (jx - last_jx), next_jy = jy + (jy - last_jy);
int sx = SCREENX(jx), sy = SCREENY(jy);
int sxx = 0, syy = 0;
- int element = Feld[jx][jy];
+ int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
int graphic, phase;
+ boolean player_is_moving = (last_jx != jx || last_jy != jy ? TRUE : FALSE);
- if (!player->active || player->gone ||
- !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
+ if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
return;
#if DEBUG
/* draw things in the field the player is leaving, if needed */
- if (last_jx != jx || last_jy != jy)
+ if (player_is_moving)
{
- if (Store[last_jx][last_jy])
+ if (Store[last_jx][last_jy] && IS_DRAWABLE(last_element))
{
DrawLevelElement(last_jx, last_jy, Store[last_jx][last_jy]);
DrawLevelFieldThruMask(last_jx, last_jy);
}
- else if (Feld[last_jx][last_jy] == EL_DYNAMIT)
+ else if (last_element == EL_DYNAMITE_ACTIVE)
DrawDynamite(last_jx, last_jy);
else
DrawLevelField(last_jx, last_jy);
if (Store[jx][jy])
DrawLevelElement(jx, jy, Store[jx][jy]);
- else if (element != EL_DYNAMIT && element != EL_DYNABOMB)
+ else if (!IS_ACTIVE_BOMB(element))
DrawLevelField(jx, jy);
/* draw player himself */
- if (player->MovDir == MV_LEFT)
- graphic = (player->Pushing ? GFX_SPIELER1_PUSH_LEFT : GFX_SPIELER1_LEFT);
- else if (player->MovDir == MV_RIGHT)
- graphic = (player->Pushing ? GFX_SPIELER1_PUSH_RIGHT : GFX_SPIELER1_RIGHT);
- else if (player->MovDir == MV_UP)
- graphic = GFX_SPIELER1_UP;
- else /* MV_DOWN || MV_NO_MOVING */
- graphic = GFX_SPIELER1_DOWN;
+ if (game.emulation == EMU_SUPAPLEX)
+ {
+ static int last_dir = MV_LEFT;
+ int action = (player->programmed_action ? player->programmed_action :
+ player->action);
+ boolean action_moving =
+ (player_is_moving ||
+ ((action & (MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN)) &&
+ !(action & ~(MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN))));
+
+ graphic = GFX_SP_MURPHY;
+
+ if (player->Pushing)
+ {
+ if (player->MovDir == MV_LEFT)
+ graphic = GFX_MURPHY_PUSH_LEFT;
+ else if (player->MovDir == MV_RIGHT)
+ graphic = GFX_MURPHY_PUSH_RIGHT;
+ else if (player->MovDir & (MV_UP | MV_DOWN) && last_dir == MV_LEFT)
+ graphic = GFX_MURPHY_PUSH_LEFT;
+ else if (player->MovDir & (MV_UP | MV_DOWN) && last_dir == MV_RIGHT)
+ graphic = GFX_MURPHY_PUSH_RIGHT;
+ }
+ else if (player->snapped)
+ {
+ if (player->MovDir == MV_LEFT)
+ graphic = GFX_MURPHY_SNAP_LEFT;
+ else if (player->MovDir == MV_RIGHT)
+ graphic = GFX_MURPHY_SNAP_RIGHT;
+ else if (player->MovDir == MV_UP)
+ graphic = GFX_MURPHY_SNAP_UP;
+ else if (player->MovDir == MV_DOWN)
+ graphic = GFX_MURPHY_SNAP_DOWN;
+ }
+ else if (action_moving)
+ {
+ if (player->MovDir == MV_LEFT)
+ graphic = GFX_MURPHY_GO_LEFT;
+ else if (player->MovDir == MV_RIGHT)
+ graphic = GFX_MURPHY_GO_RIGHT;
+ else if (player->MovDir & (MV_UP | MV_DOWN) && last_dir == MV_LEFT)
+ graphic = GFX_MURPHY_GO_LEFT;
+ else if (player->MovDir & (MV_UP | MV_DOWN) && last_dir == MV_RIGHT)
+ graphic = GFX_MURPHY_GO_RIGHT;
+
+ graphic += getGraphicAnimationPhase(3, 2, ANIM_OSCILLATE);
+ }
+
+ if (player->MovDir == MV_LEFT || player->MovDir == MV_RIGHT)
+ last_dir = player->MovDir;
+ }
+ else
+ {
+ if (player->MovDir == MV_LEFT)
+ graphic =
+ (player->Pushing ? GFX_SPIELER1_PUSH_LEFT : GFX_SPIELER1_LEFT);
+ else if (player->MovDir == MV_RIGHT)
+ graphic =
+ (player->Pushing ? GFX_SPIELER1_PUSH_RIGHT : GFX_SPIELER1_RIGHT);
+ else if (player->MovDir == MV_UP)
+ graphic = GFX_SPIELER1_UP;
+ else /* MV_DOWN || MV_NO_MOVING */
+ graphic = GFX_SPIELER1_DOWN;
- graphic += player->index_nr * 3*HEROES_PER_LINE;
- graphic += player->Frame;
+ graphic += player->index_nr * 3 * HEROES_PER_LINE;
+ graphic += player->Frame;
+ }
if (player->GfxPos)
{
{
int px = SCREENX(next_jx), py = SCREENY(next_jy);
- if (Feld[jx][jy] == EL_SOKOBAN_FELD_LEER ||
+ if (element == EL_SOKOBAN_FELD_LEER ||
Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL)
DrawGraphicShiftedThruMask(px, py, sxx, syy, GFX_SOKOBAN_OBJEKT,
NO_CUTTING);
int element = Feld[next_jx][next_jy];
int graphic = el2gfx(element);
- if (element == EL_FELSBROCKEN && sxx)
+ if ((element == EL_FELSBROCKEN || element == EL_SP_ZONK) && sxx)
{
- int phase = (player->GfxPos / (TILEX/4));
+ int phase = (player->GfxPos / (TILEX / 4));
if (player->MovDir == MV_LEFT)
graphic += phase;
else
- graphic += (phase+4)%4;
+ graphic += (phase + 4) % 4;
}
DrawGraphicShifted(px, py, sxx, syy, graphic, NO_CUTTING, NO_MASKING);
}
}
- /* draw things in front of player (EL_DYNAMIT || EL_DYNABOMB) */
+ /* draw things in front of player (active dynamite or dynabombs) */
- if (element == EL_DYNAMIT || element == EL_DYNABOMB)
+ if (IS_ACTIVE_BOMB(element))
{
graphic = el2gfx(element);
- if (element == EL_DYNAMIT)
+ if (element == EL_DYNAMITE_ACTIVE)
{
if ((phase = (96 - MovDelay[jx][jy]) / 12) > 6)
phase = 6;
phase = 7 - phase;
}
- if (game_emulation == EMU_SUPAPLEX)
+ if (game.emulation == EMU_SUPAPLEX)
DrawGraphic(sx, sy, GFX_SP_DISK_RED);
else
DrawGraphicThruMask(sx, sy, graphic + phase);
}
- if ((last_jx != jx || last_jy != jy) &&
- Feld[last_jx][last_jy] == EL_EXPLODING)
+ if (player_is_moving && last_element == EL_EXPLODING)
{
int phase = Frame[last_jx][last_jy];
int delay = 2;
GFX_EXPLOSION + ((phase - 1) / delay - 1));
}
+ /* draw elements that stay over the player */
+ /* handle the field the player is leaving ... */
+ if (player_is_moving && IS_OVER_PLAYER(last_element))
+ DrawLevelField(last_jx, last_jy);
+ /* ... and the field the player is entering */
+ if (IS_OVER_PLAYER(element))
+ DrawLevelField(jx, jy);
+
if (setup.direct_draw)
{
int dest_x = SX + SCREENX(MIN(jx, last_jx)) * TILEX;
DrawGraphicAnimationExt(x, y, graphic, frames, delay, mode, USE_MASKING);
}
+void getGraphicSource(int graphic, int *pixmap_nr, int *x, int *y)
+{
+ if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
+ {
+ graphic -= GFX_START_ROCKSSCREEN;
+ *pixmap_nr = PIX_BACK;
+ *x = SX + (graphic % GFX_PER_LINE) * TILEX;
+ *y = SY + (graphic / GFX_PER_LINE) * TILEY;
+ }
+ else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
+ {
+ graphic -= GFX_START_ROCKSHEROES;
+ *pixmap_nr = PIX_HEROES;
+ *x = (graphic % HEROES_PER_LINE) * TILEX;
+ *y = (graphic / HEROES_PER_LINE) * TILEY;
+ }
+ else if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
+ {
+ graphic -= GFX_START_ROCKSSP;
+ *pixmap_nr = PIX_SP;
+ *x = (graphic % SP_PER_LINE) * TILEX;
+ *y = (graphic / SP_PER_LINE) * TILEY;
+ }
+ else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC)
+ {
+ graphic -= GFX_START_ROCKSDC;
+ *pixmap_nr = PIX_DC;
+ *x = (graphic % DC_PER_LINE) * TILEX;
+ *y = (graphic / DC_PER_LINE) * TILEY;
+ }
+ else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
+ {
+ graphic -= GFX_START_ROCKSFONT;
+ *pixmap_nr = PIX_BIGFONT;
+ *x = (graphic % FONT_CHARS_PER_LINE) * TILEX;
+ *y = ((graphic / FONT_CHARS_PER_LINE) * TILEY +
+ FC_SPECIAL1 * FONT_LINES_PER_FONT * TILEY);
+ }
+ else
+ {
+ *pixmap_nr = PIX_SP;
+ *x = 0;
+ *y = 0;
+ }
+}
+
void DrawGraphic(int x, int y, int graphic)
{
#if DEBUG
void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
{
- if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
- {
- graphic -= GFX_START_ROCKSSCREEN;
- XCopyArea(display, pix[PIX_BACK], d, gc,
- SX + (graphic % GFX_PER_LINE) * TILEX,
- SY + (graphic / GFX_PER_LINE) * TILEY,
- TILEX, TILEY, x, y);
- }
- else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
- {
- graphic -= GFX_START_ROCKSMORE;
- XCopyArea(display, pix[PIX_MORE], d, gc,
- (graphic % MORE_PER_LINE) * TILEX,
- (graphic / MORE_PER_LINE) * TILEY,
- TILEX, TILEY, x, y);
- }
- else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
- {
- graphic -= GFX_START_ROCKSHEROES;
- XCopyArea(display, pix[PIX_HEROES], d, gc,
- (graphic % HEROES_PER_LINE) * TILEX,
- (graphic / HEROES_PER_LINE) * TILEY,
- TILEX, TILEY, x, y);
- }
- else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
- {
- graphic -= GFX_START_ROCKSFONT;
- XCopyArea(display, pix[PIX_BIGFONT], d, gc,
- (graphic % FONT_CHARS_PER_LINE) * TILEX,
- (graphic / FONT_CHARS_PER_LINE) * TILEY +
- FC_SPECIAL1 * FONT_LINES_PER_FONT * TILEY,
- TILEX, TILEY, x, y);
- }
- else
- XFillRectangle(display, d, gc, x, y, TILEX, TILEY);
+ int pixmap_nr;
+ int src_x, src_y;
+
+ getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y);
+ XCopyArea(display, pix[pixmap_nr], d, gc,
+ src_x, src_y, TILEX, TILEY, x, y);
}
void DrawGraphicThruMask(int x, int y, int graphic)
void DrawGraphicThruMaskExt(Drawable d, int dest_x, int dest_y, int graphic)
{
- int src_x, src_y;
int tile = graphic;
+ int pixmap_nr;
+ int src_x, src_y;
Pixmap src_pixmap;
GC drawing_gc;
- if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
- {
- src_pixmap = pix[PIX_BACK];
- drawing_gc = clip_gc[PIX_BACK];
- graphic -= GFX_START_ROCKSSCREEN;
- src_x = SX + (graphic % GFX_PER_LINE) * TILEX;
- src_y = SY + (graphic / GFX_PER_LINE) * TILEY;
- }
- else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
- {
- src_pixmap = pix[PIX_MORE];
- drawing_gc = clip_gc[PIX_MORE];
- graphic -= GFX_START_ROCKSMORE;
- src_x = (graphic % MORE_PER_LINE) * TILEX;
- src_y = (graphic / MORE_PER_LINE) * TILEY;
- }
- else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
- {
- src_pixmap = pix[PIX_HEROES];
- drawing_gc = clip_gc[PIX_HEROES];
- graphic -= GFX_START_ROCKSHEROES;
- src_x = (graphic % HEROES_PER_LINE) * TILEX;
- src_y = (graphic / HEROES_PER_LINE) * TILEY;
- }
- else
- {
- DrawGraphicExt(d, gc, dest_x,dest_y, graphic);
+ if (graphic == GFX_LEERRAUM)
return;
- }
+
+ getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y);
+ src_pixmap = pix[pixmap_nr];
+ drawing_gc = clip_gc[pixmap_nr];
if (tile_clipmask[tile] != None)
{
XSetClipMask(display, tile_clip_gc, tile_clipmask[tile]);
XSetClipOrigin(display, tile_clip_gc, dest_x, dest_y);
- XCopyArea(display, src_pixmap, drawto_field, tile_clip_gc,
+ XCopyArea(display, src_pixmap, d, tile_clip_gc,
src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
else
#endif
XSetClipOrigin(display, drawing_gc, dest_x-src_x, dest_y-src_y);
- XCopyArea(display, src_pixmap, drawto_field, drawing_gc,
+ XCopyArea(display, src_pixmap, d, drawing_gc,
src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
}
*x = MINI_GFX_STARTX + (graphic % MINI_GFX_PER_LINE) * MINI_TILEX;
*y = MINI_GFX_STARTY + (graphic / MINI_GFX_PER_LINE) * MINI_TILEY;
}
- else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
+ else if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
{
- graphic -= GFX_START_ROCKSMORE;
- *pixmap = pix[PIX_MORE];
- *x = MINI_MORE_STARTX + (graphic % MINI_MORE_PER_LINE) * MINI_TILEX;
- *y = MINI_MORE_STARTY + (graphic / MINI_MORE_PER_LINE) * MINI_TILEY;
+ graphic -= GFX_START_ROCKSSP;
+ graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2;
+ *pixmap = pix[PIX_SP];
+ *x = MINI_SP_STARTX + (graphic % MINI_SP_PER_LINE) * MINI_TILEX;
+ *y = MINI_SP_STARTY + (graphic / MINI_SP_PER_LINE) * MINI_TILEY;
+ }
+ else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC)
+ {
+ graphic -= GFX_START_ROCKSDC;
+ *pixmap = pix[PIX_DC];
+ *x = MINI_DC_STARTX + (graphic % MINI_DC_PER_LINE) * MINI_TILEX;
+ *y = MINI_DC_STARTY + (graphic / MINI_DC_PER_LINE) * MINI_TILEY;
}
else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
{
*pixmap = pix[PIX_SMALLFONT];
*x = (graphic % FONT_CHARS_PER_LINE) * FONT4_XSIZE;
*y = ((graphic / FONT_CHARS_PER_LINE) * FONT4_YSIZE +
- FC_SPECIAL2 * FONT2_YSIZE * FONT_LINES_PER_FONT);
+ FC_SPECIAL2 * FONT2_YSIZE * FONT_LINES_PER_FONT);
}
else
{
- *pixmap = pix[PIX_MORE];
- *x = MINI_MORE_STARTX;
- *y = MINI_MORE_STARTY;
+ *pixmap = pix[PIX_SP];
+ *x = MINI_SP_STARTX;
+ *y = MINI_SP_STARTY;
}
}
void DrawMiniGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
{
- if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
- {
- graphic -= GFX_START_ROCKSSCREEN;
- XCopyArea(display, pix[PIX_BACK], d, gc,
- MINI_GFX_STARTX + (graphic % MINI_GFX_PER_LINE) * MINI_TILEX,
- MINI_GFX_STARTY + (graphic / MINI_GFX_PER_LINE) * MINI_TILEY,
- MINI_TILEX, MINI_TILEY, x, y);
- }
- else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
- {
- graphic -= GFX_START_ROCKSMORE;
- XCopyArea(display, pix[PIX_MORE], d, gc,
- MINI_MORE_STARTX + (graphic % MINI_MORE_PER_LINE) * MINI_TILEX,
- MINI_MORE_STARTY + (graphic / MINI_MORE_PER_LINE) * MINI_TILEY,
- MINI_TILEX, MINI_TILEY, x, y);
- }
- else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
- {
- graphic -= GFX_START_ROCKSFONT;
- XCopyArea(display, pix[PIX_SMALLFONT], d, gc,
- (graphic % FONT_CHARS_PER_LINE) * FONT4_XSIZE,
- (graphic / FONT_CHARS_PER_LINE) * FONT4_YSIZE +
- FC_SPECIAL2 * FONT2_YSIZE * FONT_LINES_PER_FONT,
- MINI_TILEX, MINI_TILEY, x, y);
- }
- else
- XFillRectangle(display, d, gc, x, y, MINI_TILEX, MINI_TILEY);
+ Pixmap pixmap;
+ int src_x, src_y;
+
+ getMiniGraphicSource(graphic, &pixmap, &src_x, &src_y);
+ XCopyArea(display, pixmap, d, gc,
+ src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
}
void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
int cx = 0, cy = 0;
int src_x, src_y, dest_x, dest_y;
int tile = graphic;
+ int pixmap_nr;
Pixmap src_pixmap;
GC drawing_gc;
MarkTileDirty(x, y + SIGN(dy));
}
- if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
- {
- src_pixmap = pix[PIX_BACK];
- drawing_gc = clip_gc[PIX_BACK];
- graphic -= GFX_START_ROCKSSCREEN;
- src_x = SX + (graphic % GFX_PER_LINE) * TILEX + cx;
- src_y = SY + (graphic / GFX_PER_LINE) * TILEY + cy;
- }
- else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
- {
- src_pixmap = pix[PIX_MORE];
- drawing_gc = clip_gc[PIX_MORE];
- graphic -= GFX_START_ROCKSMORE;
- src_x = (graphic % MORE_PER_LINE) * TILEX + cx;
- src_y = (graphic / MORE_PER_LINE) * TILEY + cy;
- }
- else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
- {
- src_pixmap = pix[PIX_HEROES];
- drawing_gc = clip_gc[PIX_HEROES];
- graphic -= GFX_START_ROCKSHEROES;
- src_x = (graphic % HEROES_PER_LINE) * TILEX + cx;
- src_y = (graphic / HEROES_PER_LINE) * TILEY + cy;
- }
- else /* big font graphics currently not allowed (and not needed) */
- return;
+ getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y);
+ src_pixmap = pix[pixmap_nr];
+ drawing_gc = clip_gc[pixmap_nr];
+
+ src_x += cx;
+ src_y += cy;
dest_x = FX + x * TILEX + dx;
dest_y = FY + y * TILEY + dy;
{
graphic += !phase2;
}
- else if ((element == EL_FELSBROCKEN || IS_GEM(element)) && !cut_mode)
+ else if ((element == EL_FELSBROCKEN || element == EL_SP_ZONK ||
+ IS_GEM(element)) && !cut_mode)
{
- if (element != EL_SP_INFOTRON)
- graphic += phase2 * (element == EL_FELSBROCKEN ? 2 : 1);
+ if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1]))
+ {
+ if (element == EL_FELSBROCKEN || element == EL_SP_ZONK)
+ {
+ if (dir == MV_LEFT)
+ graphic += (4 - phase4) % 4;
+ else if (dir == MV_RIGHT)
+ graphic += phase4;
+ else
+ graphic += phase2 * 2;
+ }
+ else if (element != EL_SP_INFOTRON)
+ graphic += phase2;
+ }
}
else if (element == EL_SIEB_LEER || element == EL_SIEB2_LEER ||
element == EL_SIEB_VOLL || element == EL_SIEB2_VOLL)
else if (rechts_massiv)
graphic = GFX_MAUER_L;
}
+ else if ((element == EL_INVISIBLE_STEEL ||
+ element == EL_UNSICHTBAR ||
+ element == EL_SAND_INVISIBLE) && game.light_time_left)
+ {
+ graphic = (element == EL_INVISIBLE_STEEL ? GFX_INVISIBLE_STEEL_ON :
+ element == EL_UNSICHTBAR ? GFX_UNSICHTBAR_ON :
+ GFX_SAND_INVISIBLE_ON);
+ }
if (dx || dy)
DrawGraphicShifted(x, y, dx, dy, graphic, cut_mode, mask_mode);
element = Feld[ux][uy];
- if (element == EL_ERDREICH)
+ if (element == EL_ERDREICH || element == EL_LANDMINE)
{
if (!IN_SCR_FIELD(x, y))
return;
else
element = Feld[uxx][uyy];
- if (element == EL_ERDREICH)
+ if (element == EL_ERDREICH || element == EL_LANDMINE)
continue;
if (i == 1 || i == 2)
uxx = ux + xy[i][0];
uyy = uy + xy[i][1];
- if (!IN_LEV_FIELD(uxx, uyy) || Feld[uxx][uyy] != EL_ERDREICH ||
+ if (!IN_LEV_FIELD(uxx, uyy) ||
+ (Feld[uxx][uyy] != EL_ERDREICH && Feld[uxx][uyy] != EL_LANDMINE) ||
!IN_SCR_FIELD(xx, yy))
continue;
if (steel_position != -1)
DrawMiniGraphic(sx, sy, border[steel_position][steel_type]);
-
-
-#if 0
- if (x == -1 && y == -1)
- DrawMiniGraphic(sx, sy, GFX_STEEL_UPPER_LEFT);
- else if (x == lev_fieldx && y == -1)
- DrawMiniGraphic(sx, sy, GFX_STEEL_UPPER_RIGHT);
- else if (x == -1 && y == lev_fieldy)
- DrawMiniGraphic(sx, sy, GFX_STEEL_LOWER_LEFT);
- else if (x == lev_fieldx && y == lev_fieldy)
- DrawMiniGraphic(sx, sy, GFX_STEEL_LOWER_RIGHT);
- else if (x == -1 || x == lev_fieldx)
- DrawMiniGraphic(sx, sy, GFX_STEEL_VERTICAL);
- else if (y == -1 || y == lev_fieldy)
- DrawMiniGraphic(sx, sy, GFX_STEEL_HORIZONTAL);
-#endif
-
-
}
}
graphic = el2gfx(element);
- if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
+ if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
{
- graphic -= GFX_START_ROCKSMORE;
- XCopyArea(display, pix[PIX_MORE], drawto, gc,
- MICRO_MORE_STARTX + (graphic % MICRO_MORE_PER_LINE) *MICRO_TILEX,
- MICRO_MORE_STARTY + (graphic / MICRO_MORE_PER_LINE) *MICRO_TILEY,
+ graphic -= GFX_START_ROCKSSP;
+ graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2;
+ XCopyArea(display, pix[PIX_SP], drawto, gc,
+ MICRO_SP_STARTX + (graphic % MICRO_SP_PER_LINE) * MICRO_TILEX,
+ MICRO_SP_STARTY + (graphic / MICRO_SP_PER_LINE) * MICRO_TILEY,
+ MICRO_TILEX, MICRO_TILEY, xpos, ypos);
+ }
+ else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC)
+ {
+ graphic -= GFX_START_ROCKSDC;
+ XCopyArea(display, pix[PIX_DC], drawto, gc,
+ MICRO_DC_STARTX + (graphic % MICRO_DC_PER_LINE) * MICRO_TILEX,
+ MICRO_DC_STARTY + (graphic / MICRO_DC_PER_LINE) * MICRO_TILEY,
MICRO_TILEX, MICRO_TILEY, xpos, ypos);
}
else
for(y=BY1; y<=BY2; y++)
DrawScreenField(x, y);
- if (setup.soft_scrolling)
- XCopyArea(display, fieldbuffer, backbuffer, gc,
- FX, FY, SXSIZE, SYSIZE, SX, SY);
-
- redraw_mask |= (REDRAW_FIELD | REDRAW_FROM_BACKBUFFER);
+ redraw_mask |= REDRAW_FIELD;
}
void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
{
int x, y;
- /* determine border element for this level */
- SetBorderElement();
-
XFillRectangle(display, drawto, gc,
xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
redraw_mask |= REDRAW_MICROLEVEL;
}
+#define MICROLABEL_EMPTY 0
+#define MICROLABEL_LEVEL_NAME 1
+#define MICROLABEL_CREATED_BY 2
+#define MICROLABEL_LEVEL_AUTHOR 3
+#define MICROLABEL_IMPORTED_FROM 4
+#define MICROLABEL_LEVEL_IMPORT_INFO 5
+
+#define MAX_MICROLABEL_SIZE (SXSIZE / FONT4_XSIZE)
+
static void DrawMicroLevelLabelExt(int mode)
{
- char label_text[100];
+ char label_text[MAX_MICROLABEL_SIZE + 1];
XFillRectangle(display, drawto,gc,
SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE);
- strcpy(label_text, (mode == 1 ? level.name :
- mode == 2 ? "created by" :
- mode == 3 ? level.author : ""));
+ strncpy(label_text, (mode == MICROLABEL_LEVEL_NAME ? level.name :
+ mode == MICROLABEL_CREATED_BY ? "created by" :
+ mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
+ mode == MICROLABEL_IMPORTED_FROM ? "imported from" :
+ mode == MICROLABEL_LEVEL_IMPORT_INFO ?
+ leveldir[leveldir_nr].imported_from : ""),
+ MAX_MICROLABEL_SIZE);
+ label_text[MAX_MICROLABEL_SIZE] = '\0';
if (strlen(label_text) > 0)
{
- int size, lxpos, lypos;
-
- label_text[SXSIZE / FONT4_XSIZE] = '\0';
-
- size = strlen(label_text);
- lxpos = SX + (SXSIZE - size * FONT4_XSIZE) / 2;
- lypos = MICROLABEL_YPOS;
+ int lxpos = SX + (SXSIZE - strlen(label_text) * FONT4_XSIZE) / 2;
+ int lypos = MICROLABEL_YPOS;
DrawText(lxpos, lypos, label_text, FS_SMALL, FC_SPECIAL2);
}
strcmp(level.author, leveldir[leveldir_nr].name) != 0 &&
DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
{
- label_counter = (label_counter + 1) % 23;
- label_state = (label_counter >= 0 && label_counter <= 7 ? 1 :
- label_counter >= 9 && label_counter <= 12 ? 2 :
- label_counter >= 14 && label_counter <= 21 ? 3 : 0);
+ int max_label_counter = 23;
+
+ if (leveldir[leveldir_nr].imported_from != NULL)
+ max_label_counter += 14;
+
+ label_counter = (label_counter + 1) % max_label_counter;
+ label_state = (label_counter >= 0 && label_counter <= 7 ?
+ MICROLABEL_LEVEL_NAME :
+ label_counter >= 9 && label_counter <= 12 ?
+ MICROLABEL_CREATED_BY :
+ label_counter >= 14 && label_counter <= 21 ?
+ MICROLABEL_LEVEL_AUTHOR :
+ label_counter >= 23 && label_counter <= 26 ?
+ MICROLABEL_IMPORTED_FROM :
+ label_counter >= 28 && label_counter <= 35 ?
+ MICROLABEL_LEVEL_IMPORT_INFO : MICROLABEL_EMPTY);
DrawMicroLevelLabelExt(label_state);
}
}
DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
/* clear door drawing field */
-#if 0
- XFillRectangle(display, pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE);
-#else
XFillRectangle(display, drawto, gc, DX, DY, DXSIZE, DYSIZE);
-#endif
/* write text for request */
for(ty=0; ty<13; ty++)
}
sprintf(txt, text);
txt[tl] = 0;
-#if 0
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + 51 - (tl * 14)/2, SY + ty * 16,
- txt, FS_SMALL, FC_YELLOW);
-#else
DrawTextExt(drawto, gc,
DX + 51 - (tl * 14)/2, DY + 8 + ty * 16,
txt, FS_SMALL, FC_YELLOW);
-#endif
text += tl + (tc == 32 ? 1 : 0);
}
-#if 0
- if (req_state & REQ_ASK)
- {
- DrawYesNoButton(BUTTON_OK, DB_INIT);
- DrawYesNoButton(BUTTON_NO, DB_INIT);
- }
- else if (req_state & REQ_CONFIRM)
- {
- DrawConfirmButton(BUTTON_CONFIRM, DB_INIT);
- }
- else if (req_state & REQ_PLAYER)
- {
- DrawPlayerButton(BUTTON_PLAYER_1, DB_INIT);
- DrawPlayerButton(BUTTON_PLAYER_2, DB_INIT);
- DrawPlayerButton(BUTTON_PLAYER_3, DB_INIT);
- DrawPlayerButton(BUTTON_PLAYER_4, DB_INIT);
- }
-#else
-
if (req_state & REQ_ASK)
{
MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
DX, DY, DXSIZE, DYSIZE,
DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
-#endif
-
OpenDoor(DOOR_OPEN_1);
+
+#if 0
ClearEventQueue();
+#endif
if (!(req_state & REQUEST_WAIT_FOR))
return(FALSE);
case ButtonRelease:
case MotionNotify:
{
-
-#if 0
- int choice;
-#endif
-
if (event.type == MotionNotify)
{
Window root, child;
button_status = MB_RELEASED;
}
-
-
-#if 0
- if (req_state & REQ_ASK)
- choice = CheckYesNoButtons(mx,my,button_status);
- else if (req_state & REQ_CONFIRM)
- choice = CheckConfirmButton(mx,my,button_status);
- else
- choice = CheckPlayerButtons(mx,my,button_status);
-
- switch(choice)
- {
- case BUTTON_OK:
- result = TRUE;
- break;
- case BUTTON_NO:
- result = FALSE;
- break;
- case BUTTON_CONFIRM:
- result = TRUE | FALSE;
- break;
-
- case BUTTON_PLAYER_1:
- result = 1;
- break;
- case BUTTON_PLAYER_2:
- result = 2;
- break;
- case BUTTON_PLAYER_3:
- result = 3;
- break;
- case BUTTON_PLAYER_4:
- result = 4;
- break;
-
- default:
- break;
- }
-#else
-
/* this sets 'request_gadget_id' */
HandleGadgets(mx, my, button_status);
default:
break;
}
-#endif
break;
}
redraw_mask |= REDRAW_DOOR_2;
}
-
-
-#if 1
BackToFront();
-#else
- XCopyArea(display, drawto, window, gc, DX, DY, DXSIZE, DYSIZE, DX, DY);
-#endif
-
-
if (game_status == MAINMENU)
DoAnimation();
if (door_state & DOOR_ACTION_2)
door2 = door_state & DOOR_ACTION_2;
- return(door1 | door2);
+ return (door1 | door2);
+}
+
+void DrawSpecialEditorDoor()
+{
+ /* draw bigger toolbox window */
+ XCopyArea(display, pix[PIX_DOOR], drawto, gc,
+ DOOR_GFX_PAGEX7, 0, 108, 56, EX - 4, EY - 12);
+
+ redraw_mask |= REDRAW_ALL;
+}
+
+void UndrawSpecialEditorDoor()
+{
+ /* draw normal tape recorder window */
+ XCopyArea(display, pix[PIX_BACK], drawto, gc,
+ 562, 344, 108, 56, EX - 4, EY - 12);
+
+ redraw_mask |= REDRAW_ALL;
}
int ReadPixel(Drawable d, int x, int y)
}
};
+static void DoNotDisplayInfoText(void *ptr)
+{
+ return;
+}
+
void CreateToolButtons()
{
int i;
for (i=0; i<NUM_TOOL_BUTTONS; i++)
{
Pixmap gd_pixmap = pix[PIX_DOOR];
- Pixmap deco_pixmap = 0;
- int deco_x, deco_y, deco_xpos, deco_ypos;
+ Pixmap deco_pixmap = None;
+ int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
struct GadgetInfo *gi;
unsigned long event_mask;
int gd_xoffset, gd_yoffset;
GDI_DECORATION_SHIFTING, 1, 1,
GDI_EVENT_MASK, event_mask,
GDI_CALLBACK_ACTION, HandleToolButtons,
+ GDI_CALLBACK_INFO, DoNotDisplayInfoText,
GDI_END);
if (gi == NULL)
static void HandleToolButtons(struct GadgetInfo *gi)
{
request_gadget_id = gi->custom_id;
-
-
-#if 0
- int id = gi->custom_id;
-
- if (game_status != PLAYING)
- return;
-
- switch (id)
- {
- case GAME_CTRL_ID_STOP:
- if (AllPlayersGone)
- {
- CloseDoor(DOOR_CLOSE_1);
- game_status = MAINMENU;
- DrawMainMenu();
- break;
- }
-
- if (Request("Do you really want to quit the game ?",
- REQ_ASK | REQ_STAY_CLOSED))
- {
-#ifndef MSDOS
- if (options.network)
- SendToServer_StopPlaying();
- else
-#endif
- {
- game_status = MAINMENU;
- DrawMainMenu();
- }
- }
- else
- OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
- break;
-
- case GAME_CTRL_ID_PAUSE:
- if (options.network)
- {
-#ifndef MSDOS
- if (tape.pausing)
- SendToServer_ContinuePlaying();
- else
- SendToServer_PausePlaying();
-#endif
- }
- else
- TapeTogglePause();
- break;
-
- case GAME_CTRL_ID_PLAY:
- if (tape.pausing)
- {
-#ifndef MSDOS
- if (options.network)
- SendToServer_ContinuePlaying();
- else
-#endif
- {
- tape.pausing = FALSE;
- DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
- }
- }
- break;
-
- case SOUND_CTRL_ID_MUSIC:
- if (setup.sound_music)
- {
- setup.sound_music = FALSE;
- FadeSound(background_loop[level_nr % num_bg_loops]);
- }
- else if (sound_loops_allowed)
- {
- setup.sound = setup.sound_music = TRUE;
- PlaySoundLoop(background_loop[level_nr % num_bg_loops]);
- }
- break;
-
- case SOUND_CTRL_ID_LOOPS:
- if (setup.sound_loops)
- setup.sound_loops = FALSE;
- else if (sound_loops_allowed)
- setup.sound = setup.sound_loops = TRUE;
- break;
-
- case SOUND_CTRL_ID_SIMPLE:
- if (setup.sound_simple)
- setup.sound_simple = FALSE;
- else if (sound_status==SOUND_AVAILABLE)
- setup.sound = setup.sound_simple = TRUE;
- break;
-
- default:
- break;
- }
-#endif
-
-
-
}
int el2gfx(int element)
case EL_KOKOSNUSS: return GFX_KOKOSNUSS;
case EL_LIFE: return GFX_LIFE;
case EL_LIFE_ASYNC: return GFX_LIFE_ASYNC;
- case EL_DYNAMIT: return GFX_DYNAMIT;
+ case EL_DYNAMITE_ACTIVE: return GFX_DYNAMIT;
case EL_BADEWANNE: return GFX_BADEWANNE;
case EL_BADEWANNE1: return GFX_BADEWANNE1;
case EL_BADEWANNE2: return GFX_BADEWANNE2;
case EL_PFORTE2X: return GFX_PFORTE2X;
case EL_PFORTE3X: return GFX_PFORTE3X;
case EL_PFORTE4X: return GFX_PFORTE4X;
- case EL_DYNAMIT_AUS: return GFX_DYNAMIT_AUS;
+ case EL_DYNAMITE_INACTIVE: return GFX_DYNAMIT_AUS;
case EL_PACMAN: return GFX_PACMAN;
case EL_PACMAN_R: return GFX_PACMAN_R;
case EL_PACMAN_O: return GFX_PACMAN_O;
case EL_SIEB2_LEER: return GFX_SIEB2_LEER;
case EL_SIEB2_VOLL: return GFX_SIEB2_VOLL;
case EL_SIEB2_TOT: return GFX_SIEB2_TOT;
- case EL_DYNABOMB: return GFX_DYNABOMB;
+ case EL_DYNABOMB_ACTIVE_1: return GFX_DYNABOMB;
+ case EL_DYNABOMB_ACTIVE_2: return GFX_DYNABOMB;
+ case EL_DYNABOMB_ACTIVE_3: return GFX_DYNABOMB;
+ case EL_DYNABOMB_ACTIVE_4: return GFX_DYNABOMB;
case EL_DYNABOMB_NR: return GFX_DYNABOMB_NR;
case EL_DYNABOMB_SZ: return GFX_DYNABOMB_SZ;
case EL_DYNABOMB_XL: return GFX_DYNABOMB_XL;
case EL_SPEED_PILL: return GFX_SPEED_PILL;
case EL_SP_TERMINAL_ACTIVE: return GFX_SP_TERMINAL;
case EL_SP_BUG_ACTIVE: return GFX_SP_BUG_ACTIVE;
+ case EL_SP_ZONK: return GFX_SP_ZONK;
+ /* ^^^^^^^^^^ non-standard position in supaplex graphic set! */
case EL_INVISIBLE_STEEL: return GFX_INVISIBLE_STEEL;
+ case EL_BLACK_ORB: return GFX_BLACK_ORB;
+ case EL_EM_GATE_1: return GFX_EM_GATE_1;
+ case EL_EM_GATE_2: return GFX_EM_GATE_2;
+ case EL_EM_GATE_3: return GFX_EM_GATE_3;
+ case EL_EM_GATE_4: return GFX_EM_GATE_4;
+ case EL_EM_GATE_1X: return GFX_EM_GATE_1X;
+ case EL_EM_GATE_2X: return GFX_EM_GATE_2X;
+ case EL_EM_GATE_3X: return GFX_EM_GATE_3X;
+ case EL_EM_GATE_4X: return GFX_EM_GATE_4X;
+ case EL_EM_KEY_1_FILE: return GFX_EM_KEY_1;
+ case EL_EM_KEY_2_FILE: return GFX_EM_KEY_2;
+ case EL_EM_KEY_3_FILE: return GFX_EM_KEY_3;
+ case EL_EM_KEY_4_FILE: return GFX_EM_KEY_4;
+ case EL_EM_KEY_1: return GFX_EM_KEY_1;
+ case EL_EM_KEY_2: return GFX_EM_KEY_2;
+ case EL_EM_KEY_3: return GFX_EM_KEY_3;
+ case EL_EM_KEY_4: return GFX_EM_KEY_4;
+ case EL_PEARL: return GFX_PEARL;
+ case EL_CRYSTAL: return GFX_CRYSTAL;
+ case EL_WALL_PEARL: return GFX_WALL_PEARL;
+ case EL_WALL_CRYSTAL: return GFX_WALL_CRYSTAL;
+ case EL_DOOR_WHITE: return GFX_DOOR_WHITE;
+ case EL_DOOR_WHITE_GRAY: return GFX_DOOR_WHITE_GRAY;
+ case EL_KEY_WHITE: return GFX_KEY_WHITE;
+ case EL_FORCE_FIELD: return GFX_FORCE_FIELD;
+ case EL_EXTRA_TIME: return GFX_EXTRA_TIME;
+ case EL_SWITCHGATE_OPEN: return GFX_SWITCHGATE_OPEN;
+ case EL_SWITCHGATE_CLOSED: return GFX_SWITCHGATE_CLOSED;
+ case EL_SWITCHGATE_SWITCH_1:return GFX_SWITCHGATE_SWITCH_1;
+ case EL_SWITCHGATE_SWITCH_2:return GFX_SWITCHGATE_SWITCH_2;
+ case EL_TIME_GATE: return GFX_TIME_GATE;
+ case EL_TIME_GATE_WHEEL: return GFX_TIME_GATE_WHEEL;
+ case EL_BELT1_LEFT: return GFX_BELT1_LEFT;
+ case EL_BELT1_MIDDLE: return GFX_BELT1_MIDDLE;
+ case EL_BELT1_RIGHT: return GFX_BELT1_RIGHT;
+ case EL_BELT1_SWITCH_L: return GFX_BELT1_SWITCH_L;
+ case EL_BELT1_SWITCH_M: return GFX_BELT1_SWITCH_M;
+ case EL_BELT1_SWITCH_R: return GFX_BELT1_SWITCH_R;
+ case EL_BELT2_LEFT: return GFX_BELT2_LEFT;
+ case EL_BELT2_MIDDLE: return GFX_BELT2_MIDDLE;
+ case EL_BELT2_RIGHT: return GFX_BELT2_RIGHT;
+ case EL_BELT2_SWITCH_L: return GFX_BELT2_SWITCH_L;
+ case EL_BELT2_SWITCH_M: return GFX_BELT2_SWITCH_M;
+ case EL_BELT2_SWITCH_R: return GFX_BELT2_SWITCH_R;
+ case EL_BELT3_LEFT: return GFX_BELT3_LEFT;
+ case EL_BELT3_MIDDLE: return GFX_BELT3_MIDDLE;
+ case EL_BELT3_RIGHT: return GFX_BELT3_RIGHT;
+ case EL_BELT3_SWITCH_L: return GFX_BELT3_SWITCH_L;
+ case EL_BELT3_SWITCH_M: return GFX_BELT3_SWITCH_M;
+ case EL_BELT3_SWITCH_R: return GFX_BELT3_SWITCH_R;
+ case EL_BELT4_LEFT: return GFX_BELT4_LEFT;
+ case EL_BELT4_MIDDLE: return GFX_BELT4_MIDDLE;
+ case EL_BELT4_RIGHT: return GFX_BELT4_RIGHT;
+ case EL_BELT4_SWITCH_L: return GFX_BELT4_SWITCH_L;
+ case EL_BELT4_SWITCH_M: return GFX_BELT4_SWITCH_M;
+ case EL_BELT4_SWITCH_R: return GFX_BELT4_SWITCH_R;
+ case EL_LANDMINE: return GFX_LANDMINE;
+ case EL_ENVELOPE: return GFX_ENVELOPE;
+ case EL_LIGHT_SWITCH_OFF: return GFX_LIGHT_SWITCH_OFF;
+ case EL_LIGHT_SWITCH_ON: return GFX_LIGHT_SWITCH_ON;
+ case EL_SIGN_EXCLAMATION: return GFX_SIGN_EXCLAMATION;
+ case EL_SIGN_RADIOACTIVITY: return GFX_SIGN_RADIOACTIVITY;
+ case EL_SIGN_STOP: return GFX_SIGN_STOP;
+ case EL_SIGN_WHEELCHAIR: return GFX_SIGN_WHEELCHAIR;
+ case EL_SIGN_PARKING: return GFX_SIGN_PARKING;
+ case EL_SIGN_ONEWAY: return GFX_SIGN_ONEWAY;
+ case EL_SIGN_HEART: return GFX_SIGN_HEART;
+ case EL_SIGN_TRIANGLE: return GFX_SIGN_TRIANGLE;
+ case EL_SIGN_ROUND: return GFX_SIGN_ROUND;
+ case EL_SIGN_EXIT: return GFX_SIGN_EXIT;
+ case EL_SIGN_YINYANG: return GFX_SIGN_YINYANG;
+ case EL_SIGN_OTHER: return GFX_SIGN_OTHER;
+ case EL_MOLE_LEFT: return GFX_MOLE_LEFT;
+ case EL_MOLE_RIGHT: return GFX_MOLE_RIGHT;
+ case EL_MOLE_UP: return GFX_MOLE_UP;
+ case EL_MOLE_DOWN: return GFX_MOLE_DOWN;
+ case EL_STEEL_SLANTED: return GFX_STEEL_SLANTED;
+ case EL_SAND_INVISIBLE: return GFX_SAND_INVISIBLE;
default:
{
int nr_element = element - EL_SP_START;
int gfx_per_line = 8;
int nr_graphic =
- (nr_element / gfx_per_line) * MORE_PER_LINE +
+ (nr_element / gfx_per_line) * SP_PER_LINE +
(nr_element % gfx_per_line);
- return GFX_START_ROCKSMORE + nr_graphic;
+ return GFX_START_ROCKSSP + nr_graphic;
}
else
return -1;