/***********************************************************
-* Rocks'n'Diamonds -- McDuffin Strikes Back! *
+* Rocks'n'Diamonds -- McDuffin Strikes Back! *
*----------------------------------------------------------*
-* (c) 1995-98 Artsoft Entertainment *
-* Holger Schemel *
-* Oststrasse 11a *
-* 33604 Bielefeld *
-* phone: ++49 +521 290471 *
-* email: aeglos@valinor.owl.de *
+* (c) 1995-2002 Artsoft Entertainment *
+* Holger Schemel *
+* Detmolder Strasse 189 *
+* 33604 Bielefeld *
+* Germany *
+* e-mail: info@artsoft.org *
*----------------------------------------------------------*
-* tools.c *
+* tools.c *
***********************************************************/
-#include <stdarg.h>
-
-#ifdef __FreeBSD__
-#include <machine/joystick.h>
-#endif
+#include "libgame/libgame.h"
#include "tools.h"
#include "game.h"
#include "events.h"
-#include "sound.h"
-#include "misc.h"
-#include "buttons.h"
-#include "joystick.h"
#include "cartoons.h"
#include "network.h"
+#include "tape.h"
-#ifdef MSDOS
-extern boolean wait_for_vsync;
-#endif
+/* tool button identifiers */
+#define TOOL_CTRL_ID_YES 0
+#define TOOL_CTRL_ID_NO 1
+#define TOOL_CTRL_ID_CONFIRM 2
+#define TOOL_CTRL_ID_PLAYER_1 3
+#define TOOL_CTRL_ID_PLAYER_2 4
+#define TOOL_CTRL_ID_PLAYER_3 5
+#define TOOL_CTRL_ID_PLAYER_4 6
+
+#define NUM_TOOL_BUTTONS 7
+
+/* forward declaration for internal use */
+static void UnmapToolButtons();
+static void HandleToolButtons(struct GadgetInfo *);
+static int el_act_dir2crm(int, int, int);
+
+static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
+static int request_gadget_id = -1;
void SetDrawtoField(int mode)
{
}
}
+void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
+{
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ if (force_redraw)
+ {
+ x = gfx.sx - TILEX;
+ y = gfx.sy - TILEY;
+ width = gfx.sxsize + 2 * TILEX;
+ height = gfx.sysize + 2 * TILEY;
+ }
+
+ if (force_redraw || setup.direct_draw)
+ {
+ int xx, yy;
+ int x1 = (x - SX) / TILEX, y1 = (y - SY) / TILEY;
+ int x2 = (x - SX + width) / TILEX, y2 = (y - SY + height) / TILEY;
+
+ if (setup.direct_draw)
+ SetDrawtoField(DRAW_BACKBUFFER);
+
+ for(xx=BX1; xx<=BX2; xx++)
+ for(yy=BY1; yy<=BY2; yy++)
+ if (xx >= x1 && xx <= x2 && yy >= y1 && yy <= y2)
+ DrawScreenField(xx, yy);
+ DrawAllPlayers();
+
+ if (setup.direct_draw)
+ SetDrawtoField(DRAW_DIRECT);
+ }
+
+ if (setup.soft_scrolling)
+ {
+ int fx = FX, fy = FY;
+
+ fx += (ScreenMovDir & (MV_LEFT|MV_RIGHT) ? ScreenGfxPos : 0);
+ fy += (ScreenMovDir & (MV_UP|MV_DOWN) ? ScreenGfxPos : 0);
+
+ BlitBitmap(fieldbuffer, backbuffer, fx,fy, SXSIZE,SYSIZE, SX,SY);
+ }
+ }
+
+ BlitBitmap(drawto, window, x, y, width, height, x, y);
+}
+
void BackToFront()
{
int x,y;
- Drawable buffer = (drawto_field == window ? backbuffer : drawto_field);
+ DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
- if (setup.direct_draw && game_status == PLAYING)
+ if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
redraw_mask &= ~REDRAW_MAIN;
if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
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)
+ if (redraw_mask == REDRAW_NONE)
return;
+ if (global.fps_slowdown && game_status == GAME_MODE_PLAYING)
+ {
+ static boolean last_frame_skipped = FALSE;
+ boolean skip_even_when_not_scrolling = TRUE;
+ boolean just_scrolling = (ScreenMovDir != 0);
+ boolean verbose = FALSE;
+
+ if (global.fps_slowdown_factor > 1 &&
+ (FrameCounter % global.fps_slowdown_factor) &&
+ (just_scrolling || skip_even_when_not_scrolling))
+ {
+ redraw_mask &= ~REDRAW_MAIN;
+
+ last_frame_skipped = TRUE;
+
+ if (verbose)
+ printf("FRAME SKIPPED\n");
+ }
+ else
+ {
+ if (last_frame_skipped)
+ redraw_mask |= REDRAW_FIELD;
+
+ last_frame_skipped = FALSE;
+
+ if (verbose)
+ printf("frame not skipped\n");
+ }
+ }
+
/* synchronize X11 graphics at this point; if we would synchronize the
display immediately after the buffer switching (after the XFlush),
this could mean that we have to wait for the graphics to complete,
although we could go on doing calculations for the next frame */
- XSync(display, FALSE);
-
- /*
-#ifdef MSDOS
- wait_for_vsync = TRUE;
-#endif
- */
+ SyncDisplay();
if (redraw_mask & REDRAW_ALL)
{
- XCopyArea(display,backbuffer,window,gc,
- 0,0, WIN_XSIZE,WIN_YSIZE,
- 0,0);
+ BlitBitmap(backbuffer, window, 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);
+ if (game_status != GAME_MODE_PLAYING ||
+ redraw_mask & REDRAW_FROM_BACKBUFFER)
+ {
+ BlitBitmap(backbuffer, window,
+ REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
+ }
else
{
int fx = FX, fy = FY;
ABS(ScreenMovPos) == ScrollStepSize ||
redraw_tiles > REDRAWTILES_THRESHOLD)
{
- XCopyArea(display, buffer, window, gc, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ BlitBitmap(buffer, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
#ifdef DEBUG
#if 0
#endif
}
}
+
redraw_mask &= ~REDRAW_MAIN;
}
if (redraw_mask & REDRAW_DOORS)
{
if (redraw_mask & REDRAW_DOOR_1)
- XCopyArea(display,backbuffer,window,gc,
- DX,DY, DXSIZE,DYSIZE,
- DX,DY);
+ BlitBitmap(backbuffer, window, DX, DY, DXSIZE, DYSIZE, DX, DY);
if (redraw_mask & REDRAW_DOOR_2)
{
if ((redraw_mask & REDRAW_DOOR_2) == REDRAW_DOOR_2)
- XCopyArea(display,backbuffer,window,gc,
- VX,VY, VXSIZE,VYSIZE,
- VX,VY);
+ BlitBitmap(backbuffer, window, VX,VY, VXSIZE,VYSIZE, VX,VY);
else
{
if (redraw_mask & REDRAW_VIDEO_1)
- XCopyArea(display,backbuffer,window,gc,
- VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS,
- VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
- VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS);
+ BlitBitmap(backbuffer, window,
+ VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS,
+ VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
+ VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS);
if (redraw_mask & REDRAW_VIDEO_2)
- XCopyArea(display,backbuffer,window,gc,
- VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS,
- VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
- VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS);
+ BlitBitmap(backbuffer, window,
+ VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS,
+ VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
+ VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS);
if (redraw_mask & REDRAW_VIDEO_3)
- XCopyArea(display,backbuffer,window,gc,
- VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS,
- VIDEO_CONTROL_XSIZE,VIDEO_CONTROL_YSIZE,
- VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS);
+ BlitBitmap(backbuffer, window,
+ VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS,
+ VIDEO_CONTROL_XSIZE,VIDEO_CONTROL_YSIZE,
+ VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS);
}
}
+
if (redraw_mask & REDRAW_DOOR_3)
- XCopyArea(display, backbuffer, window, gc,
- EX, EY, EXSIZE, EYSIZE,
- EX, EY);
+ BlitBitmap(backbuffer, window, EX, EY, EXSIZE, EYSIZE, EX, EY);
+
redraw_mask &= ~REDRAW_DOORS;
}
- if (redraw_mask & REDRAW_MICROLEV)
+ if (redraw_mask & REDRAW_MICROLEVEL)
{
- XCopyArea(display,backbuffer,window,gc,
- MICROLEV_XPOS,MICROLEV_YPOS, MICROLEV_XSIZE,MICROLEV_YSIZE,
- MICROLEV_XPOS,MICROLEV_YPOS);
- XCopyArea(display,backbuffer,window,gc,
- SX,MICROLABEL_YPOS, SXSIZE,FONT4_YSIZE,
- SX,MICROLABEL_YPOS);
- redraw_mask &= ~REDRAW_MICROLEV;
+ BlitBitmap(backbuffer, window, SX, SY + 10 * TILEY, SXSIZE, 7 * TILEY,
+ SX, SY + 10 * TILEY);
+
+ redraw_mask &= ~REDRAW_MICROLEVEL;
}
if (redraw_mask & REDRAW_TILES)
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);
+ BlitBitmap(buffer, window,
+ FX + x * TILEX, FX + y * TILEY, TILEX, TILEY,
+ SX + x * TILEX, SY + y * TILEY);
+ }
+
+ if (redraw_mask & REDRAW_FPS) /* display frames per second */
+ {
+ char text[100];
+ char info1[100];
+
+ sprintf(info1, " (only every %d. frame)", global.fps_slowdown_factor);
+ if (!global.fps_slowdown)
+ info1[0] = '\0';
+
+ sprintf(text, "%.1f fps%s", global.frames_per_second, info1);
+ DrawTextExt(window, SX, SY, text, FONT_TEXT_2, BLIT_OPAQUE);
}
- XFlush(display);
+ FlushDisplay();
for(x=0; x<MAX_BUF_XSIZE; x++)
for(y=0; y<MAX_BUF_YSIZE; y++)
redraw[x][y] = 0;
redraw_tiles = 0;
- redraw_mask = 0;
+ redraw_mask = REDRAW_NONE;
}
void FadeToFront()
{
-/*
+#if 0
long fading_delay = 300;
if (setup.fading && (redraw_mask & REDRAW_FIELD))
{
-*/
+#endif
-/*
+#if 0
int x,y;
- XFillRectangle(display,window,gc,
- REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
- XFlush(display);
+ ClearRectangle(window, REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
+ FlushDisplay();
for(i=0;i<2*FULL_SYSIZE;i++)
{
for(y=0;y<FULL_SYSIZE;y++)
{
- XCopyArea(display,backbuffer,window,gc,
- REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
+ BlitBitmap(backbuffer, window,
+ REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
}
- XFlush(display);
+ FlushDisplay();
Delay(10);
}
-*/
+#endif
-/*
+#if 0
for(i=1;i<FULL_SYSIZE;i+=2)
- XCopyArea(display,backbuffer,window,gc,
- REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
- XFlush(display);
+ BlitBitmap(backbuffer, window,
+ REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
+ FlushDisplay();
Delay(fading_delay);
-*/
+#endif
-/*
- XSetClipOrigin(display,clip_gc[PIX_FADEMASK],0,0);
- XCopyArea(display,backbuffer,window,clip_gc[PIX_FADEMASK],
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE, REAL_SX,REAL_SY);
- XFlush(display);
+#if 0
+ SetClipOrigin(clip_gc[PIX_FADEMASK], 0, 0);
+ BlitBitmapMasked(backbuffer, window,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
+ REAL_SX,REAL_SY);
+ FlushDisplay();
Delay(fading_delay);
- XSetClipOrigin(display,clip_gc[PIX_FADEMASK],-1,-1);
- XCopyArea(display,backbuffer,window,clip_gc[PIX_FADEMASK],
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE, REAL_SX,REAL_SY);
- XFlush(display);
+ SetClipOrigin(clip_gc[PIX_FADEMASK], -1, -1);
+ BlitBitmapMasked(backbuffer, window,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
+ REAL_SX,REAL_SY);
+ FlushDisplay();
Delay(fading_delay);
- XSetClipOrigin(display,clip_gc[PIX_FADEMASK],0,-1);
- XCopyArea(display,backbuffer,window,clip_gc[PIX_FADEMASK],
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE, REAL_SX,REAL_SY);
- XFlush(display);
+ SetClipOrigin(clip_gc[PIX_FADEMASK], 0, -1);
+ BlitBitmapMasked(backbuffer, window,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
+ REAL_SX,REAL_SY);
+ FlushDisplay();
Delay(fading_delay);
- XSetClipOrigin(display,clip_gc[PIX_FADEMASK],-1,0);
- XCopyArea(display,backbuffer,window,clip_gc[PIX_FADEMASK],
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE, REAL_SX,REAL_SY);
- XFlush(display);
+ SetClipOrigin(clip_gc[PIX_FADEMASK], -1, 0);
+ BlitBitmapMasked(backbuffer, window,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
+ REAL_SX,REAL_SY);
+ FlushDisplay();
Delay(fading_delay);
redraw_mask &= ~REDRAW_MAIN;
}
-*/
+#endif
BackToFront();
}
+void SetMainBackgroundImage(int graphic)
+{
+ SetMainBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
+ graphic_info[graphic].bitmap ?
+ graphic_info[graphic].bitmap :
+ graphic_info[IMG_BACKGROUND].bitmap);
+}
+
+void SetDoorBackgroundImage(int graphic)
+{
+ SetDoorBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
+ graphic_info[graphic].bitmap ?
+ graphic_info[graphic].bitmap :
+ graphic_info[IMG_BACKGROUND].bitmap);
+}
+
+void DrawBackground(int dest_x, int dest_y, int width, int height)
+{
+ ClearRectangleOnBackground(backbuffer, dest_x, dest_y, width, height);
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
void ClearWindow()
{
- XFillRectangle(display, backbuffer, gc,
- REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
+ DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
- if (setup.soft_scrolling && game_status == PLAYING)
+ if (setup.soft_scrolling && game_status == GAME_MODE_PLAYING)
{
- XFillRectangle(display, fieldbuffer, gc, 0, 0, FXSIZE, FYSIZE);
+ ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
SetDrawtoField(DRAW_BUFFERED);
}
else
SetDrawtoField(DRAW_BACKBUFFER);
- if (setup.direct_draw && game_status == PLAYING)
+ if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
{
- XFillRectangle(display, window, gc,
- REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
+ ClearRectangle(window, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
SetDrawtoField(DRAW_DIRECT);
}
+}
- redraw_mask |= REDRAW_FIELD;
+void MarkTileDirty(int x, int y)
+{
+ int xx = redraw_x1 + x;
+ int yy = redraw_y1 + y;
+
+ if (!redraw[xx][yy])
+ redraw_tiles++;
+
+ redraw[xx][yy] = TRUE;
+ redraw_mask |= REDRAW_TILES;
}
-void DrawTextFCentered(int y, int font_type, char *format, ...)
+void SetBorderElement()
{
- char buffer[FULL_SXSIZE / FONT3_XSIZE + 10];
- int font_xsize;
- va_list ap;
+ int x, y;
+
+ BorderElement = EL_EMPTY;
- font_xsize = (font_type < FC_SPECIAL1 ? FONT2_XSIZE :
- font_type < FC_SPECIAL2 ? FONT3_XSIZE : FONT4_XSIZE);
+ for(y=0; y<lev_fieldy && BorderElement == EL_EMPTY; y++)
+ {
+ for(x=0; x<lev_fieldx; x++)
+ {
+ if (!IS_INDESTRUCTIBLE(Feld[x][y]))
+ BorderElement = EL_STEELWALL;
- va_start(ap, format);
- vsprintf(buffer, format, ap);
- va_end(ap);
+ if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
+ x = lev_fieldx - 2;
+ }
+ }
+}
- DrawText(SX + (SXSIZE - strlen(buffer) * font_xsize) / 2, SY + y,
- buffer, FS_SMALL, font_type);
+void SetRandomAnimationValue(int x, int y)
+{
+ gfx.anim_random_frame = GfxRandom[x][y];
}
-void DrawTextF(int x, int y, int font_type, char *format, ...)
+inline int getGraphicAnimationFrame(int graphic, int sync_frame)
{
- char buffer[FULL_SXSIZE / FONT3_XSIZE + 10];
- va_list ap;
+ /* animation synchronized with global frame counter, not move position */
+ if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
+ sync_frame = FrameCounter;
+
+ return getAnimationFrame(graphic_info[graphic].anim_frames,
+ graphic_info[graphic].anim_delay,
+ graphic_info[graphic].anim_mode,
+ graphic_info[graphic].anim_start_frame,
+ sync_frame);
+}
- va_start(ap, format);
- vsprintf(buffer, format, ap);
- va_end(ap);
+inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+ int graphic, int sync_frame, int mask_mode)
+{
+ int frame = getGraphicAnimationFrame(graphic, sync_frame);
- DrawText(SX + x, SY + y, buffer, FS_SMALL, font_type);
+ if (mask_mode == USE_MASKING)
+ DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
+ else
+ DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
}
-void DrawText(int x, int y, char *text, int font_size, int font_type)
+inline void DrawGraphicAnimation(int x, int y, int graphic)
{
- DrawTextExt(drawto, gc, x, y, text, font_size, font_type);
+ int lx = LEVELX(x), ly = LEVELY(y);
- if (x < DX)
- redraw_mask |= REDRAW_FIELD;
- else if (y < VY)
- redraw_mask |= REDRAW_DOOR_1;
+ if (!IN_SCR_FIELD(x, y))
+ return;
+
+ DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
+ graphic, GfxFrame[lx][ly], NO_MASKING);
+ MarkTileDirty(x, y);
}
-void DrawTextExt(Drawable d, GC gc, int x, int y,
- char *text, int font_size, int font_type)
+void DrawLevelGraphicAnimation(int x, int y, int graphic)
{
- int font_width, font_height, font_start;
- int font_pixmap;
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+}
- if (font_size != FS_SMALL && font_size != FS_BIG)
- font_size = FS_SMALL;
- if (font_type < FC_RED || font_type > FC_SPECIAL2)
- font_type = FC_RED;
+void DrawLevelElementAnimation(int x, int y, int element)
+{
+#if 1
+ int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
- 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_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);
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+#else
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), el2img(element));
+#endif
+}
- while(*text)
- {
- char c = *text++;
+inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
+{
+ int sx = SCREENX(x), sy = SCREENY(y);
- if (c >= 'a' && c <= 'z')
- c = 'A' + (c - 'a');
- else if (c == 'ä' || c == 'Ä')
- c = 91;
- else if (c == 'ö' || c == 'Ö')
- c = 92;
- else if (c == 'ü' || c == 'Ü')
- c = 93;
+ if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
+ return;
+
+ if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ return;
- if (c >= 32 && c <= 95)
- XCopyArea(display, pix[font_pixmap], d, gc,
- ((c - 32) % FONT_CHARS_PER_LINE) * font_width,
- ((c - 32) / FONT_CHARS_PER_LINE) * font_height + font_start,
- font_width, font_height, x, y);
+ DrawGraphicAnimation(sx, sy, graphic);
- x += font_width;
- }
+ if (CAN_BE_CRUMBLED(Feld[x][y]))
+ DrawLevelFieldCrumbledSand(x, y);
+}
+
+void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
+{
+ int sx = SCREENX(x), sy = SCREENY(y);
+ int graphic;
+
+ if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
+ return;
+
+ graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
+
+ if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ return;
+
+ DrawGraphicAnimation(sx, sy, graphic);
+
+ if (CAN_BE_CRUMBLED(element))
+ DrawLevelFieldCrumbledSand(x, y);
}
void DrawAllPlayers()
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)
{
+#if 0
int jx = player->jx, jy = player->jy;
int last_jx = player->last_jx, last_jy = player->last_jy;
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 graphic, phase;
+ int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
+ int graphic;
+ int frame = 0;
+ boolean player_is_moving = (last_jx != jx || last_jy != jy ? TRUE : FALSE);
+ int move_dir = player->MovDir;
+ int action = ACTION_DEFAULT;
+#else
+ int jx = player->jx, jy = player->jy;
+ int move_dir = player->MovDir;
+ int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
+ int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
+ int last_jx = (player->is_moving ? jx - dx : jx);
+ int last_jy = (player->is_moving ? jy - dy : jy);
+ int next_jx = jx + dx;
+ int next_jy = jy + dy;
+ int sx = SCREENX(jx), sy = SCREENY(jy);
+ int sxx = 0, syy = 0;
+ int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
+ int graphic;
+ int frame = 0;
+ boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
+ int action = ACTION_DEFAULT;
+#endif
- 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
}
#endif
- if (element == EL_EXPLODING)
+ if (element == EL_EXPLOSION)
return;
- /* draw things in the field the player is leaving, if needed */
+ action = (player->Pushing ? ACTION_PUSHING :
+ player->is_digging ? ACTION_DIGGING :
+ player->is_collecting ? ACTION_COLLECTING :
+ player->is_moving ? ACTION_MOVING :
+ player->snapped ? ACTION_SNAPPING : ACTION_DEFAULT);
+
+#if 0
+ printf("::: '%s'\n", element_action_info[action].suffix);
+#endif
+
+ InitPlayerGfxAnimation(player, action, move_dir);
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things in the field the player is leaving, if needed */
+ /* ----------------------------------------------------------------------- */
- if (last_jx != jx || last_jy != jy)
+#if 1
+ if (player->is_moving)
+#else
+ if (player_is_moving)
+#endif
{
- if (Store[last_jx][last_jy])
+ if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
{
- DrawLevelElement(last_jx, last_jy, Store[last_jx][last_jy]);
- DrawLevelFieldThruMask(last_jx, last_jy);
+ DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
+
+ if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
+ DrawDynamite(last_jx, last_jy);
+ else
+ DrawLevelFieldThruMask(last_jx, last_jy);
}
- else if (Feld[last_jx][last_jy] == EL_DYNAMIT)
+ else if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
DrawDynamite(last_jx, last_jy);
else
DrawLevelField(last_jx, last_jy);
if (player->Pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
{
+#if 1
+#if 1
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+#else
if (player->GfxPos)
{
- if (Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL)
- DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FELD_LEER);
+ if (Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL)
+ DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FIELD_EMPTY);
else
- DrawLevelElement(next_jx, next_jy, EL_LEERRAUM);
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
}
else
DrawLevelField(next_jx, next_jy);
+#endif
+#endif
}
}
if (setup.direct_draw)
SetDrawtoField(DRAW_BUFFERED);
- /* draw things behind the player, if needed */
+ /* ----------------------------------------------------------------------- */
+ /* draw things behind the player, if needed */
+ /* ----------------------------------------------------------------------- */
- if (Store[jx][jy])
- DrawLevelElement(jx, jy, Store[jx][jy]);
- else if (element != EL_DYNAMIT && element != EL_DYNABOMB)
- DrawLevelField(jx, jy);
+ if (Back[jx][jy])
+ DrawLevelElement(jx, jy, Back[jx][jy]);
+ else if (IS_ACTIVE_BOMB(element))
+ DrawLevelElement(jx, jy, EL_EMPTY);
+ else
+ {
+ if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
+ {
+#if 1
+ if (CAN_BE_CRUMBLED(GfxElement[jx][jy]))
+ DrawLevelFieldCrumbledSandDigging(jx, jy, move_dir, player->StepFrame);
+#else
+ if (GfxElement[jx][jy] == EL_SAND)
+ DrawLevelFieldCrumbledSandDigging(jx, jy, move_dir, player->StepFrame);
+#endif
+ else
+ {
+ int old_element = GfxElement[jx][jy];
+ int old_graphic = el_act_dir2img(old_element, action, move_dir);
+ int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
- /* draw player himself */
+ DrawGraphic(sx, sy, old_graphic, frame);
+ }
+ }
+ else
+ {
+ GfxElement[jx][jy] = EL_UNDEFINED;
- 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;
+ DrawLevelField(jx, jy);
+ }
+ }
- graphic += player->index_nr * 3*HEROES_PER_LINE;
- graphic += player->Frame;
+ /* ----------------------------------------------------------------------- */
+ /* draw player himself */
+ /* ----------------------------------------------------------------------- */
+
+ if (player->use_murphy_graphic)
+ {
+ static int last_horizontal_dir = MV_LEFT;
+ int direction;
+
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ last_horizontal_dir = move_dir;
+
+ direction = (player->snapped ? move_dir : last_horizontal_dir);
+
+ graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
+ }
+ else
+ graphic = el_act_dir2img(player->element_nr, player->GfxAction, move_dir);
+
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
if (player->GfxPos)
{
- if (player->MovDir == MV_LEFT || player->MovDir == MV_RIGHT)
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
sxx = player->GfxPos;
else
syy = player->GfxPos;
if (!setup.soft_scrolling && ScreenMovPos)
sxx = syy = 0;
- DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, NO_CUTTING);
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+
+ if (SHIELD_ON(player))
+ {
+ int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
+ IMG_SHIELD_NORMAL_ACTIVE);
+ int frame = getGraphicAnimationFrame(graphic, -1);
+
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ }
- if (player->Pushing && player->GfxPos)
+ /* ----------------------------------------------------------------------- */
+ /* draw things the player is pushing, if needed */
+ /* ----------------------------------------------------------------------- */
+
+#if 0
+ printf("::: %d, %d [%d, %d] [%d]\n",
+ player->Pushing, player_is_moving, player->GfxAction,
+ player->is_moving, player_is_moving);
+#endif
+
+#if 1
+ if (player->Pushing && player->is_moving)
+#else
+ if (player->Pushing && player_is_moving)
+#endif
{
int px = SCREENX(next_jx), py = SCREENY(next_jy);
- if (Feld[jx][jy] == EL_SOKOBAN_FELD_LEER ||
- Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL)
- DrawGraphicShiftedThruMask(px, py, sxx, syy, GFX_SOKOBAN_OBJEKT,
+ if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+
+#if 1
+ if ((sxx || syy) && element == EL_SOKOBAN_OBJECT)
+ DrawGraphicShiftedThruMask(px, py, sxx, syy, IMG_SOKOBAN_OBJECT, 0,
NO_CUTTING);
+#else
+ if ((sxx || syy) &&
+ (element == EL_SOKOBAN_FIELD_EMPTY ||
+ Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL))
+ DrawGraphicShiftedThruMask(px, py, sxx, syy, IMG_SOKOBAN_OBJECT, 0,
+ NO_CUTTING);
+#endif
else
{
+#if 1
+ int element = MovingOrBlocked2Element(next_jx, next_jy);
+#else
+#if 1
+ int element = Feld[jx][jy];
+#else
int element = Feld[next_jx][next_jy];
- int graphic = el2gfx(element);
+#endif
+#endif
- if (element == EL_FELSBROCKEN && sxx)
- {
- int phase = (player->GfxPos / (TILEX/4));
+#if 1
+ int graphic = el2img(element);
+ int frame = 0;
- if (player->MovDir == MV_LEFT)
- graphic += phase;
- else
- graphic += (phase+4)%4;
+#if 0
+ if ((sxx || syy) && IS_PUSHABLE(element))
+#endif
+ {
+ graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
}
- DrawGraphicShifted(px, py, sxx, syy, graphic, NO_CUTTING, NO_MASKING);
+#if 0
+ printf("::: pushing %d: %d ...\n", sxx, frame);
+#endif
+
+ DrawGraphicShifted(px, py, sxx, syy, graphic, frame,
+ NO_CUTTING, NO_MASKING);
+#endif
}
}
- /* 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);
+ graphic = el2img(element);
+ frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
- if (element == EL_DYNAMIT)
- {
- if ((phase = (96 - MovDelay[jx][jy]) / 12) > 6)
- phase = 6;
- }
+ if (game.emulation == EMU_SUPAPLEX)
+ DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
else
- {
- if ((phase = ((96 - MovDelay[jx][jy]) / 6) % 8) > 3)
- phase = 7 - phase;
- }
-
- DrawGraphicThruMask(sx, sy, graphic + phase);
+ DrawGraphicThruMask(sx, sy, graphic, frame);
}
- if ((last_jx != jx || last_jy != jy) &&
- Feld[last_jx][last_jy] == EL_EXPLODING)
+ if (player_is_moving && last_element == EL_EXPLOSION)
{
- int phase = Frame[last_jx][last_jy];
- int delay = 2;
+#if 1
+ int graphic = el_act2img(GfxElement[last_jx][last_jy], ACTION_EXPLODING);
+#else
+ int stored = Store[last_jx][last_jy];
+ int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
+ stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
+ IMG_SP_EXPLOSION);
+#endif
+ int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
+ int phase = ExplodePhase[last_jx][last_jy] - 1;
+ int frame = getGraphicAnimationFrame(graphic, phase - delay);
- if (phase > 2)
- DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy),
- GFX_EXPLOSION + ((phase - 1) / delay - 1));
+ if (phase >= delay)
+ DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
}
+ /* ----------------------------------------------------------------------- */
+ /* draw elements the player is just walking/passing through/under */
+ /* ----------------------------------------------------------------------- */
+
+ /* handle the field the player is leaving ... */
+ if (player_is_moving && IS_ACCESSIBLE_INSIDE(last_element))
+ DrawLevelField(last_jx, last_jy);
+ else if (player_is_moving && IS_ACCESSIBLE_UNDER(last_element))
+ DrawLevelFieldThruMask(last_jx, last_jy);
+
+ /* ... and the field the player is entering */
+ if (IS_ACCESSIBLE_INSIDE(element))
+ DrawLevelField(jx, jy);
+ else if (IS_ACCESSIBLE_UNDER(element))
+ DrawLevelFieldThruMask(jx, jy);
+
if (setup.direct_draw)
{
int dest_x = SX + SCREENX(MIN(jx, last_jx)) * TILEX;
int x_size = TILEX * (1 + ABS(jx - last_jx));
int y_size = TILEY * (1 + ABS(jy - last_jy));
- XCopyArea(display, drawto_field, window, gc,
- dest_x, dest_y, x_size, y_size, dest_x, dest_y);
+ BlitBitmap(drawto_field, window,
+ dest_x, dest_y, x_size, y_size, dest_x, dest_y);
SetDrawtoField(DRAW_DIRECT);
}
MarkTileDirty(sx,sy);
}
-static int getGraphicAnimationPhase(int frames, int delay, int mode)
+void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
{
- int phase;
+ struct GraphicInfo *g = &graphic_info[graphic];
- if (mode == ANIM_OSCILLATE)
- {
- int max_anim_frames = 2 * frames - 2;
- phase = (FrameCounter % (delay * max_anim_frames)) / delay;
- phase = (phase < frames ? phase : max_anim_frames - phase);
- }
- else
- phase = (FrameCounter % (delay * frames)) / delay;
-
- if (mode == ANIM_REVERSE)
- phase = -phase;
+ *bitmap = g->bitmap;
- return(phase);
-}
+ if (g->offset_y == 0) /* frames are ordered horizontally */
+ {
+ int max_width = g->anim_frames_per_line * g->width;
-void DrawGraphicAnimationExt(int x, int y, int graphic,
- int frames, int delay, int mode, int mask_mode)
-{
- int phase = getGraphicAnimationPhase(frames, delay, mode);
+ *x = (g->src_x + frame * g->offset_x) % max_width;
+ *y = g->src_y + (g->src_x + frame * g->offset_x) / max_width * g->height;
+ }
+ else if (g->offset_x == 0) /* frames are ordered vertically */
+ {
+ int max_height = g->anim_frames_per_line * g->height;
- if (!(FrameCounter % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+ *x = g->src_x + (g->src_y + frame * g->offset_y) / max_height * g->width;
+ *y = (g->src_y + frame * g->offset_y) % max_height;
+ }
+ else /* frames are ordered diagonally */
{
- if (mask_mode == USE_MASKING)
- DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic + phase);
- else
- DrawGraphic(SCREENX(x), SCREENY(y), graphic + phase);
+ *x = g->src_x + frame * g->offset_x;
+ *y = g->src_y + frame * g->offset_y;
}
}
-void DrawGraphicAnimation(int x, int y, int graphic,
- int frames, int delay, int mode)
-{
- DrawGraphicAnimationExt(x, y, graphic, frames, delay, mode, NO_MASKING);
-}
-
-void DrawGraphicAnimationThruMask(int x, int y, int graphic,
- int frames, int delay, int mode)
-{
- DrawGraphicAnimationExt(x, y, graphic, frames, delay, mode, USE_MASKING);
-}
-
-void DrawGraphic(int x, int y, int graphic)
+void DrawGraphic(int x, int y, int graphic, int frame)
{
#if DEBUG
- if (!IN_SCR_FIELD(x,y))
+ if (!IN_SCR_FIELD(x, y))
{
- printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+ 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);
+ DrawGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, frame);
+ MarkTileDirty(x, y);
}
-void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
+ int frame)
{
- 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);
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
+ BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
}
-void DrawGraphicThruMask(int x, int y, int graphic)
+void DrawGraphicThruMask(int x, int y, int graphic, int frame)
{
#if DEBUG
- if (!IN_SCR_FIELD(x,y))
+ if (!IN_SCR_FIELD(x, y))
{
printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
printf("DrawGraphicThruMask(): This should never happen!\n");
}
#endif
- DrawGraphicThruMaskExt(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic);
- MarkTileDirty(x,y);
+ DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y *TILEY, graphic,
+ frame);
+ MarkTileDirty(x, y);
}
-void DrawGraphicThruMaskExt(Drawable d, int dest_x, int dest_y, int graphic)
+void DrawGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, int graphic,
+ int frame)
{
+#if 1
+ Bitmap *src_bitmap;
int src_x, src_y;
- int tile = graphic;
- 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);
- return;
- }
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
+ drawing_gc = src_bitmap->stored_clip_gc;
+#else
+ GC drawing_gc = src_bitmap->stored_clip_gc;
+ Bitmap *src_bitmap = graphic_info[graphic].bitmap;
+ int src_x = graphic_info[graphic].src_x;
+ int src_y = graphic_info[graphic].src_y;
+ int offset_x = graphic_info[graphic].offset_x;
+ int offset_y = graphic_info[graphic].offset_y;
+
+ src_x += frame * offset_x;
+ src_y += frame * offset_y;
- 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,
- src_x, src_y, TILEX, TILEY, dest_x, dest_y);
- }
- else
- {
-#if DEBUG
- printf("DrawGraphicThruMask(): tile '%d' needs clipping!\n", tile);
#endif
- XSetClipOrigin(display, drawing_gc, dest_x-src_x, dest_y-src_y);
- XCopyArea(display, src_pixmap, drawto_field, drawing_gc,
- src_x, src_y, TILEX, TILEY, dest_x, dest_y);
- }
+ SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
+ BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
void DrawMiniGraphic(int x, int y, int graphic)
{
- DrawMiniGraphicExt(drawto,gc, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic);
- MarkTileDirty(x/2, y/2);
+ DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX,SY + y * MINI_TILEY, graphic);
+ MarkTileDirty(x / 2, y / 2);
}
-void DrawMiniGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
{
- 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);
+ struct GraphicInfo *g = &graphic_info[graphic];
+ int mini_startx = 0;
+ int mini_starty = g->bitmap->height * 2 / 3;
+
+ *bitmap = g->bitmap;
+ *x = mini_startx + g->src_x / 2;
+ *y = mini_starty + g->src_y / 2;
}
-void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
+void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
+{
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+
+ getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+ BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
+}
+
+void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, int frame,
int cut_mode, int mask_mode)
{
+ Bitmap *src_bitmap;
+ GC drawing_gc;
+ int src_x, src_y;
int width = TILEX, height = TILEY;
int cx = 0, cy = 0;
- int src_x, src_y, dest_x, dest_y;
- int tile = graphic;
- Pixmap src_pixmap;
- GC drawing_gc;
+ int dest_x, dest_y;
if (graphic < 0)
{
- DrawGraphic(x, y, graphic);
+ DrawGraphic(x, y, graphic, frame);
return;
}
- if (dx || dy) /* Verschiebung der Grafik? */
+ if (dx || dy) /* shifted graphic */
{
- if (x < BX1) /* Element kommt von links ins Bild */
+ if (x < BX1) /* object enters playfield from the left */
{
x = BX1;
width = dx;
cx = TILEX - dx;
dx = 0;
}
- else if (x > BX2) /* Element kommt von rechts ins Bild */
+ else if (x > BX2) /* object enters playfield from the right */
{
x = BX2;
width = -dx;
dx = TILEX + dx;
}
- else if (x==BX1 && dx < 0) /* Element verläßt links das Bild */
+ else if (x==BX1 && dx < 0) /* object leaves playfield to the left */
{
width += dx;
cx = -dx;
dx = 0;
}
- else if (x==BX2 && dx > 0) /* Element verläßt rechts das Bild */
+ else if (x==BX2 && dx > 0) /* object leaves playfield to the right */
width -= dx;
- else if (dx) /* allg. Bewegung in x-Richtung */
+ else if (dx) /* general horizontal movement */
MarkTileDirty(x + SIGN(dx), y);
- if (y < BY1) /* Element kommt von oben ins Bild */
+ if (y < BY1) /* object enters playfield from the top */
{
- if (cut_mode==CUT_BELOW) /* Element oberhalb des Bildes */
+ if (cut_mode==CUT_BELOW) /* object completely above top border */
return;
y = BY1;
cy = TILEY - dy;
dy = 0;
}
- else if (y > BY2) /* Element kommt von unten ins Bild */
+ else if (y > BY2) /* object enters playfield from the bottom */
{
y = BY2;
height = -dy;
dy = TILEY + dy;
}
- else if (y==BY1 && dy < 0) /* Element verläßt oben das Bild */
+ else if (y==BY1 && dy < 0) /* object leaves playfield to the top */
{
height += dy;
cy = -dy;
}
else if (dy > 0 && cut_mode == CUT_ABOVE)
{
- if (y == BY2) /* Element unterhalb des Bildes */
+ if (y == BY2) /* object completely above bottom border */
return;
height = dy;
cy = TILEY - dy;
dy = TILEY;
MarkTileDirty(x, y + 1);
- } /* Element verläßt unten das Bild */
+ } /* object leaves playfield to the bottom */
else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
height -= dy;
- else if (dy) /* allg. Bewegung in y-Richtung */
+ else if (dy) /* general vertical movement */
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;
+#if 1
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
+#else
+ src_bitmap = graphic_info[graphic].bitmap;
+ src_x = graphic_info[graphic].src_x;
+ src_y = graphic_info[graphic].src_y;
+ offset_x = graphic_info[graphic].offset_x;
+ offset_y = graphic_info[graphic].offset_y;
+
+ src_x += frame * offset_x;
+ src_y += frame * offset_y;
+#endif
+
+ drawing_gc = src_bitmap->stored_clip_gc;
+
+ src_x += cx;
+ src_y += cy;
dest_x = FX + x * TILEX + dx;
dest_y = FY + y * TILEY + dy;
#endif
if (mask_mode == USE_MASKING)
- {
- 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,
- src_x, src_y, TILEX, TILEY, dest_x, dest_y);
- }
- else
- {
-#if DEBUG
- printf("DrawGraphicShifted(): tile '%d' needs clipping!\n", tile);
-#endif
-
- XSetClipOrigin(display, drawing_gc, dest_x - src_x, dest_y - src_y);
- XCopyArea(display, src_pixmap, drawto_field, drawing_gc,
- src_x, src_y, width, height, dest_x, dest_y);
- }
+ {
+ SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
+ BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
+ dest_x, dest_y);
}
else
- XCopyArea(display, src_pixmap, drawto_field, gc,
- src_x, src_y, width, height, dest_x, dest_y);
+ BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
+ dest_x, dest_y);
MarkTileDirty(x,y);
}
-void DrawGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic,
- int cut_mode)
+void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy, int graphic,
+ int frame, int cut_mode)
{
- DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode, USE_MASKING);
+ DrawGraphicShifted(x,y, dx,dy, graphic, frame, cut_mode, USE_MASKING);
}
void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
int cut_mode, int mask_mode)
{
- int ux = LEVELX(x), uy = LEVELY(y);
- int graphic = el2gfx(element);
- int phase4 = ABS(MovPos[ux][uy]) / (TILEX / 4);
- int phase = phase4 / 2;
- int dir = MovDir[ux][uy];
-
- if (element == EL_PACMAN || element == EL_KAEFER || element == EL_FLIEGER)
- {
- graphic += 4*!phase;
-
- if (dir == MV_UP)
- graphic += 1;
- else if (dir == MV_LEFT)
- graphic += 2;
- else if (dir == MV_DOWN)
- graphic += 3;
- }
- else if (element == EL_MAULWURF || element == EL_PINGUIN ||
- element == EL_SCHWEIN || element == EL_DRACHE)
- {
- if (dir == MV_LEFT)
- graphic = (element == EL_MAULWURF ? GFX_MAULWURF_LEFT :
- element == EL_PINGUIN ? GFX_PINGUIN_LEFT :
- element == EL_SCHWEIN ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT);
- else if (dir == MV_RIGHT)
- graphic = (element == EL_MAULWURF ? GFX_MAULWURF_RIGHT :
- element == EL_PINGUIN ? GFX_PINGUIN_RIGHT :
- element == EL_SCHWEIN ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT);
- else if (dir == MV_UP)
- graphic = (element == EL_MAULWURF ? GFX_MAULWURF_UP :
- element == EL_PINGUIN ? GFX_PINGUIN_UP :
- element == EL_SCHWEIN ? GFX_SCHWEIN_UP : GFX_DRACHE_UP);
- else
- graphic = (element == EL_MAULWURF ? GFX_MAULWURF_DOWN :
- element == EL_PINGUIN ? GFX_PINGUIN_DOWN :
- element == EL_SCHWEIN ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN);
+ int lx = LEVELX(x), ly = LEVELY(y);
+ int graphic;
+ int frame;
- graphic += phase4;
- }
- else if (element == EL_SONDE)
- {
- graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_NORMAL);
- }
- else if (element == EL_SALZSAEURE)
- {
- graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_NORMAL);
- }
- else if (element == EL_BUTTERFLY || element == EL_FIREFLY)
+ if (IN_LEV_FIELD(lx, ly))
{
- graphic += !phase;
- }
- else if ((element == EL_FELSBROCKEN || IS_GEM(element)) && !cut_mode)
- {
- if (element != EL_SP_INFOTRON)
- graphic += phase * (element == EL_FELSBROCKEN ? 2 : 1);
- }
- else if (element == EL_SIEB_LEER || element == EL_SIEB2_LEER ||
- element == EL_SIEB_VOLL || element == EL_SIEB2_VOLL)
- {
- graphic += 3 + getGraphicAnimationPhase(4, 4, ANIM_REVERSE);
+ SetRandomAnimationValue(lx, ly);
+
+ graphic = el_act_dir2img(element, GfxAction[lx][ly], MovDir[lx][ly]);
+ frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
}
- else if (IS_AMOEBOID(element))
+ else /* border element */
{
- graphic = (element == EL_AMOEBE_TOT ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
- graphic += (x + 2 * y + 4) % 4;
+ graphic = el2img(element);
+ frame = getGraphicAnimationFrame(graphic, -1);
}
- else if (element == EL_MAUER_LEBT)
+
+ if (element == EL_EXPANDABLE_WALL)
{
- boolean links_massiv = FALSE, rechts_massiv = FALSE;
+ boolean left_stopped = FALSE, right_stopped = FALSE;
- if (!IN_LEV_FIELD(ux-1, uy) || IS_MAUER(Feld[ux-1][uy]))
- links_massiv = TRUE;
- if (!IN_LEV_FIELD(ux+1, uy) || IS_MAUER(Feld[ux+1][uy]))
- rechts_massiv = TRUE;
+ if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Feld[lx - 1][ly]))
+ left_stopped = TRUE;
+ if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Feld[lx + 1][ly]))
+ right_stopped = TRUE;
- if (links_massiv && rechts_massiv)
- graphic = GFX_MAUERWERK;
- else if (links_massiv)
- graphic = GFX_MAUER_R;
- else if (rechts_massiv)
- graphic = GFX_MAUER_L;
+ if (left_stopped && right_stopped)
+ graphic = IMG_WALL;
+ else if (left_stopped)
+ {
+ graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
+ frame = graphic_info[graphic].anim_frames - 1;
+ }
+ else if (right_stopped)
+ {
+ graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
+ frame = graphic_info[graphic].anim_frames - 1;
+ }
}
if (dx || dy)
- DrawGraphicShifted(x, y, dx, dy, graphic, cut_mode, mask_mode);
+ DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
else if (mask_mode == USE_MASKING)
- DrawGraphicThruMask(x, y, graphic);
+ DrawGraphicThruMask(x, y, graphic, frame);
else
- DrawGraphic(x, y, graphic);
+ DrawGraphic(x, y, graphic, frame);
}
void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
}
-void DrawScreenElementThruMask(int x, int y, int element)
-{
- DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
-}
-
void DrawLevelElementThruMask(int x, int y, int element)
{
DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
}
-void ErdreichAnbroeckeln(int x, int y)
+static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
{
- int i, width, height, cx,cy;
- int ux = LEVELX(x), uy = LEVELY(y);
- int element, graphic;
- int snip = 4;
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+ int sx = SCREENX(x), sy = SCREENY(y);
+ int element;
+ int width, height, cx, cy, i;
+ int snip = TILEX / 8; /* number of border pixels from "crumbled graphic" */
static int xy[4][2] =
{
{ 0, -1 },
{ 0, +1 }
};
- if (!IN_LEV_FIELD(ux, uy))
+ if (!IN_LEV_FIELD(x, y))
return;
- element = Feld[ux][uy];
+ element = (GfxElement[x][y] != EL_UNDEFINED && Feld[x][y] != EL_EXPLOSION ?
+ GfxElement[x][y] : Feld[x][y]);
- if (element == EL_ERDREICH)
+ /* crumble field itself */
+ if (CAN_BE_CRUMBLED(element) && !IS_MOVING(x, y))
{
- if (!IN_SCR_FIELD(x, y))
+ if (!IN_SCR_FIELD(sx, sy))
return;
- graphic = GFX_ERDENRAND;
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
for(i=0; i<4; i++)
{
- int uxx, uyy;
+ int xx = x + xy[i][0];
+ int yy = y + xy[i][1];
- uxx = ux + xy[i][0];
- uyy = uy + xy[i][1];
- if (!IN_LEV_FIELD(uxx, uyy))
- element = EL_BETON;
- else
- element = Feld[uxx][uyy];
+ element = (IN_LEV_FIELD(xx, yy) ? Feld[xx][yy] : BorderElement);
- if (element == EL_ERDREICH)
+ /* check if neighbour field is of same type */
+ if (CAN_BE_CRUMBLED(element) && !IS_MOVING(xx, yy))
continue;
+#if 0
+ if (Feld[x][y] == EL_CUSTOM_START + 123)
+ printf("::: crumble [%d] THE CHAOS ENGINE (%d, %d): %d, %d\n",
+ i, Feld[x][y], element,
+ CAN_BE_CRUMBLED(element), IS_MOVING(x, y));
+#endif
+
if (i == 1 || i == 2)
{
width = snip;
cy = (i == 3 ? TILEY - snip : 0);
}
- XCopyArea(display, pix[PIX_BACK], drawto_field, gc,
- SX + (graphic % GFX_PER_LINE) * TILEX + cx,
- SY + (graphic / GFX_PER_LINE) * TILEY + cy,
- width, height, FX + x * TILEX + cx, FY + y * TILEY + cy);
+ BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+ width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
}
- MarkTileDirty(x, y);
+ MarkTileDirty(sx, sy);
}
- else
+ else /* crumble neighbour fields */
{
- graphic = GFX_ERDENRAND;
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
for(i=0; i<4; i++)
{
- int xx, yy, uxx, uyy;
-
- xx = x + xy[i][0];
- yy = y + xy[i][1];
- uxx = ux + xy[i][0];
- uyy = uy + xy[i][1];
-
- if (!IN_LEV_FIELD(uxx, uyy) || Feld[uxx][uyy] != EL_ERDREICH ||
- !IN_SCR_FIELD(xx, yy))
+ int xx = x + xy[i][0];
+ int yy = y + xy[i][1];
+ int sxx = sx + xy[i][0];
+ int syy = sy + xy[i][1];
+
+ if (!IN_LEV_FIELD(xx, yy) ||
+ !IN_SCR_FIELD(sxx, syy) ||
+ !CAN_BE_CRUMBLED(Feld[xx][yy]) ||
+ IS_MOVING(xx, yy))
continue;
if (i == 1 || i == 2)
cy = (i==0 ? TILEY-snip : 0);
}
- XCopyArea(display, pix[PIX_BACK], drawto_field, gc,
- SX + (graphic % GFX_PER_LINE) * TILEX + cx,
- SY + (graphic / GFX_PER_LINE) * TILEY + cy,
- width, height, FX + xx * TILEX + cx, FY + yy * TILEY + cy);
+ BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+ width, height, FX + sxx * TILEX + cx, FY + syy * TILEY + cy);
- MarkTileDirty(xx, yy);
+ MarkTileDirty(sxx, syy);
}
}
}
+void DrawLevelFieldCrumbledSand(int x, int y)
+{
+ DrawLevelFieldCrumbledSandExt(x, y, IMG_SAND_CRUMBLED, 0);
+}
+
+void DrawLevelFieldCrumbledSandDigging(int x, int y, int direction,
+ int step_frame)
+{
+#if 1
+ int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
+ int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
+#else
+ int graphic1 = el_act_dir2img(EL_SAND, ACTION_DIGGING, direction);
+ int graphic2 = el_act_dir2img(EL_SAND_CRUMBLED, ACTION_DIGGING, direction);
+#endif
+ int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
+ int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
+ int sx = SCREENX(x), sy = SCREENY(y);
+
+ DrawGraphic(sx, sy, graphic1, frame1);
+ DrawLevelFieldCrumbledSandExt(x, y, graphic2, frame2);
+}
+
+void DrawLevelFieldCrumbledSandNeighbours(int x, int y)
+{
+ int sx = SCREENX(x), sy = SCREENY(y);
+ static int xy[4][2] =
+ {
+ { 0, -1 },
+ { -1, 0 },
+ { +1, 0 },
+ { 0, +1 }
+ };
+ int i;
+
+ for(i=0; i<4; i++)
+ {
+ int xx = x + xy[i][0];
+ int yy = y + xy[i][1];
+ int sxx = sx + xy[i][0];
+ int syy = sy + xy[i][1];
+
+ if (!IN_LEV_FIELD(xx, yy) ||
+ !IN_SCR_FIELD(sxx, syy) ||
+ !CAN_BE_CRUMBLED(Feld[xx][yy]) ||
+ IS_MOVING(xx, yy))
+ continue;
+
+ DrawLevelField(xx, yy);
+ }
+}
+
+static int getBorderElement(int x, int y)
+{
+ int border[7][2] =
+ {
+ { EL_STEELWALL_TOPLEFT, EL_INVISIBLE_STEELWALL_TOPLEFT },
+ { EL_STEELWALL_TOPRIGHT, EL_INVISIBLE_STEELWALL_TOPRIGHT },
+ { EL_STEELWALL_BOTTOMLEFT, EL_INVISIBLE_STEELWALL_BOTTOMLEFT },
+ { EL_STEELWALL_BOTTOMRIGHT, EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
+ { EL_STEELWALL_VERTICAL, EL_INVISIBLE_STEELWALL_VERTICAL },
+ { EL_STEELWALL_HORIZONTAL, EL_INVISIBLE_STEELWALL_HORIZONTAL },
+ { EL_STEELWALL, EL_INVISIBLE_STEELWALL }
+ };
+ int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
+ int 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 : 6);
+
+ return border[steel_position][steel_type];
+}
+
void DrawScreenElement(int x, int y, int element)
{
DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
- ErdreichAnbroeckeln(x, y);
+ DrawLevelFieldCrumbledSand(LEVELX(x), LEVELY(y));
}
void DrawLevelElement(int x, int y, int element)
void DrawScreenField(int x, int y)
{
- int ux = LEVELX(x), uy = LEVELY(y);
- int element;
+ int lx = LEVELX(x), ly = LEVELY(y);
+ int element, content;
- if (!IN_LEV_FIELD(ux, uy))
+ if (!IN_LEV_FIELD(lx, ly))
{
- DrawScreenElement(x, y, EL_BETON);
+ if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
+ element = EL_EMPTY;
+ else
+ element = getBorderElement(lx, ly);
+
+ DrawScreenElement(x, y, element);
return;
}
- element = Feld[ux][uy];
+ element = Feld[lx][ly];
+ content = Store[lx][ly];
- if (IS_MOVING(ux, uy))
+ if (IS_MOVING(lx, ly))
{
- int horiz_move = (MovDir[ux][uy] == MV_LEFT || MovDir[ux][uy] == MV_RIGHT);
+ int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
boolean cut_mode = NO_CUTTING;
- if (Store[ux][uy] == EL_MORAST_LEER ||
- Store[ux][uy] == EL_SIEB_LEER ||
- Store[ux][uy] == EL_SIEB2_LEER ||
- Store[ux][uy] == EL_AMOEBE_NASS)
+ if (element == EL_QUICKSAND_EMPTYING ||
+ element == EL_MAGIC_WALL_EMPTYING ||
+ element == EL_BD_MAGIC_WALL_EMPTYING ||
+ element == EL_AMOEBA_DROPPING)
cut_mode = CUT_ABOVE;
- else if (Store[ux][uy] == EL_MORAST_VOLL ||
- Store[ux][uy] == EL_SIEB_VOLL ||
- Store[ux][uy] == EL_SIEB2_VOLL)
+ else if (element == EL_QUICKSAND_FILLING ||
+ element == EL_MAGIC_WALL_FILLING ||
+ element == EL_BD_MAGIC_WALL_FILLING)
cut_mode = CUT_BELOW;
if (cut_mode == CUT_ABOVE)
- DrawScreenElementShifted(x, y, 0, 0, Store[ux][uy], NO_CUTTING);
+ DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
else
- DrawScreenElement(x, y, EL_LEERRAUM);
+ DrawScreenElement(x, y, EL_EMPTY);
if (horiz_move)
- DrawScreenElementShifted(x, y, MovPos[ux][uy], 0, element, NO_CUTTING);
+ DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
+ else if (cut_mode == NO_CUTTING)
+ DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
else
- DrawScreenElementShifted(x, y, 0, MovPos[ux][uy], element, cut_mode);
+ DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
- if (Store[ux][uy] == EL_SALZSAEURE)
- DrawLevelElementThruMask(ux, uy + 1, EL_SALZSAEURE);
+ if (content == EL_ACID)
+ DrawLevelElementThruMask(lx, ly + 1, EL_ACID);
}
- else if (IS_BLOCKED(ux, uy))
+ else if (IS_BLOCKED(lx, ly))
{
int oldx, oldy;
int sx, sy;
int horiz_move;
boolean cut_mode = NO_CUTTING;
+ int element_old, content_old;
- Blocked2Moving(ux, uy, &oldx, &oldy);
+ Blocked2Moving(lx, ly, &oldx, &oldy);
sx = SCREENX(oldx);
sy = SCREENY(oldy);
horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
MovDir[oldx][oldy] == MV_RIGHT);
- if (Store[oldx][oldy] == EL_MORAST_LEER ||
- Store[oldx][oldy] == EL_SIEB_LEER ||
- Store[oldx][oldy] == EL_SIEB2_LEER ||
- Store[oldx][oldy] == EL_AMOEBE_NASS)
+ element_old = Feld[oldx][oldy];
+ content_old = Store[oldx][oldy];
+
+ if (element_old == EL_QUICKSAND_EMPTYING ||
+ element_old == EL_MAGIC_WALL_EMPTYING ||
+ element_old == EL_BD_MAGIC_WALL_EMPTYING ||
+ element_old == EL_AMOEBA_DROPPING)
cut_mode = CUT_ABOVE;
- DrawScreenElement(x, y, EL_LEERRAUM);
- element = Feld[oldx][oldy];
+ DrawScreenElement(x, y, EL_EMPTY);
if (horiz_move)
- DrawScreenElementShifted(sx,sy, MovPos[oldx][oldy],0,element,NO_CUTTING);
+ DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
+ NO_CUTTING);
+ else if (cut_mode == NO_CUTTING)
+ DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
+ cut_mode);
else
- DrawScreenElementShifted(sx,sy, 0,MovPos[oldx][oldy],element,cut_mode);
+ DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
+ cut_mode);
}
else if (IS_DRAWABLE(element))
DrawScreenElement(x, y, element);
else
- DrawScreenElement(x, y, EL_LEERRAUM);
+ DrawScreenElement(x, y, EL_EMPTY);
}
void DrawLevelField(int x, int y)
{
int graphic;
- if (!element)
- {
- DrawMiniGraphic(x, y, -1);
- return;
- }
-
- graphic = el2gfx(element);
+ graphic = el2edimg(element);
DrawMiniGraphic(x, y, graphic);
}
int x = sx + scroll_x, y = sy + scroll_y;
if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
- DrawMiniElement(sx, sy, EL_LEERRAUM);
- else if (x == -1 || x == lev_fieldx || y == -1 || y == lev_fieldy)
- DrawMiniElement(sx, sy, EL_BETON);
- else
+ DrawMiniElement(sx, sy, EL_EMPTY);
+ else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
DrawMiniElement(sx, sy, Feld[x][y]);
+ else
+ DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
}
-void DrawMicroElement(int xpos, int ypos, int element)
+void DrawEnvelopeBorder(int sx, int sy, int ex, int ey)
{
- int graphic;
+ int border[8][2] =
+ {
+ { EL_STEELWALL_TOPLEFT, EL_INVISIBLE_STEELWALL_TOPLEFT },
+ { EL_STEELWALL_TOPRIGHT, EL_INVISIBLE_STEELWALL_TOPRIGHT },
+ { EL_STEELWALL_BOTTOMLEFT, EL_INVISIBLE_STEELWALL_BOTTOMLEFT },
+ { EL_STEELWALL_BOTTOMRIGHT, EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
+ { EL_STEELWALL_VERTICAL, EL_INVISIBLE_STEELWALL_VERTICAL },
+ { EL_STEELWALL_HORIZONTAL, EL_INVISIBLE_STEELWALL_HORIZONTAL },
+ { EL_STEELWALL, EL_INVISIBLE_STEELWALL },
+ { EL_EMPTY, EL_EMPTY }
+ };
+ int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
+ int steel_position = (ex == -1 && ey == -1 ? 0 :
+ ex == +1 && ey == -1 ? 1 :
+ ex == -1 && ey == +1 ? 2 :
+ ex == +1 && ey == +1 ? 3 :
+ ex == -1 || ex == +1 ? 4 :
+ ey == -1 || ey == +1 ? 5 : 7);
+ int element = border[steel_position][steel_type];
+
+ DrawMiniGraphic(sx, sy, el2edimg(element));
+}
- if (element == EL_LEERRAUM)
- return;
+void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
+{
+ Bitmap *src_bitmap = graphic_info[graphic].bitmap;
+ int mini_startx = src_bitmap->width * 3 / 4;
+ int mini_starty = src_bitmap->height * 2 / 3;
+ int src_x = mini_startx + graphic_info[graphic].src_x / 8;
+ int src_y = mini_starty + graphic_info[graphic].src_y / 8;
+
+ *bitmap = src_bitmap;
+ *x = src_x;
+ *y = src_y;
+}
- graphic = el2gfx(element);
+void DrawMicroElement(int xpos, int ypos, int element)
+{
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+ int graphic = el2preimg(element);
- if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
- {
- 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,
- MICRO_TILEX, MICRO_TILEY, xpos, ypos);
- }
- else
- XCopyArea(display, pix[PIX_BACK], drawto, gc,
- MICRO_GFX_STARTX + (graphic % MICRO_GFX_PER_LINE) * MICRO_TILEX,
- MICRO_GFX_STARTY + (graphic / MICRO_GFX_PER_LINE) * MICRO_TILEY,
- MICRO_TILEX, MICRO_TILEY, xpos, ypos);
+ getMicroGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+ BlitBitmap(src_bitmap, drawto, src_x, src_y, MICRO_TILEX, MICRO_TILEY,
+ xpos, ypos);
}
void DrawLevel()
{
int x,y;
+ SetDrawBackgroundMask(REDRAW_NONE);
ClearWindow();
for(x=BX1; x<=BX2; x++)
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 scroll_x, int scroll_y)
+void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
{
int x,y;
- ClearWindow();
-
- for(x=0; x<2*SCR_FIELDX; x++)
- for(y=0; y<2*SCR_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;
}
-void DrawMicroLevel(int xpos, int ypos)
+static void DrawMicroLevelExt(int xpos, int ypos, int from_x, int from_y)
{
- int x,y;
+ int x, y;
+
+ DrawBackground(xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
- XFillRectangle(display, drawto, gc,
- xpos - MICRO_TILEX, ypos - MICRO_TILEY,
- MICRO_TILEX * (STD_LEV_FIELDX + 2),
- MICRO_TILEY * (STD_LEV_FIELDY + 2));
if (lev_fieldx < STD_LEV_FIELDX)
- xpos += (STD_LEV_FIELDX - lev_fieldx)/2 * MICRO_TILEX;
+ xpos += (STD_LEV_FIELDX - lev_fieldx) / 2 * MICRO_TILEX;
if (lev_fieldy < STD_LEV_FIELDY)
- ypos += (STD_LEV_FIELDY - lev_fieldy)/2 * MICRO_TILEY;
+ ypos += (STD_LEV_FIELDY - lev_fieldy) / 2 * MICRO_TILEY;
+
+ xpos += MICRO_TILEX;
+ ypos += MICRO_TILEY;
for(x=-1; x<=STD_LEV_FIELDX; x++)
+ {
for(y=-1; y<=STD_LEV_FIELDY; y++)
- if (x >= 0 && x < lev_fieldx && y >= 0 && y < lev_fieldy)
+ {
+ int lx = from_x + x, ly = from_y + y;
+
+ if (lx >= 0 && lx < lev_fieldx && ly >= 0 && ly < lev_fieldy)
DrawMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
- Ur[x][y]);
- else if (x >= -1 && x < lev_fieldx+1 && y >= -1 && y < lev_fieldy+1)
+ level.field[lx][ly]);
+ else if (lx >= -1 && lx < lev_fieldx+1 && ly >= -1 && ly < lev_fieldy+1
+ && BorderElement != EL_EMPTY)
DrawMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
- EL_BETON);
+ getBorderElement(lx, ly));
+ }
+ }
+
+ redraw_mask |= REDRAW_MICROLEVEL;
+}
- XFillRectangle(display, drawto,gc, SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE);
+#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
- if (level.name)
+static void DrawMicroLevelLabelExt(int mode)
+{
+ char label_text[MAX_OUTPUT_LINESIZE + 1];
+ int max_len_label_text;
+ int font_nr = FONT_TEXT_2;
+
+ if (mode == MICROLABEL_CREATED_BY || mode == MICROLABEL_IMPORTED_FROM)
+ font_nr = FONT_TEXT_3;
+
+ max_len_label_text = SXSIZE / getFontWidth(font_nr);
+
+ DrawBackground(SX, MICROLABEL_YPOS, SXSIZE, getFontHeight(font_nr));
+
+ 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_current->imported_from : ""),
+ max_len_label_text);
+ label_text[max_len_label_text] = '\0';
+
+ if (strlen(label_text) > 0)
{
- int len = strlen(level.name);
- int lxpos = SX + (SXSIZE - len * FONT4_XSIZE) / 2;
+ int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
int lypos = MICROLABEL_YPOS;
- DrawText(lxpos, lypos, level.name, FS_SMALL, FC_SPECIAL2);
+ DrawText(lxpos, lypos, label_text, font_nr);
+ }
+
+ redraw_mask |= REDRAW_MICROLEVEL;
+}
+
+void DrawMicroLevel(int xpos, int ypos, boolean restart)
+{
+ static unsigned long scroll_delay = 0;
+ static unsigned long label_delay = 0;
+ static int from_x, from_y, scroll_direction;
+ static int label_state, label_counter;
+ int last_game_status = game_status; /* save current game status */
+
+ /* force PREVIEW font on preview level */
+ game_status = GAME_MODE_PSEUDO_PREVIEW;
+
+ if (restart)
+ {
+ from_x = from_y = 0;
+ scroll_direction = MV_RIGHT;
+ label_state = 1;
+ label_counter = 0;
+
+ DrawMicroLevelExt(xpos, ypos, from_x, from_y);
+ DrawMicroLevelLabelExt(label_state);
+
+ /* initialize delay counters */
+ DelayReached(&scroll_delay, 0);
+ DelayReached(&label_delay, 0);
+
+ if (leveldir_current->name)
+ {
+ int text_width = getTextWidth(leveldir_current->name, FONT_TEXT_1);
+ int lxpos = SX + (SXSIZE - text_width) / 2;
+ int lypos = SY + 352;
+
+ DrawText(lxpos, lypos, leveldir_current->name, FONT_TEXT_1);
+ }
+
+ game_status = last_game_status; /* restore current game status */
+
+ return;
+ }
+
+ /* scroll micro level, if needed */
+ if ((lev_fieldx > STD_LEV_FIELDX || lev_fieldy > STD_LEV_FIELDY) &&
+ DelayReached(&scroll_delay, MICROLEVEL_SCROLL_DELAY))
+ {
+ switch (scroll_direction)
+ {
+ case MV_LEFT:
+ if (from_x > 0)
+ from_x--;
+ else
+ scroll_direction = MV_UP;
+ break;
+
+ case MV_RIGHT:
+ if (from_x < lev_fieldx - STD_LEV_FIELDX)
+ from_x++;
+ else
+ scroll_direction = MV_DOWN;
+ break;
+
+ case MV_UP:
+ if (from_y > 0)
+ from_y--;
+ else
+ scroll_direction = MV_RIGHT;
+ break;
+
+ case MV_DOWN:
+ if (from_y < lev_fieldy - STD_LEV_FIELDY)
+ from_y++;
+ else
+ scroll_direction = MV_LEFT;
+ break;
+
+ default:
+ break;
+ }
+
+ DrawMicroLevelExt(xpos, ypos, from_x, from_y);
+ }
+
+ /* redraw micro level label, if needed */
+ if (strcmp(level.name, NAMELESS_LEVEL_NAME) != 0 &&
+ strcmp(level.author, ANONYMOUS_NAME) != 0 &&
+ strcmp(level.author, leveldir_current->name) != 0 &&
+ DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
+ {
+ int max_label_counter = 23;
+
+ if (leveldir_current->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);
}
- redraw_mask |= REDRAW_MICROLEV;
+ game_status = last_game_status; /* restore current game status */
}
int REQ_in_range(int x, int y)
return 0;
}
+#define MAX_REQUEST_LINES 13
+#define MAX_REQUEST_LINE_LEN 7
+
boolean Request(char *text, unsigned int req_state)
{
int mx, my, ty, result = -1;
unsigned int old_door_state;
+ int last_game_status = game_status; /* save current game status */
-#ifndef MSDOS
+#if 1
+ SetMouseCursor(CURSOR_DEFAULT);
+#endif
+
+#if defined(PLATFORM_UNIX)
/* pause network game while waiting for request to answer */
if (options.network &&
- game_status == PLAYING &&
+ game_status == GAME_MODE_PLAYING &&
req_state & REQUEST_WAIT_FOR)
SendToServer_PausePlaying();
#endif
old_door_state = GetDoorState();
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ UnmapAllGadgets();
+
CloseDoor(DOOR_CLOSE_1);
- /* Alten Türinhalt sichern */
- XCopyArea(display, pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
- DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
+ /* save old door content */
+ BlitBitmap(bitmap_db_door, bitmap_db_door,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
- /* Fragetext schreiben */
- XFillRectangle(display, pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE);
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
- for(ty=0; ty<13; ty++)
+ /* clear door drawing field */
+ DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+ /* force DOOR font on preview level */
+ game_status = GAME_MODE_PSEUDO_DOOR;
+
+ /* write text for request */
+ for(ty=0; ty < MAX_REQUEST_LINES; ty++)
{
+ char text_line[MAX_REQUEST_LINE_LEN + 1];
int tx, tl, tc;
- char txt[256];
if (!*text)
break;
- for(tl=0,tx=0; tx<7; tl++,tx++)
+ for(tl=0,tx=0; tx < MAX_REQUEST_LINE_LEN; tl++,tx++)
{
tc = *(text + tx);
- if (!tc || tc == 32)
+ if (!tc || tc == ' ')
break;
}
+
if (!tl)
{
text++;
ty--;
continue;
}
- sprintf(txt, text);
- txt[tl] = 0;
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + 51 - (tl * 14)/2, SY + ty * 16,
- txt, FS_SMALL, FC_YELLOW);
- text += tl + (tc == 32 ? 1 : 0);
+
+ strncpy(text_line, text, tl);
+ text_line[tl] = 0;
+
+ DrawText(DX + (DXSIZE - tl * getFontWidth(FONT_TEXT_2)) / 2,
+ DY + 8 + ty * (getFontHeight(FONT_TEXT_2) + 2),
+ text_line, FONT_TEXT_2);
+
+ text += tl + (tc == ' ' ? 1 : 0);
}
+ game_status = last_game_status; /* restore current game status */
+
if (req_state & REQ_ASK)
{
- DrawYesNoButton(BUTTON_OK, DB_INIT);
- DrawYesNoButton(BUTTON_NO, DB_INIT);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
}
else if (req_state & REQ_CONFIRM)
{
- DrawConfirmButton(BUTTON_CONFIRM, DB_INIT);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
}
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);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
}
+ /* copy request gadgets to door backbuffer */
+ BlitBitmap(drawto, bitmap_db_door,
+ DX, DY, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+
OpenDoor(DOOR_OPEN_1);
+
+#if 0
ClearEventQueue();
+#endif
if (!(req_state & REQUEST_WAIT_FOR))
- return(FALSE);
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
- if (game_status != MAINMENU)
+ return FALSE;
+ }
+
+ if (game_status != GAME_MODE_MAIN)
InitAnimation();
button_status = MB_RELEASED;
+ request_gadget_id = -1;
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+#if 0
+ SetMouseCursor(CURSOR_DEFAULT);
+#endif
+
while(result < 0)
{
- if (XPending(display))
+ if (PendingEvent())
{
- XEvent event;
+ Event event;
- XNextEvent(display, &event);
+ NextEvent(&event);
switch(event.type)
{
- case ButtonPress:
- case ButtonRelease:
- case MotionNotify:
+ case EVENT_BUTTONPRESS:
+ case EVENT_BUTTONRELEASE:
+ case EVENT_MOTIONNOTIFY:
{
- int choice;
-
- if (event.type == MotionNotify)
+ if (event.type == EVENT_MOTIONNOTIFY)
{
+ if (!PointerInWindow(window))
+ continue; /* window and pointer are on different screens */
+
+ if (!button_status)
+ continue;
+
motion_status = TRUE;
- mx = ((XMotionEvent *) &event)->x;
- my = ((XMotionEvent *) &event)->y;
+ mx = ((MotionEvent *) &event)->x;
+ my = ((MotionEvent *) &event)->y;
}
else
{
motion_status = FALSE;
- mx = ((XButtonEvent *) &event)->x;
- my = ((XButtonEvent *) &event)->y;
- if (event.type==ButtonPress)
- button_status = ((XButtonEvent *) &event)->button;
+ mx = ((ButtonEvent *) &event)->x;
+ my = ((ButtonEvent *) &event)->y;
+ if (event.type == EVENT_BUTTONPRESS)
+ button_status = ((ButtonEvent *) &event)->button;
else
button_status = MB_RELEASED;
}
- 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);
+ /* this sets 'request_gadget_id' */
+ HandleGadgets(mx, my, button_status);
- switch(choice)
+ switch(request_gadget_id)
{
- case BUTTON_OK:
+ case TOOL_CTRL_ID_YES:
result = TRUE;
break;
- case BUTTON_NO:
+ case TOOL_CTRL_ID_NO:
result = FALSE;
break;
- case BUTTON_CONFIRM:
+ case TOOL_CTRL_ID_CONFIRM:
result = TRUE | FALSE;
break;
- case BUTTON_PLAYER_1:
+ case TOOL_CTRL_ID_PLAYER_1:
result = 1;
break;
- case BUTTON_PLAYER_2:
+ case TOOL_CTRL_ID_PLAYER_2:
result = 2;
break;
- case BUTTON_PLAYER_3:
+ case TOOL_CTRL_ID_PLAYER_3:
result = 3;
break;
- case BUTTON_PLAYER_4:
+ case TOOL_CTRL_ID_PLAYER_4:
result = 4;
break;
default:
break;
}
+
break;
}
- case KeyPress:
- switch(XLookupKeysym((XKeyEvent *)&event,
- ((XKeyEvent *)&event)->state))
+ case EVENT_KEYPRESS:
+ switch(GetEventKey((KeyEvent *)&event, TRUE))
{
- case XK_Return:
+ case KSYM_Return:
result = 1;
break;
- case XK_Escape:
+ case KSYM_Escape:
result = 0;
break;
result = 0;
break;
- case KeyRelease:
- key_joystick_mapping = 0;
+ case EVENT_KEYRELEASE:
+ ClearPlayerAction();
break;
default:
Delay(10);
}
- if (game_status != MAINMENU)
+ if (game_status != GAME_MODE_MAIN)
StopAnimation();
+ UnmapToolButtons();
+
if (!(req_state & REQ_STAY_OPEN))
{
CloseDoor(DOOR_CLOSE_1);
if (!(req_state & REQ_STAY_CLOSED) && (old_door_state & DOOR_OPEN_1))
{
- XCopyArea(display,pix[PIX_DB_DOOR],pix[PIX_DB_DOOR],gc,
- DOOR_GFX_PAGEX2,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
- DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1);
+ BlitBitmap(bitmap_db_door, bitmap_db_door,
+ DOOR_GFX_PAGEX2,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
+ DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1);
OpenDoor(DOOR_OPEN_1);
}
}
-#ifndef MSDOS
+ RemapAllGadgets();
+
+ SetDrawBackgroundMask(REDRAW_FIELD);
+
+#if defined(PLATFORM_UNIX)
/* continue network game after request */
if (options.network &&
- game_status == PLAYING &&
+ game_status == GAME_MODE_PLAYING &&
req_state & REQUEST_WAIT_FOR)
SendToServer_ContinuePlaying();
#endif
- return(result);
+ return result;
}
unsigned int OpenDoor(unsigned int door_state)
if (door_state & DOOR_COPY_BACK)
{
- XCopyArea(display, pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE + VYSIZE,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+ BlitBitmap(bitmap_db_door, bitmap_db_door,
+ DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE + VYSIZE,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
door_state &= ~DOOR_COPY_BACK;
}
{
unsigned int new_door_state;
- XCopyArea(display, backbuffer, pix[PIX_DB_DOOR], gc,
- DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
- XCopyArea(display, backbuffer, pix[PIX_DB_DOOR], gc,
- VX, VY, VXSIZE, VYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2);
+ BlitBitmap(backbuffer, bitmap_db_door,
+ DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+ BlitBitmap(backbuffer, bitmap_db_door,
+ VX, VY, VXSIZE, VYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2);
new_door_state = MoveDoor(door_state);
unsigned int GetDoorState()
{
- return(MoveDoor(DOOR_GET_STATE));
+ return MoveDoor(DOOR_GET_STATE);
+}
+
+unsigned int SetDoorState(unsigned int door_state)
+{
+ return MoveDoor(door_state | DOOR_SET_STATE);
}
unsigned int MoveDoor(unsigned int door_state)
static int door1 = DOOR_OPEN_1;
static int door2 = DOOR_CLOSE_2;
static unsigned long door_delay = 0;
- int x, start, stepsize = 2;
- unsigned long door_delay_value = stepsize * 5;
+ int x, start, stepsize = door.step_offset;
+ unsigned long door_delay_value = door.step_delay;
if (door_state == DOOR_GET_STATE)
return(door1 | door2);
+ if (door_state & DOOR_SET_STATE)
+ {
+ if (door_state & DOOR_ACTION_1)
+ door1 = door_state & DOOR_ACTION_1;
+ if (door_state & DOOR_ACTION_2)
+ door2 = door_state & DOOR_ACTION_2;
+
+ return(door1 | door2);
+ }
+
if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
door_state &= ~DOOR_OPEN_1;
else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
{
stepsize = 20;
door_delay_value = 0;
- StopSound(SND_OEFFNEN);
+
+ StopSound(SND_DOOR_OPENING);
+ StopSound(SND_DOOR_CLOSING);
+ }
+
+ if (global.autoplay_leveldir)
+ {
+ door_state |= DOOR_NO_DELAY;
+ door_state &= ~DOOR_CLOSE_ALL;
}
if (door_state & DOOR_ACTION)
{
if (!(door_state & DOOR_NO_DELAY))
- PlaySoundStereo(SND_OEFFNEN, PSND_MAX_RIGHT);
+ {
+ /* opening door sound has priority over simultaneously closing door */
+ if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
+ PlaySoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
+ else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
+ PlaySoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
+ }
start = ((door_state & DOOR_NO_DELAY) ? DXSIZE : 0);
for(x=start; x<=DXSIZE; x+=stepsize)
{
- WaitUntilDelayReached(&door_delay, door_delay_value);
+ Bitmap *bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
+ GC gc = bitmap->stored_clip_gc;
+
+ if (!(door_state & DOOR_NO_DELAY))
+ WaitUntilDelayReached(&door_delay, door_delay_value);
if (door_state & DOOR_ACTION_1)
{
int i = (door_state & DOOR_OPEN_1 ? DXSIZE-x : x);
int j = (DXSIZE - i) / 3;
- XCopyArea(display, pix[PIX_DB_DOOR], drawto, gc,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 + i/2,
- DXSIZE,DYSIZE - i/2, DX, DY);
-
- XFillRectangle(display, drawto, gc, DX, DY + DYSIZE - i/2, DXSIZE,i/2);
-
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- DX - i, (DY + j) - DOOR_GFX_PAGEY1);
- XCopyArea(display, pix[PIX_DOOR], drawto,clip_gc[PIX_DOOR],
- DXSIZE, DOOR_GFX_PAGEY1, i, 77, DX + DXSIZE - i, DY + j);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE, DOOR_GFX_PAGEY1 + 140, i, 63, DX + DXSIZE - i,
- DY + 140 + j);
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j));
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j, DX, DY);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63, DX, DY + 140 - j);
-
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63,
- DX, DY + 77 - j);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE - i, DOOR_GFX_PAGEY1 + 203, i, 77,
- DX, DY + 203 - j);
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- DX - i, (DY + j) - DOOR_GFX_PAGEY1);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63,
- DX + DXSIZE - i, DY + 77 + j);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
- DX + DXSIZE - i, DY + 203 + j);
+ BlitBitmap(bitmap_db_door, drawto,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 + i/2,
+ DXSIZE,DYSIZE - i/2, DX, DY);
+
+ ClearRectangle(drawto, DX, DY + DYSIZE - i/2, DXSIZE,i/2);
+
+ SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE, DOOR_GFX_PAGEY1, i, 77,
+ DX + DXSIZE - i, DY + j);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE, DOOR_GFX_PAGEY1 + 140, i, 63,
+ DX + DXSIZE - i, DY + 140 + j);
+ SetClipOrigin(bitmap, gc, DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j));
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j,
+ DX, DY);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63,
+ DX, DY + 140 - j);
+
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63,
+ DX, DY + 77 - j);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE - i, DOOR_GFX_PAGEY1 + 203, i, 77,
+ DX, DY + 203 - j);
+ SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63,
+ DX + DXSIZE - i, DY + 77 + j);
+ BlitBitmapMasked(bitmap, drawto,
+ DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
+ DX + DXSIZE - i, DY + 203 + j);
redraw_mask |= REDRAW_DOOR_1;
}
int i = (door_state & DOOR_OPEN_2 ? VXSIZE - x : x);
int j = (VXSIZE - i) / 3;
- XCopyArea(display, pix[PIX_DB_DOOR], drawto, gc,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 + i/2,
- VXSIZE, VYSIZE - i/2, VX, VY);
-
- XFillRectangle(display, drawto, gc, VX, VY + VYSIZE-i/2, VXSIZE, i/2);
-
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- VX - i, (VY + j) - DOOR_GFX_PAGEY2);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2, VX + VXSIZE-i, VY+j);
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j));
- XCopyArea(display, pix[PIX_DOOR], drawto,clip_gc[PIX_DOOR],
- VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j, VX, VY);
-
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- VXSIZE - i, DOOR_GFX_PAGEY2 + VYSIZE / 2, i, VYSIZE / 2,
- VX, VY + VYSIZE / 2 - j);
- XSetClipOrigin(display, clip_gc[PIX_DOOR],
- VX - i, (VY + j) - DOOR_GFX_PAGEY2);
- XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR],
- VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2, i, VYSIZE / 2 - j,
- VX + VXSIZE - i, VY + VYSIZE / 2 + j);
+ BlitBitmap(bitmap_db_door, drawto,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 + i/2,
+ VXSIZE, VYSIZE - i/2, VX, VY);
+
+ ClearRectangle(drawto, VX, VY + VYSIZE-i/2, VXSIZE, i/2);
+
+ SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
+ BlitBitmapMasked(bitmap, drawto,
+ VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2,
+ VX + VXSIZE-i, VY+j);
+ SetClipOrigin(bitmap, gc,
+ VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j));
+ BlitBitmapMasked(bitmap, drawto,
+ VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j,
+ VX, VY);
+
+ BlitBitmapMasked(bitmap, drawto,
+ VXSIZE - i, DOOR_GFX_PAGEY2 + VYSIZE / 2,
+ i, VYSIZE / 2, VX, VY + VYSIZE / 2 - j);
+ SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
+ BlitBitmapMasked(bitmap, drawto,
+ VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2,
+ i, VYSIZE / 2 - j,
+ VX + VXSIZE - i, VY + VYSIZE / 2 + j);
redraw_mask |= REDRAW_DOOR_2;
}
BackToFront();
- if (game_status == MAINMENU)
+ if (game_status == GAME_MODE_MAIN)
DoAnimation();
}
}
if (setup.quick_doors)
- StopSound(SND_OEFFNEN);
+ {
+ StopSound(SND_DOOR_OPENING);
+ StopSound(SND_DOOR_CLOSING);
+ }
if (door_state & DOOR_ACTION_1)
door1 = door_state & DOOR_ACTION_1;
if (door_state & DOOR_ACTION_2)
door2 = door_state & DOOR_ACTION_2;
- return(door1 | door2);
+ return (door1 | door2);
}
-int ReadPixel(Drawable d, int x, int y)
+void DrawSpecialEditorDoor()
{
- XImage *pixel_image;
- unsigned long pixel_value;
-
- pixel_image = XGetImage(display, d, x, y, 1, 1, AllPlanes, ZPixmap);
- pixel_value = XGetPixel(pixel_image, 0, 0);
+ /* draw bigger toolbox window */
+ BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
+ DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
+ EX - 4, EY - 12);
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ EX - 4, VY - 4, EXSIZE + 8, EYSIZE - VYSIZE + 4,
+ EX - 4, EY - 4);
+
+ redraw_mask |= REDRAW_ALL;
+}
- XDestroyImage(pixel_image);
+void UndrawSpecialEditorDoor()
+{
+ /* draw normal tape recorder window */
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ EX - 4, EY - 12, EXSIZE + 8, EYSIZE - VYSIZE + 12,
+ EX - 4, EY - 12);
- return pixel_value;
+ redraw_mask |= REDRAW_ALL;
}
-int el2gfx(int element)
+
+/* ---------- new tool button stuff ---------------------------------------- */
+
+/* graphic position values for tool buttons */
+#define TOOL_BUTTON_YES_XPOS 2
+#define TOOL_BUTTON_YES_YPOS 250
+#define TOOL_BUTTON_YES_GFX_YPOS 0
+#define TOOL_BUTTON_YES_XSIZE 46
+#define TOOL_BUTTON_YES_YSIZE 28
+#define TOOL_BUTTON_NO_XPOS 52
+#define TOOL_BUTTON_NO_YPOS TOOL_BUTTON_YES_YPOS
+#define TOOL_BUTTON_NO_GFX_YPOS TOOL_BUTTON_YES_GFX_YPOS
+#define TOOL_BUTTON_NO_XSIZE TOOL_BUTTON_YES_XSIZE
+#define TOOL_BUTTON_NO_YSIZE TOOL_BUTTON_YES_YSIZE
+#define TOOL_BUTTON_CONFIRM_XPOS TOOL_BUTTON_YES_XPOS
+#define TOOL_BUTTON_CONFIRM_YPOS TOOL_BUTTON_YES_YPOS
+#define TOOL_BUTTON_CONFIRM_GFX_YPOS 30
+#define TOOL_BUTTON_CONFIRM_XSIZE 96
+#define TOOL_BUTTON_CONFIRM_YSIZE TOOL_BUTTON_YES_YSIZE
+#define TOOL_BUTTON_PLAYER_XSIZE 30
+#define TOOL_BUTTON_PLAYER_YSIZE 30
+#define TOOL_BUTTON_PLAYER_GFX_XPOS 5
+#define TOOL_BUTTON_PLAYER_GFX_YPOS 185
+#define TOOL_BUTTON_PLAYER_XPOS (5 + TOOL_BUTTON_PLAYER_XSIZE / 2)
+#define TOOL_BUTTON_PLAYER_YPOS (215 - TOOL_BUTTON_PLAYER_YSIZE / 2)
+#define TOOL_BUTTON_PLAYER1_XPOS (TOOL_BUTTON_PLAYER_XPOS \
+ + 0 * TOOL_BUTTON_PLAYER_XSIZE)
+#define TOOL_BUTTON_PLAYER2_XPOS (TOOL_BUTTON_PLAYER_XPOS \
+ + 1 * TOOL_BUTTON_PLAYER_XSIZE)
+#define TOOL_BUTTON_PLAYER3_XPOS (TOOL_BUTTON_PLAYER_XPOS \
+ + 0 * TOOL_BUTTON_PLAYER_XSIZE)
+#define TOOL_BUTTON_PLAYER4_XPOS (TOOL_BUTTON_PLAYER_XPOS \
+ + 1 * TOOL_BUTTON_PLAYER_XSIZE)
+#define TOOL_BUTTON_PLAYER1_YPOS (TOOL_BUTTON_PLAYER_YPOS \
+ + 0 * TOOL_BUTTON_PLAYER_YSIZE)
+#define TOOL_BUTTON_PLAYER2_YPOS (TOOL_BUTTON_PLAYER_YPOS \
+ + 0 * TOOL_BUTTON_PLAYER_YSIZE)
+#define TOOL_BUTTON_PLAYER3_YPOS (TOOL_BUTTON_PLAYER_YPOS \
+ + 1 * TOOL_BUTTON_PLAYER_YSIZE)
+#define TOOL_BUTTON_PLAYER4_YPOS (TOOL_BUTTON_PLAYER_YPOS \
+ + 1 * TOOL_BUTTON_PLAYER_YSIZE)
+
+static struct
{
- switch(element)
+ int xpos, ypos;
+ int x, y;
+ int width, height;
+ int gadget_id;
+ char *infotext;
+} toolbutton_info[NUM_TOOL_BUTTONS] =
+{
+ {
+ TOOL_BUTTON_YES_XPOS, TOOL_BUTTON_YES_GFX_YPOS,
+ TOOL_BUTTON_YES_XPOS, TOOL_BUTTON_YES_YPOS,
+ TOOL_BUTTON_YES_XSIZE, TOOL_BUTTON_YES_YSIZE,
+ TOOL_CTRL_ID_YES,
+ "yes"
+ },
+ {
+ TOOL_BUTTON_NO_XPOS, TOOL_BUTTON_NO_GFX_YPOS,
+ TOOL_BUTTON_NO_XPOS, TOOL_BUTTON_NO_YPOS,
+ TOOL_BUTTON_NO_XSIZE, TOOL_BUTTON_NO_YSIZE,
+ TOOL_CTRL_ID_NO,
+ "no"
+ },
+ {
+ TOOL_BUTTON_CONFIRM_XPOS, TOOL_BUTTON_CONFIRM_GFX_YPOS,
+ TOOL_BUTTON_CONFIRM_XPOS, TOOL_BUTTON_CONFIRM_YPOS,
+ TOOL_BUTTON_CONFIRM_XSIZE, TOOL_BUTTON_CONFIRM_YSIZE,
+ TOOL_CTRL_ID_CONFIRM,
+ "confirm"
+ },
+ {
+ TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
+ TOOL_BUTTON_PLAYER1_XPOS, TOOL_BUTTON_PLAYER1_YPOS,
+ TOOL_BUTTON_PLAYER_XSIZE, TOOL_BUTTON_PLAYER_YSIZE,
+ TOOL_CTRL_ID_PLAYER_1,
+ "player 1"
+ },
+ {
+ TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
+ TOOL_BUTTON_PLAYER2_XPOS, TOOL_BUTTON_PLAYER2_YPOS,
+ TOOL_BUTTON_PLAYER_XSIZE, TOOL_BUTTON_PLAYER_YSIZE,
+ TOOL_CTRL_ID_PLAYER_2,
+ "player 2"
+ },
+ {
+ TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
+ TOOL_BUTTON_PLAYER3_XPOS, TOOL_BUTTON_PLAYER3_YPOS,
+ TOOL_BUTTON_PLAYER_XSIZE, TOOL_BUTTON_PLAYER_YSIZE,
+ TOOL_CTRL_ID_PLAYER_3,
+ "player 3"
+ },
+ {
+ TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
+ TOOL_BUTTON_PLAYER4_XPOS, TOOL_BUTTON_PLAYER4_YPOS,
+ TOOL_BUTTON_PLAYER_XSIZE, TOOL_BUTTON_PLAYER_YSIZE,
+ TOOL_CTRL_ID_PLAYER_4,
+ "player 4"
+ }
+};
+
+void CreateToolButtons()
+{
+ int i;
+
+ for (i=0; i<NUM_TOOL_BUTTONS; i++)
{
- case EL_LEERRAUM: return -1;
- case EL_ERDREICH: return GFX_ERDREICH;
- case EL_MAUERWERK: return GFX_MAUERWERK;
- case EL_FELSBODEN: return GFX_FELSBODEN;
- case EL_FELSBROCKEN: return GFX_FELSBROCKEN;
- case EL_SCHLUESSEL: return GFX_SCHLUESSEL;
- case EL_EDELSTEIN: return GFX_EDELSTEIN;
- case EL_AUSGANG_ZU: return GFX_AUSGANG_ZU;
- case EL_AUSGANG_ACT: return GFX_AUSGANG_ACT;
- case EL_AUSGANG_AUF: return GFX_AUSGANG_AUF;
- case EL_SPIELFIGUR: return GFX_SPIELFIGUR;
- case EL_SPIELER1: return GFX_SPIELER1;
- case EL_SPIELER2: return GFX_SPIELER2;
- case EL_SPIELER3: return GFX_SPIELER3;
- case EL_SPIELER4: return GFX_SPIELER4;
- case EL_KAEFER: return GFX_KAEFER;
- case EL_KAEFER_R: return GFX_KAEFER_R;
- case EL_KAEFER_O: return GFX_KAEFER_O;
- case EL_KAEFER_L: return GFX_KAEFER_L;
- case EL_KAEFER_U: return GFX_KAEFER_U;
- case EL_FLIEGER: return GFX_FLIEGER;
- case EL_FLIEGER_R: return GFX_FLIEGER_R;
- case EL_FLIEGER_O: return GFX_FLIEGER_O;
- case EL_FLIEGER_L: return GFX_FLIEGER_L;
- case EL_FLIEGER_U: return GFX_FLIEGER_U;
- case EL_BUTTERFLY: return GFX_BUTTERFLY;
- case EL_BUTTERFLY_R: return GFX_BUTTERFLY_R;
- case EL_BUTTERFLY_O: return GFX_BUTTERFLY_O;
- case EL_BUTTERFLY_L: return GFX_BUTTERFLY_L;
- case EL_BUTTERFLY_U: return GFX_BUTTERFLY_U;
- case EL_FIREFLY: return GFX_FIREFLY;
- case EL_FIREFLY_R: return GFX_FIREFLY_R;
- case EL_FIREFLY_O: return GFX_FIREFLY_O;
- case EL_FIREFLY_L: return GFX_FIREFLY_L;
- case EL_FIREFLY_U: return GFX_FIREFLY_U;
- case EL_MAMPFER: return GFX_MAMPFER;
- case EL_ROBOT: return GFX_ROBOT;
- case EL_BETON: return GFX_BETON;
- case EL_DIAMANT: return GFX_DIAMANT;
- case EL_MORAST_LEER: return GFX_MORAST_LEER;
- case EL_MORAST_VOLL: return GFX_MORAST_VOLL;
- case EL_TROPFEN: return GFX_TROPFEN;
- case EL_BOMBE: return GFX_BOMBE;
- case EL_SIEB_INAKTIV: return GFX_SIEB_INAKTIV;
- case EL_SIEB_LEER: return GFX_SIEB_LEER;
- case EL_SIEB_VOLL: return GFX_SIEB_VOLL;
- case EL_SIEB_TOT: return GFX_SIEB_TOT;
- case EL_SALZSAEURE: return GFX_SALZSAEURE;
- case EL_AMOEBE_TOT: return GFX_AMOEBE_TOT;
- case EL_AMOEBE_NASS: return GFX_AMOEBE_NASS;
- case EL_AMOEBE_NORM: return GFX_AMOEBE_NORM;
- case EL_AMOEBE_VOLL: return GFX_AMOEBE_VOLL;
- case EL_AMOEBE_BD: return GFX_AMOEBE_BD;
- case EL_AMOEBA2DIAM: return GFX_AMOEBA2DIAM;
- 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_BADEWANNE: return GFX_BADEWANNE;
- case EL_BADEWANNE1: return GFX_BADEWANNE1;
- case EL_BADEWANNE2: return GFX_BADEWANNE2;
- case EL_BADEWANNE3: return GFX_BADEWANNE3;
- case EL_BADEWANNE4: return GFX_BADEWANNE4;
- case EL_BADEWANNE5: return GFX_BADEWANNE5;
- case EL_ABLENK_AUS: return GFX_ABLENK_AUS;
- case EL_ABLENK_EIN: return GFX_ABLENK_EIN;
- case EL_SCHLUESSEL1: return GFX_SCHLUESSEL1;
- case EL_SCHLUESSEL2: return GFX_SCHLUESSEL2;
- case EL_SCHLUESSEL3: return GFX_SCHLUESSEL3;
- case EL_SCHLUESSEL4: return GFX_SCHLUESSEL4;
- case EL_PFORTE1: return GFX_PFORTE1;
- case EL_PFORTE2: return GFX_PFORTE2;
- case EL_PFORTE3: return GFX_PFORTE3;
- case EL_PFORTE4: return GFX_PFORTE4;
- case EL_PFORTE1X: return GFX_PFORTE1X;
- 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_PACMAN: return GFX_PACMAN;
- case EL_PACMAN_R: return GFX_PACMAN_R;
- case EL_PACMAN_O: return GFX_PACMAN_O;
- case EL_PACMAN_L: return GFX_PACMAN_L;
- case EL_PACMAN_U: return GFX_PACMAN_U;
- case EL_UNSICHTBAR: return GFX_UNSICHTBAR;
- case EL_ERZ_EDEL: return GFX_ERZ_EDEL;
- case EL_ERZ_DIAM: return GFX_ERZ_DIAM;
- case EL_BIRNE_AUS: return GFX_BIRNE_AUS;
- case EL_BIRNE_EIN: return GFX_BIRNE_EIN;
- case EL_ZEIT_VOLL: return GFX_ZEIT_VOLL;
- case EL_ZEIT_LEER: return GFX_ZEIT_LEER;
- case EL_MAUER_LEBT: return GFX_MAUER_LEBT;
- case EL_MAUER_X: return GFX_MAUER_X;
- case EL_MAUER_Y: return GFX_MAUER_Y;
- case EL_MAUER_XY: return GFX_MAUER_XY;
- case EL_EDELSTEIN_BD: return GFX_EDELSTEIN_BD;
- case EL_EDELSTEIN_GELB: return GFX_EDELSTEIN_GELB;
- case EL_EDELSTEIN_ROT: return GFX_EDELSTEIN_ROT;
- case EL_EDELSTEIN_LILA: return GFX_EDELSTEIN_LILA;
- case EL_ERZ_EDEL_BD: return GFX_ERZ_EDEL_BD;
- case EL_ERZ_EDEL_GELB: return GFX_ERZ_EDEL_GELB;
- case EL_ERZ_EDEL_ROT: return GFX_ERZ_EDEL_ROT;
- case EL_ERZ_EDEL_LILA: return GFX_ERZ_EDEL_LILA;
- case EL_MAMPFER2: return GFX_MAMPFER2;
- case EL_SIEB2_INAKTIV: return GFX_SIEB2_INAKTIV;
- 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_NR: return GFX_DYNABOMB_NR;
- case EL_DYNABOMB_SZ: return GFX_DYNABOMB_SZ;
- case EL_DYNABOMB_XL: return GFX_DYNABOMB_XL;
- case EL_SOKOBAN_OBJEKT: return GFX_SOKOBAN_OBJEKT;
- case EL_SOKOBAN_FELD_LEER: return GFX_SOKOBAN_FELD_LEER;
- case EL_SOKOBAN_FELD_VOLL: return GFX_SOKOBAN_FELD_VOLL;
- case EL_MAULWURF: return GFX_MAULWURF;
- case EL_PINGUIN: return GFX_PINGUIN;
- case EL_SCHWEIN: return GFX_SCHWEIN;
- case EL_DRACHE: return GFX_DRACHE;
- case EL_SONDE: return GFX_SONDE;
- case EL_PFEIL_L: return GFX_PFEIL_L;
- case EL_PFEIL_R: return GFX_PFEIL_R;
- case EL_PFEIL_O: return GFX_PFEIL_O;
- case EL_PFEIL_U: return GFX_PFEIL_U;
- default:
+ Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
+ Bitmap *deco_bitmap = 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;
+ int gd_x1, gd_x2, gd_y;
+ int id = i;
+
+ event_mask = GD_EVENT_RELEASED;
+
+ gd_xoffset = toolbutton_info[i].xpos;
+ gd_yoffset = toolbutton_info[i].ypos;
+ gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
+ gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
+ gd_y = DOOR_GFX_PAGEY1 + gd_yoffset;
+
+ if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
{
- if (IS_CHAR(element))
- return GFX_CHAR_START + (element - EL_CHAR_START);
- else if (element >= EL_SP_START && element <= EL_SP_END)
- return GFX_START_ROCKSMORE + (element - EL_SP_START);
- else
- return -1;
+ int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
+
+ getMiniGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr),
+ &deco_bitmap, &deco_x, &deco_y);
+ deco_xpos = (toolbutton_info[i].width - MINI_TILEX) / 2;
+ deco_ypos = (toolbutton_info[i].height - MINI_TILEY) / 2;
}
+
+ gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_INFO_TEXT, toolbutton_info[i].infotext,
+ GDI_X, DX + toolbutton_info[i].x,
+ GDI_Y, DY + toolbutton_info[i].y,
+ GDI_WIDTH, toolbutton_info[i].width,
+ GDI_HEIGHT, toolbutton_info[i].height,
+ GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
+ GDI_STATE, GD_BUTTON_UNPRESSED,
+ GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
+ GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
+ GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
+ GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
+ GDI_DECORATION_SIZE, MINI_TILEX, MINI_TILEY,
+ GDI_DECORATION_SHIFTING, 1, 1,
+ GDI_EVENT_MASK, event_mask,
+ GDI_CALLBACK_ACTION, HandleToolButtons,
+ GDI_END);
+
+ if (gi == NULL)
+ Error(ERR_EXIT, "cannot create gadget");
+
+ tool_gadget[id] = gi;
+ }
+}
+
+void FreeToolButtons()
+{
+ int i;
+
+ for (i=0; i<NUM_TOOL_BUTTONS; i++)
+ FreeGadget(tool_gadget[i]);
+}
+
+static void UnmapToolButtons()
+{
+ int i;
+
+ for (i=0; i<NUM_TOOL_BUTTONS; i++)
+ UnmapGadget(tool_gadget[i]);
+}
+
+static void HandleToolButtons(struct GadgetInfo *gi)
+{
+ request_gadget_id = gi->custom_id;
+}
+
+int get_next_element(int element)
+{
+ switch(element)
+ {
+ case EL_QUICKSAND_FILLING: return EL_QUICKSAND_FULL;
+ case EL_QUICKSAND_EMPTYING: return EL_QUICKSAND_EMPTY;
+ case EL_MAGIC_WALL_FILLING: return EL_MAGIC_WALL_FULL;
+ case EL_MAGIC_WALL_EMPTYING: return EL_MAGIC_WALL_ACTIVE;
+ case EL_BD_MAGIC_WALL_FILLING: return EL_BD_MAGIC_WALL_FULL;
+ case EL_BD_MAGIC_WALL_EMPTYING: return EL_BD_MAGIC_WALL_ACTIVE;
+ case EL_AMOEBA_DROPPING: return EL_AMOEBA_WET;
+
+ default: return element;
}
}
+
+int el_act_dir2img(int element, int action, int direction)
+{
+ element = GFX_ELEMENT(element);
+ direction = MV_DIR_BIT(direction);
+
+ return element_info[element].direction_graphic[action][direction];
+}
+
+static int el_act_dir2crm(int element, int action, int direction)
+{
+ element = GFX_ELEMENT(element);
+ direction = MV_DIR_BIT(direction);
+
+ return element_info[element].direction_crumbled[action][direction];
+}
+
+int el_act2img(int element, int action)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].graphic[action];
+}
+
+int el_dir2img(int element, int direction)
+{
+ element = GFX_ELEMENT(element);
+
+ return el_act_dir2img(element, ACTION_DEFAULT, direction);
+}
+
+int el2img(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].graphic[ACTION_DEFAULT];
+}
+
+int el2edimg(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
+}
+
+int el2preimg(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
+}
projects / rocksndiamonds.git / blobdiff