#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 (redraw_mask & REDRAW_FIELD)
{
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
{
int fx = FX, fy = FY;
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)
for(x=0; x<SCR_FIELDX; x++)
for(y=0; y<SCR_FIELDY; y++)
if (redraw[redraw_x1 + x][redraw_y1 + y])
- XCopyArea(display,buffer,window,gc,
- FX+x*TILEX,FX+y*TILEY, TILEX,TILEY,
- SX+x*TILEX,SY+y*TILEY);
+ XCopyArea(display, buffer, window, gc,
+ FX + x * TILEX, FX + y * TILEY, TILEX, TILEY,
+ SX + x * TILEX, SY + y * TILEY);
}
XFlush(display);
void DrawTextFCentered(int y, int font_type, char *format, ...)
{
- char buffer[FULL_SXSIZE / FONT3_XSIZE + 10];
+ char buffer[FULL_SXSIZE / FONT5_XSIZE + 10];
int font_xsize;
va_list ap;
font_xsize = (font_type < FC_SPECIAL1 ? FONT2_XSIZE :
- font_type < FC_SPECIAL2 ? FONT3_XSIZE : FONT4_XSIZE);
+ font_type < FC_SPECIAL2 ? FONT3_XSIZE :
+ font_type < FC_SPECIAL3 ? FONT4_XSIZE :
+ FONT5_XSIZE);
va_start(ap, format);
vsprintf(buffer, format, ap);
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_type < FC_SPECIAL2 ? FONT3_XSIZE :
+ font_type < FC_SPECIAL3 ? FONT4_XSIZE :
+ FONT5_XSIZE);
+ font_height = (font_size == FS_BIG ? FONT1_YSIZE :
+ font_type < FC_SPECIAL1 ? FONT2_YSIZE :
+ font_type < FC_SPECIAL2 ? FONT3_YSIZE :
+ font_type < FC_SPECIAL3 ? FONT4_YSIZE :
+ FONT5_YSIZE);
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 + 3;
+
while (*text)
{
char c = *text++;
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_DYNAMIT)
DrawDynamite(last_jx, last_jy);
else
DrawLevelField(last_jx, last_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 += player->index_nr * 3*HEROES_PER_LINE;
- graphic += player->Frame;
+ 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;
+ }
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 (EL_DYNAMIT or EL_DYNABOMB) */
if (element == EL_DYNAMIT || element == EL_DYNABOMB)
{
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 DrawGraphic(int x, int y, int graphic)
-{
-#if DEBUG
- if (!IN_SCR_FIELD(x,y))
- {
- printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
- printf("DrawGraphic(): This should never happen!\n");
- return;
- }
-#endif
-
- DrawGraphicExt(drawto_field, gc, FX + x*TILEX, FY + y*TILEY, graphic);
- MarkTileDirty(x,y);
-}
-
-void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+void getGraphicSource(int graphic, int *pixmap_nr, int *x, int *y)
{
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);
+ *pixmap_nr = PIX_BACK;
+ *x = SX + (graphic % GFX_PER_LINE) * TILEX;
+ *y = SY + (graphic / GFX_PER_LINE) * TILEY;
}
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);
+ *pixmap_nr = PIX_MORE;
+ *x = (graphic % MORE_PER_LINE) * TILEX;
+ *y = (graphic / MORE_PER_LINE) * TILEY;
}
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);
+ *pixmap_nr = PIX_HEROES;
+ *x = (graphic % HEROES_PER_LINE) * TILEX;
+ *y = (graphic / HEROES_PER_LINE) * TILEY;
}
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);
+ *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
- XFillRectangle(display, d, gc, x, y, TILEX, TILEY);
+ {
+ *pixmap_nr = PIX_MORE;
+ *x = 0;
+ *y = 0;
+ }
+}
+
+void DrawGraphic(int x, int y, int graphic)
+{
+#if DEBUG
+ if (!IN_SCR_FIELD(x,y))
+ {
+ printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+ printf("DrawGraphic(): This should never happen!\n");
+ return;
+ }
+#endif
+
+ DrawGraphicExt(drawto_field, gc, FX + x*TILEX, FY + y*TILEY, graphic);
+ MarkTileDirty(x,y);
+}
+
+void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+{
+ 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);
}
}
else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
{
graphic -= GFX_START_ROCKSMORE;
+ graphic -= ((graphic / MORE_PER_LINE) * MORE_PER_LINE) / 2;
*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;
*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
{
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];
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)
+ 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;
+
+ /*
+ if (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 * (element == EL_FELSBROCKEN ? 2 : 1);
+ */
+
}
else if (element == EL_SIEB_LEER || element == EL_SIEB2_LEER ||
element == EL_SIEB_VOLL || element == EL_SIEB2_VOLL)
DrawMiniElement(sx, sy, EL_LEERRAUM);
else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
DrawMiniElement(sx, sy, Feld[x][y]);
- else 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);
+ else
+ {
+ int steel_type, steel_position;
+ int border[6][2] =
+ {
+ { GFX_VSTEEL_UPPER_LEFT, GFX_ISTEEL_UPPER_LEFT },
+ { GFX_VSTEEL_UPPER_RIGHT, GFX_ISTEEL_UPPER_RIGHT },
+ { GFX_VSTEEL_LOWER_LEFT, GFX_ISTEEL_LOWER_LEFT },
+ { GFX_VSTEEL_LOWER_RIGHT, GFX_ISTEEL_LOWER_RIGHT },
+ { GFX_VSTEEL_VERTICAL, GFX_ISTEEL_VERTICAL },
+ { GFX_VSTEEL_HORIZONTAL, GFX_ISTEEL_HORIZONTAL }
+ };
+
+ steel_type = (BorderElement == EL_BETON ? 0 : 1);
+ steel_position = (x == -1 && y == -1 ? 0 :
+ x == lev_fieldx && y == -1 ? 1 :
+ x == -1 && y == lev_fieldy ? 2 :
+ x == lev_fieldx && y == lev_fieldy ? 3 :
+ x == -1 || x == lev_fieldx ? 4 :
+ y == -1 || y == lev_fieldy ? 5 : -1);
+
+ if (steel_position != -1)
+ DrawMiniGraphic(sx, sy, border[steel_position][steel_type]);
+ }
}
void DrawMicroElement(int xpos, int ypos, int element)
if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
{
graphic -= GFX_START_ROCKSMORE;
+ graphic -= ((graphic / MORE_PER_LINE) * MORE_PER_LINE) / 2;
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,
for(y=BY1; y<=BY2; y++)
DrawScreenField(x, y);
+
+#if 1
+
+ redraw_mask |= REDRAW_FIELD;
+
+#else
+
if (setup.soft_scrolling)
XCopyArea(display, fieldbuffer, backbuffer, gc,
FX, FY, SXSIZE, SYSIZE, SX, SY);
redraw_mask |= (REDRAW_FIELD | REDRAW_FROM_BACKBUFFER);
+
+#endif
+
}
-void DrawMiniLevel(int scroll_x, int scroll_y)
+void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
{
int x,y;
- for(x=0; x<ED_FIELDX; x++)
- for(y=0; y<ED_FIELDY; y++)
+ for(x=0; x<size_x; x++)
+ for(y=0; y<size_y; y++)
DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
redraw_mask |= REDRAW_FIELD;
{
int x, y;
- /* determine border element for this level */
- SetBorderElement();
-
XFillRectangle(display, drawto, gc,
xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
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:
{
- int choice;
-
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;
}
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, 60, 108, 56, EX - 4, EY - 12);
+
+ /* draw background for level selection gadgets */
+ XCopyArea(display, pix[PIX_DOOR], drawto, gc,
+ DOOR_GFX_PAGEX7, 0, 108, 60, EX - 4, 0);
+
+ 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);
+
+ /* draw game title */
+ XCopyArea(display, pix[PIX_BACK], drawto, gc,
+ 562, 0, 108, 60, EX - 4, 0);
+
+ 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_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;
default:
{
projects / rocksndiamonds.git / blobdiff