* q99492@pbhrzx.uni-paderborn.de *
*----------------------------------------------------------*
* tools.c *
-* *
-* Letzte Aenderung: 15.06.1995 *
***********************************************************/
+#ifdef __FreeBSD__
+#include <machine/joystick.h>
+#endif
+
#include "tools.h"
#include "game.h"
#include "events.h"
#include "sound.h"
-#include "screens.h"
#include "misc.h"
+#include "buttons.h"
+#include "joystick.h"
+#include "cartoons.h"
+
+#include <math.h>
+
+#ifdef MSDOS
+extern BOOL wait_for_vsync;
+#endif
+
+void SetDrawtoField(int mode)
+{
+ if (mode == DRAW_BUFFERED && soft_scrolling_on)
+ {
+ FX = TILEX;
+ FY = TILEY;
+ BX1 = -1;
+ BY1 = -1;
+ BX2 = SCR_FIELDX;
+ BY2 = SCR_FIELDY;
+ redraw_x1 = 1;
+ redraw_y1 = 1;
+
+ drawto_field = fieldbuffer;
+ }
+ else /* DRAW_DIRECT, DRAW_BACKBUFFER */
+ {
+ FX = SX;
+ FY = SY;
+ BX1 = 0;
+ BY1 = 0;
+ BX2 = SCR_FIELDX - 1;
+ BY2 = SCR_FIELDY - 1;
+ redraw_x1 = 0;
+ redraw_y1 = 0;
+
+ drawto_field = (mode == DRAW_DIRECT ? window : backbuffer);
+ }
+}
void BackToFront()
{
int x,y;
+ Drawable buffer = (drawto_field != window ? drawto_field : backbuffer);
- if (direct_draw_on && game_status==PLAYING)
+ if (direct_draw_on && game_status == PLAYING)
redraw_mask &= ~REDRAW_MAIN;
+ if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
+ redraw_mask |= REDRAW_FIELD;
+
+ if (redraw_mask & REDRAW_FIELD || ScreenMovPos)
+ redraw_mask &= ~REDRAW_TILES;
+
if (!redraw_mask)
return;
- if (redraw_mask & REDRAW_ALL ||
- (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS))
+ /* 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
+
+ if (redraw_mask & REDRAW_ALL)
{
XCopyArea(display,backbuffer,window,gc,
0,0, WIN_XSIZE,WIN_YSIZE,
0,0);
redraw_mask = 0;
}
- else if (redraw_mask & REDRAW_FIELD)
+
+ if (redraw_mask & REDRAW_FIELD)
{
- XCopyArea(display,backbuffer,window,gc,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
+ 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);
+ else
+ {
+ int fx = FX, fy = FY;
+
+ if (soft_scrolling_on)
+ {
+ fx += (PlayerMovDir & (MV_LEFT|MV_RIGHT) ? ScreenMovPos : 0);
+ fy += (PlayerMovDir & (MV_UP|MV_DOWN) ? ScreenMovPos : 0);
+ }
+
+ XCopyArea(display,buffer,window,gc,
+ fx,fy, SXSIZE,SYSIZE,
+ SX,SY);
+ }
redraw_mask &= ~REDRAW_MAIN;
}
- else if (redraw_mask & REDRAW_DOORS)
+
+ if (redraw_mask & REDRAW_DOORS)
{
if (redraw_mask & REDRAW_DOOR_1)
XCopyArea(display,backbuffer,window,gc,
- DX,DY, DXSIZE,DYSIZE, DX,DY);
+ 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);
+ VX,VY, VXSIZE,VYSIZE,
+ VX,VY);
else
{
if (redraw_mask & REDRAW_VIDEO_1)
if (redraw_mask & REDRAW_TILES)
{
- if (redraw_tiles>REDRAWTILES_TH)
- XCopyArea(display,backbuffer,window,gc,SX,SY,SXSIZE,SYSIZE,SX,SY);
- else
- for(x=0;x<SCR_FIELDX;x++)
- for(y=0;y<SCR_FIELDY;y++)
- if (redraw[x][y])
- XCopyArea(display,backbuffer,window,gc,
- SX+x*TILEX,SY+y*TILEY,TILEX,TILEY,SX+x*TILEX,SY+y*TILEY);
+ 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);
}
XFlush(display);
- for(x=0;x<SCR_FIELDX;x++)
- for(y=0;y<SCR_FIELDY;y++)
- redraw[x][y]=0;
- redraw_tiles=0;
- redraw_mask=0;
+ 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;
}
void FadeToFront()
{
- long fading_delay = 300000;
+/*
+ long fading_delay = 300;
if (fading_on && (redraw_mask & REDRAW_FIELD))
{
+*/
+
+/*
+ int x,y;
+
+ XFillRectangle(display,window,gc,
+ REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
+ XFlush(display);
+
+ 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);
+ }
+ XFlush(display);
+ Delay(10);
+ }
+*/
+
+/*
+ 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);
+ Delay(fading_delay);
+*/
+
+/*
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);
redraw_mask &= ~REDRAW_MAIN;
}
+*/
BackToFront();
}
void ClearWindow()
{
- drawto_field = backbuffer;
- XFillRectangle(display,drawto_field,gc,
- REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
- redraw_mask|=REDRAW_FIELD;
+ XFillRectangle(display,backbuffer,gc,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE);
- if (game_status==PLAYING && direct_draw_on)
+ if (soft_scrolling_on && game_status==PLAYING)
{
- drawto_field = window;
- XFillRectangle(display,drawto_field,gc,
- REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
+ XFillRectangle(display,fieldbuffer,gc,
+ 0,0, FXSIZE,FYSIZE);
+ SetDrawtoField(DRAW_BUFFERED);
}
+ else
+ SetDrawtoField(DRAW_BACKBUFFER);
+
+ if (direct_draw_on && game_status==PLAYING)
+ {
+ XFillRectangle(display,window,gc,
+ REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE);
+ SetDrawtoField(DRAW_DIRECT);
+ }
+
+ redraw_mask |= REDRAW_FIELD;
}
void DrawText(int x, int y, char *text, int font, int col)
{
DrawTextExt(drawto, gc, x, y, text, font, col);
- if (x<DX)
- redraw_mask|=REDRAW_FIELD;
- else if (y<VY)
- redraw_mask|=REDRAW_DOOR_1;
+ if (x < DX)
+ redraw_mask |= REDRAW_FIELD;
+ else if (y < VY)
+ redraw_mask |= REDRAW_DOOR_1;
}
void DrawTextExt(Drawable d, GC gc, int x, int y,
}
}
-void DrawGraphic(int x, int y, int graphic)
+void DrawPlayerField()
+{
+ int x = JX, y = JY;
+ int sx = SCROLLX(x), sy = SCROLLY(y);
+
+ int sxx = 0, syy = 0;
+
+ int element = Feld[x][y];
+ int graphic, phase;
+
+ if (PlayerGone)
+ return;
+
+#if DEBUG
+ if (!IN_LEV_FIELD(x,y) || !IN_SCR_FIELD(sx,sy))
+ {
+ printf("DrawPlayerField(): x = %d, y = %d\n",x,y);
+ printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
+ printf("DrawPlayerField(): This should never happen!\n");
+ return;
+ }
+#endif
+
+ if (element == EL_EXPLODING)
+ return;
+
+ if (direct_draw_on)
+ SetDrawtoField(DRAW_BUFFERED);
+
+ /* draw things in the field the player is leaving, if needed */
+
+ if (lastJX != JX || lastJY != JY)
+ {
+ if (Store[lastJX][lastJY])
+ {
+ DrawLevelElement(lastJX,lastJY, Store[lastJX][lastJY]);
+ DrawLevelElementThruMask(lastJX,lastJY, Feld[lastJX][lastJY]);
+ }
+ else if (Feld[lastJX][lastJY] == EL_DYNAMIT)
+ DrawDynamite(lastJX,lastJY);
+ else
+ DrawLevelField(lastJX,lastJY);
+
+ if (PlayerPushing)
+ {
+ int nextJX = JX + (JX - lastJX);
+ int nextJY = JY + (JY - lastJY);
+
+ if (PlayerGfxPos)
+ {
+ if (Feld[nextJX][nextJY] == EL_SOKOBAN_FELD_VOLL)
+ DrawLevelElement(nextJX,nextJY, EL_SOKOBAN_FELD_LEER);
+ else
+ DrawLevelElement(nextJX,nextJY, EL_LEERRAUM);
+ }
+ else
+ DrawLevelField(nextJX,nextJY);
+ }
+ }
+
+ /* draw things behind the player, if needed */
+
+ if (Store[x][y])
+ DrawLevelElement(x,y, Store[x][y]);
+ else if (element != EL_DYNAMIT && element != EL_DYNABOMB)
+ DrawLevelField(x,y);
+
+ /* draw player himself */
+
+ if (PlayerMovDir==MV_LEFT)
+ graphic = (PlayerPushing ? GFX_SPIELER_PUSH_LEFT : GFX_SPIELER_LEFT);
+ else if (PlayerMovDir==MV_RIGHT)
+ graphic = (PlayerPushing ? GFX_SPIELER_PUSH_RIGHT : GFX_SPIELER_RIGHT);
+ else if (PlayerMovDir==MV_UP)
+ graphic = GFX_SPIELER_UP;
+ else /* MV_DOWN || MV_NO_MOVING */
+ graphic = GFX_SPIELER_DOWN;
+
+ graphic += PlayerFrame;
+
+ if (PlayerGfxPos)
+ {
+ if (PlayerMovDir == MV_LEFT || PlayerMovDir == MV_RIGHT)
+ sxx = PlayerGfxPos;
+ else
+ syy = PlayerGfxPos;
+ }
+
+ if (!soft_scrolling_on && ScreenMovPos)
+ sxx = syy = 0;
+
+ DrawGraphicShiftedThruMask(sx,sy, sxx,syy, graphic, NO_CUTTING);
+
+ if (PlayerPushing && PlayerGfxPos)
+ {
+ int nextJX = JX + (JX - lastJX);
+ int nextJY = JY + (JY - lastJY);
+ int px = SCROLLX(nextJX), py = SCROLLY(nextJY);
+
+ if (Feld[JX][JY] == EL_SOKOBAN_FELD_LEER ||
+ Feld[nextJX][nextJY] == EL_SOKOBAN_FELD_VOLL)
+ DrawGraphicShiftedThruMask(px,py,sxx,syy, GFX_SOKOBAN_OBJEKT,NO_CUTTING);
+ else
+ {
+ int element = Feld[nextJX][nextJY];
+ int graphic = el2gfx(element);
+
+ if (element == EL_FELSBROCKEN && sxx)
+ {
+ int phase = (PlayerGfxPos / (TILEX/4));
+
+ if (PlayerMovDir == MV_LEFT)
+ graphic += phase;
+ else
+ graphic += (phase+4)%4;
+ }
+
+ DrawGraphicShifted(px,py, sxx,syy, graphic, NO_CUTTING, NO_MASKING);
+ }
+ }
+
+ /* draw things in front of player (EL_DYNAMIT || EL_DYNABOMB) */
+
+ if (element == EL_DYNAMIT || element == EL_DYNABOMB)
+ {
+ graphic = el2gfx(element);
+
+ if (element == EL_DYNAMIT)
+ {
+ if ((phase = (96-MovDelay[x][y])/12) > 6)
+ phase = 6;
+ }
+ else
+ {
+ if ((phase = ((96-MovDelay[x][y])/6) % 8) > 3)
+ phase = 7-phase;
+ }
+
+ DrawGraphicThruMask(sx,sy, graphic + phase);
+ }
+
+ if (direct_draw_on)
+ {
+ int dest_x = SX+SCROLLX(x)*TILEX;
+ int dest_y = SY+SCROLLY(y)*TILEY;
+ int x_size = TILEX;
+ int y_size = TILEY;
+
+ if (!ScreenMovPos)
+ {
+ dest_x = SX + SCROLLX(MIN(JX,lastJX))*TILEX;
+ dest_y = SY + SCROLLY(MIN(JY,lastJY))*TILEY;
+ x_size = TILEX * (1 + ABS(JX - lastJX));
+ y_size = TILEY * (1 + ABS(JY - lastJY));
+ }
+
+ XCopyArea(display,drawto_field,window,gc,
+ 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)
{
- DrawGraphicExt(drawto_field, gc, x, y, graphic);
- redraw_tiles++;
- redraw[x][y] = TRUE;
- redraw_mask |= REDRAW_TILES;
+ int phase;
+
+ if (mode == ANIM_OSCILLATE)
+ {
+ int max_anim_frames = frames*2 - 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;
+
+ return(phase);
}
-void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+void DrawGraphicAnimationExt(int x, int y, int graphic,
+ int frames, int delay, int mode, int mask_mode)
{
- DrawGraphicExtHiRes(d, gc, SX+x*TILEX, SY+y*TILEY, graphic);
+ int phase = getGraphicAnimationPhase(frames, delay, mode);
+
+ if (!(FrameCounter % delay) && IN_SCR_FIELD(SCROLLX(x),SCROLLY(y)))
+ {
+ if (mask_mode == USE_MASKING)
+ DrawGraphicThruMask(SCROLLX(x),SCROLLY(y), graphic + phase);
+ else
+ DrawGraphic(SCROLLX(x),SCROLLY(y), graphic + phase);
+ }
}
-void DrawGraphicExtHiRes(Drawable d, GC gc, int x, int y, int graphic)
+void DrawGraphicAnimation(int x, int y, int graphic,
+ int frames, int delay, int mode)
{
- if (graphic<0)
- XFillRectangle(display,d,gc, x,y, TILEX,TILEY);
- else if (graphic<256)
+ 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)
+{
+
+#if DEBUG
+ if (!IN_SCR_FIELD(x,y))
+ {
+ printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+ printf("DrawGraphic(): This should never happen!\n");
+ return;
+ }
+#endif
+
+ DrawGraphicExt(drawto_field, gc, FX+x*TILEX, FY+y*TILEY, graphic);
+ MarkTileDirty(x,y);
+}
+
+void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic)
+{
+ 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,
+ SX + (graphic % GFX_PER_LINE) * TILEX,
+ SY + (graphic / GFX_PER_LINE) * TILEY,
TILEX,TILEY, x,y);
- else
+ }
+ else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
{
- graphic -= 256;
+ 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*TILEY*FONT_LINES_PER_FONT,
+ (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);
}
void DrawGraphicThruMask(int x, int y, int graphic)
{
int src_x,src_y, dest_x,dest_y;
+ int tile = graphic;
+ Pixmap src_pixmap;
+ GC drawing_gc;
+
+#if DEBUG
+ if (!IN_SCR_FIELD(x,y))
+ {
+ printf("DrawGraphicThruMask(): x = %d, y = %d\n",x,y);
+ printf("DrawGraphicThruMask(): This should never happen!\n");
+ return;
+ }
+#endif
- if (graphic<0 || graphic>255)
+ 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_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
{
DrawGraphic(x,y,graphic);
return;
}
- src_x = SX+(graphic % GFX_PER_LINE)*TILEX;
- src_y = SY+(graphic / GFX_PER_LINE)*TILEY;
- dest_x = SX+x*TILEX;
- dest_y = SY+y*TILEY;
+ dest_x = FX + x*TILEX;
+ dest_y = FY + y*TILEY;
- XSetClipOrigin(display,clip_gc[PIX_BACK],dest_x-src_x,dest_y-src_y);
- XCopyArea(display,pix[PIX_BACK],drawto_field,clip_gc[PIX_BACK], src_x,src_y,
- TILEX,TILEY, dest_x,dest_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
- redraw_tiles++;
- redraw[x][y]=TRUE;
- redraw_mask|=REDRAW_TILES;
-}
+ 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);
+ }
-void DrawElementThruMask(int x, int y, int element)
-{
- DrawGraphicThruMask(x,y,el2gfx(element));
+ MarkTileDirty(x,y);
}
void DrawMiniGraphic(int x, int y, int graphic)
{
- DrawMiniGraphicExt(drawto, gc, x, y, graphic);
- redraw_tiles++;
- redraw[x/2][y/2]=TRUE;
- redraw_mask|=REDRAW_TILES;
+ DrawMiniGraphicExt(drawto,gc, 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)
{
- DrawMiniGraphicExtHiRes(d,gc, SX+x*MINI_TILEX,SY+y*MINI_TILEY, graphic);
-}
-
-void DrawMiniGraphicExtHiRes(Drawable d, GC gc, int x, int y, int graphic)
-{
- if (graphic<0)
- XFillRectangle(display,d,gc, x,y, MINI_TILEX,MINI_TILEY);
- else if (graphic<256)
+ 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
+ }
+ else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
{
- graphic -= 256;
+ 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);
}
-int el2gfx(int element)
-{
- switch(element)
- {
- 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_MAMPFER: return(GFX_MAMPFER);
- case EL_ZOMBIE: return(GFX_ZOMBIE);
- 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_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_AMOEBE1: return(GFX_AMOEBE1);
- case EL_AMOEBE2: return(GFX_AMOEBE2);
- case EL_AMOEBE3: return(GFX_AMOEBE3);
- 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_1: return(GFX_ERZ_1);
- case EL_ERZ_2: return(GFX_ERZ_2);
- case EL_BIRNE_AUS: return(GFX_BIRNE_AUS);
- case EL_BIRNE_EIN: return(GFX_BIRNE_EIN);
- default:
- {
- if (IS_CHAR(element))
- return(GFX_CHAR_START + (element-EL_CHAR_START));
- else
- return(-1);
- }
- }
-}
-
-void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, int cut_mode)
+void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
+ int cut_mode, int mask_mode)
{
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;
- if (graphic<0)
+ if (graphic < 0)
{
DrawGraphic(x,y,graphic);
return;
if (dx || dy) /* Verschiebung der Grafik? */
{
- if (x<0) /* Element kommt von links ins Bild */
+ if (x < BX1) /* Element kommt von links ins Bild */
{
- x=0;
- width=dx;
- cx=TILEX-dx;
- dx=0;
+ x = BX1;
+ width = dx;
+ cx = TILEX - dx;
+ dx = 0;
}
- else if (x==SCR_FIELDX) /* Element kommt von rechts ins Bild */
+ else if (x > BX2) /* Element kommt von rechts ins Bild */
{
- x=SCR_FIELDX-1;
- width=-dx;
- dx=TILEX+dx;
+ x = BX2;
+ width = -dx;
+ dx = TILEX + dx;
}
- else if (x==0 && dx<0) /* Element verläßt links das Bild */
+ else if (x==BX1 && dx<0) /* Element verläßt links das Bild */
{
- width+=dx;
- cx=-dx;
- dx=0;
+ width += dx;
+ cx = -dx;
+ dx = 0;
}
- else if (x==SCR_FIELDX-1 && dx>0) /* El. verläßt rechts das Bild */
- width-=dx;
+ else if (x==BX2 && dx>0) /* Element verläßt rechts das Bild */
+ width -= dx;
else if (dx) /* allg. Bewegung in x-Richtung */
- redraw[x+SIGN(dx)][y]=TRUE;
+ MarkTileDirty(x + SIGN(dx), y);
- if (y<0) /* Element kommt von oben ins Bild */
+ if (y < BY1) /* Element kommt von oben ins Bild */
{
if (cut_mode==CUT_BELOW) /* Element oberhalb des Bildes */
return;
- y=0;
- height=dy;
- cy=TILEY-dy;
- dy=0;
+ y = BY1;
+ height = dy;
+ cy = TILEY - dy;
+ dy = 0;
}
- else if (y==SCR_FIELDY) /* Element kommt von unten ins Bild */
+ else if (y > BY2) /* Element kommt von unten ins Bild */
{
- y=SCR_FIELDY-1;
- height=-dy;
- dy=TILEY+dy;
+ y = BY2;
+ height = -dy;
+ dy = TILEY + dy;
}
- else if (y==0 && dy<0) /* Element verläßt oben das Bild */
+ else if (y==BY1 && dy<0) /* Element verläßt oben das Bild */
{
- height+=dy;
- cy=-dy;
- dy=0;
+ height += dy;
+ cy = -dy;
+ dy = 0;
}
- else if (dy>0 && cut_mode==CUT_ABOVE)
+ else if (dy > 0 && cut_mode==CUT_ABOVE)
{
- if (y==SCR_FIELDY-1) /* Element unterhalb des Bildes */
+ if (y == BY2) /* Element unterhalb des Bildes */
return;
- height=dy;
- cy=TILEY-dy;
- dy=TILEY;
- redraw[x][y+1]=TRUE;
+ height = dy;
+ cy = TILEY-dy;
+ dy = TILEY;
+ MarkTileDirty(x, y + 1);
} /* Element verläßt unten das Bild */
- else if (dy>0 && (y==SCR_FIELDY-1 || cut_mode==CUT_BELOW))
- height-=dy;
+ else if (dy > 0 && (y == BY2 || cut_mode==CUT_BELOW))
+ height -= dy;
else if (dy) /* allg. Bewegung in y-Richtung */
- redraw[x][y+SIGN(dy)]=TRUE;
+ MarkTileDirty(x, y + SIGN(dy));
}
- XCopyArea(display,pix[PIX_BACK],drawto_field,gc,
- SX+(graphic % GFX_PER_LINE)*TILEX+cx,
- SY+(graphic / GFX_PER_LINE)*TILEY+cy,
- width,height, SX+x*TILEX+dx,SY+y*TILEY+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_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;
+ }
+
+ dest_x = FX + x*TILEX + dx;
+ dest_y = FY + y*TILEY + dy;
- redraw_tiles++;
- redraw[x][y]=TRUE;
- redraw_mask|=REDRAW_TILES;
+#if DEBUG
+ if (!IN_SCR_FIELD(x,y))
+ {
+ printf("DrawGraphicShifted(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+ printf("DrawGraphicShifted(): This should never happen!\n");
+ return;
+ }
+#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);
+ }
+ }
+ else
+ XCopyArea(display, src_pixmap, drawto_field, gc,
+ src_x,src_y, width,height, dest_x,dest_y);
+
+ MarkTileDirty(x,y);
}
-void DrawElementShifted(int x, int y, int dx, int dy, int element,int cut_mode)
+void DrawGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic,
+ int cut_mode)
+{
+ DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode, USE_MASKING);
+}
+
+void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
+ int cut_mode, int mask_mode)
{
int ux = UNSCROLLX(x), uy = UNSCROLLY(y);
int graphic = el2gfx(element);
- int phase = ABS(MovPos[ux][uy])/(TILEX/2);
+ int phase4 = ABS(MovPos[ux][uy])/(TILEX/4);
+ int phase = phase4 / 2;
int dir = MovDir[ux][uy];
- int horiz_move = (dir==MV_LEFT || dir==MV_RIGHT);
- if (element==EL_PACMAN ||
- element==EL_KAEFER ||
- element==EL_FLIEGER)
+ if (element==EL_PACMAN || element==EL_KAEFER || element==EL_FLIEGER)
{
- if (element==EL_PACMAN)
- graphic = GFX_PACMAN + 4*!phase;
- else
- graphic += 4*!phase;
+ graphic += 4*!phase;
- if (dir==MV_UP)
+ if (dir == MV_UP)
graphic += 1;
- else if (dir==MV_LEFT)
+ else if (dir == MV_LEFT)
graphic += 2;
- else if (dir==MV_DOWN)
+ else if (dir == MV_DOWN)
graphic += 3;
}
- else if ((element==EL_FELSBROCKEN ||
- element==EL_EDELSTEIN ||
- element==EL_DIAMANT) && horiz_move && phase)
+ else if (element==EL_MAULWURF || element==EL_PINGUIN ||
+ element==EL_SCHWEIN || element==EL_DRACHE)
{
- if (element==EL_FELSBROCKEN)
- graphic += 2;
+ 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 += 1;
+ graphic = (element==EL_MAULWURF ? GFX_MAULWURF_DOWN :
+ element==EL_PINGUIN ? GFX_PINGUIN_DOWN :
+ element==EL_SCHWEIN ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN);
+
+ 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)
+ {
+ graphic += !phase;
+ }
+ else if ((element==EL_FELSBROCKEN || IS_GEM(element)) && !cut_mode)
+ {
+ graphic += phase * (element==EL_FELSBROCKEN ? 2 : 1);
}
- else if ((element==EL_SIEB_LEER ||
- element==EL_SIEB_VOLL) && SiebAktiv)
+ else if ((element==EL_SIEB_LEER || element==EL_SIEB2_LEER ||
+ element==EL_SIEB_VOLL || element==EL_SIEB2_VOLL) && SiebAktiv)
{
graphic += 3-(SiebAktiv%8)/2;
}
else if (IS_AMOEBOID(element))
{
- graphic = (element==EL_AMOEBE1 ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
+ graphic = (element==EL_AMOEBE_TOT ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
graphic += (x+2*y) % 4;
}
+ else if (element==EL_MAUER_LEBT)
+ {
+ BOOL links_massiv = FALSE, rechts_massiv = 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 (links_massiv && rechts_massiv)
+ graphic = GFX_MAUERWERK;
+ else if (links_massiv)
+ graphic = GFX_MAUER_R;
+ else if (rechts_massiv)
+ graphic = GFX_MAUER_L;
+ }
if (dx || dy)
- DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode);
+ DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode, mask_mode);
+ else if (mask_mode == USE_MASKING)
+ DrawGraphicThruMask(x,y, graphic);
else
DrawGraphic(x,y, graphic);
}
+void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
+ int cut_mode, int mask_mode)
+{
+ if (IN_LEV_FIELD(x,y) && IN_SCR_FIELD(SCROLLX(x),SCROLLY(y)))
+ DrawScreenElementExt(SCROLLX(x),SCROLLY(y), dx,dy, element,
+ cut_mode, mask_mode);
+}
+
+void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
+ int cut_mode)
+{
+ DrawScreenElementExt(x,y, dx,dy, element, cut_mode, NO_MASKING);
+}
+
+void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
+ int cut_mode)
+{
+ 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);
+}
+
void ErdreichAnbroeckeln(int x, int y)
{
int i, width, height, cx,cy;
int snip = 4;
static int xy[4][2] =
{
- 0,-1,
- -1,0,
- +1,0,
- 0,+1
+ { 0,-1 },
+ { -1,0 },
+ { +1,0 },
+ { 0,+1 }
};
if (!IN_LEV_FIELD(ux,uy))
else
element = Feld[uxx][uyy];
-/*
- if (element==EL_ERDREICH || IS_SOLID(element))
- continue;
-*/
if (element==EL_ERDREICH)
continue;
XCopyArea(display,pix[PIX_BACK],drawto_field,gc,
SX+(graphic % GFX_PER_LINE)*TILEX+cx,
SY+(graphic / GFX_PER_LINE)*TILEY+cy,
- width,height, SX+x*TILEX+cx,SY+y*TILEY+cy);
+ width,height, FX+x*TILEX+cx,FY+y*TILEY+cy);
}
- redraw_tiles++;
- redraw[x][y]=TRUE;
+ MarkTileDirty(x,y);
}
else
{
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) || IS_SOLID(element))
- continue;
-*/
if (!IN_LEV_FIELD(uxx,uyy) || Feld[uxx][uyy]!=EL_ERDREICH ||
!IN_SCR_FIELD(xx,yy))
XCopyArea(display,pix[PIX_BACK],drawto_field,gc,
SX+(graphic % GFX_PER_LINE)*TILEX+cx,
SY+(graphic / GFX_PER_LINE)*TILEY+cy,
- width,height, SX+xx*TILEX+cx,SY+yy*TILEY+cy);
+ width,height, FX+xx*TILEX+cx,FY+yy*TILEY+cy);
- redraw_tiles++;
- redraw[xx][yy]=TRUE;
+ MarkTileDirty(xx,yy);
}
}
}
void DrawScreenElement(int x, int y, int element)
{
- DrawElementShifted(x,y,0,0,element,CUT_NO_CUTTING);
+ DrawScreenElementExt(x,y, 0,0, element, NO_CUTTING, NO_MASKING);
ErdreichAnbroeckeln(x,y);
}
if (IS_MOVING(ux,uy))
{
int horiz_move = (MovDir[ux][uy]==MV_LEFT || MovDir[ux][uy]==MV_RIGHT);
- BOOL cut_mode = CUT_NO_CUTTING;
+ BOOL cut_mode = NO_CUTTING;
if (Store[ux][uy]==EL_MORAST_LEER ||
Store[ux][uy]==EL_SIEB_LEER ||
- Store[ux][uy]==EL_AMOEBE2)
+ Store[ux][uy]==EL_SIEB2_LEER ||
+ Store[ux][uy]==EL_AMOEBE_NASS)
cut_mode = CUT_ABOVE;
else if (Store[ux][uy]==EL_MORAST_VOLL ||
+
+#if 0
+ Store[ux][uy]==EL_SALZSAEURE ||
+#endif
+
Store[ux][uy]==EL_SIEB_VOLL ||
- Store[ux][uy]==EL_SALZSAEURE)
+ Store[ux][uy]==EL_SIEB2_VOLL)
cut_mode = CUT_BELOW;
if (cut_mode==CUT_ABOVE)
- DrawElementShifted(x,y,0,0,Store[ux][uy],CUT_NO_CUTTING);
+ DrawScreenElementShifted(x,y, 0,0, Store[ux][uy], NO_CUTTING);
else
DrawScreenElement(x,y,EL_LEERRAUM);
if (horiz_move)
- DrawElementShifted(x,y,MovPos[ux][uy],0,element,CUT_NO_CUTTING);
+ DrawScreenElementShifted(x,y, MovPos[ux][uy],0, element, NO_CUTTING);
else
- DrawElementShifted(x,y,0,MovPos[ux][uy],element,cut_mode);
+ DrawScreenElementShifted(x,y, 0,MovPos[ux][uy], element, cut_mode);
+
+#if 1
+ if (Store[ux][uy] == EL_SALZSAEURE)
+ DrawLevelElementThruMask(ux,uy+1, EL_SALZSAEURE);
+#endif
+
}
else if (IS_BLOCKED(ux,uy))
{
int oldx,oldy;
int sx, sy;
int horiz_move;
- BOOL cut_mode = CUT_NO_CUTTING;
+ BOOL cut_mode = NO_CUTTING;
Blocked2Moving(ux,uy,&oldx,&oldy);
sx = SCROLLX(oldx);
if (Store[oldx][oldy]==EL_MORAST_LEER ||
Store[oldx][oldy]==EL_SIEB_LEER ||
- Store[oldx][oldy]==EL_AMOEBE2)
+ Store[oldx][oldy]==EL_SIEB2_LEER ||
+ Store[oldx][oldy]==EL_AMOEBE_NASS)
cut_mode = CUT_ABOVE;
DrawScreenElement(x,y,EL_LEERRAUM);
element = Feld[oldx][oldy];
if (horiz_move)
- DrawElementShifted(sx,sy,MovPos[oldx][oldy],0,element,CUT_NO_CUTTING);
+ DrawScreenElementShifted(sx,sy, MovPos[oldx][oldy],0,element,NO_CUTTING);
else
- DrawElementShifted(sx,sy,0,MovPos[oldx][oldy],element,cut_mode);
+ DrawScreenElementShifted(sx,sy, 0,MovPos[oldx][oldy],element,cut_mode);
}
else if (IS_DRAWABLE(element))
DrawScreenElement(x,y,element);
graphic = el2gfx(element);
DrawMiniGraphic(x,y,graphic);
-
- redraw_tiles++;
- redraw[x/2][y/2]=TRUE;
- redraw_mask|=REDRAW_TILES;
}
void DrawMiniElementOrWall(int x, int y, int scroll_x, int scroll_y)
ClearWindow();
- for(x=0;x<SCR_FIELDX;x++)
- for(y=0;y<SCR_FIELDY;y++)
+ for(x=BX1; x<=BX2; x++)
+ for(y=BY1; y<=BY2; y++)
DrawScreenField(x,y);
- redraw_mask |= REDRAW_FIELD;
+ if (soft_scrolling_on)
+ XCopyArea(display,fieldbuffer,backbuffer,gc,
+ FX,FY, SXSIZE,SYSIZE,
+ SX,SY);
+
+ redraw_mask |= (REDRAW_FIELD | REDRAW_FROM_BACKBUFFER);
}
void DrawMiniLevel(int scroll_x, int scroll_y)
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;
+ if (lev_fieldy < STD_LEV_FIELDY)
+ ypos += (STD_LEV_FIELDY - lev_fieldy)/2 * MICRO_TILEY;
for(x=-1;x<=STD_LEV_FIELDX;x++)
for(y=-1;y<=STD_LEV_FIELDY;y++)
BOOL AreYouSure(char *text, unsigned int ays_state)
{
int mx,my, ty, result = -1;
+ unsigned int old_door_state;
+
+ old_door_state = GetDoorState();
CloseDoor(DOOR_CLOSE_1);
DOOR_GFX_PAGEX1,CONFIRM_BUTTON_YPOS);
OpenDoor(DOOR_OPEN_1);
+ ClearEventQueue();
if (!(ays_state & AYS_ASK) && !(ays_state & AYS_CONFIRM))
return(FALSE);
- if (game_status!=MAINMENU)
+ if (game_status != MAINMENU)
InitAnimation();
button_status = MB_RELEASED;
while(result<0)
{
DoAnimation();
- Delay(10000);
+ Delay(10);
if (XPending(display))
{
{
int choice;
- if (event.type==MotionNotify)
+ if (event.type == MotionNotify)
{
motion_status = TRUE;
mx = ((XMotionEvent *) &event)->x;
break;
}
case KeyPress:
- key_status = KEY_PRESSED;
switch(XLookupKeysym((XKeyEvent *)&event,
((XKeyEvent *)&event)->state))
{
break;
}
break;
- case FocusIn:
- HandleFocusEvent(FOCUS_IN);
+ case KeyRelease:
+ key_joystick_mapping = 0;
break;
+ case FocusIn:
case FocusOut:
- HandleFocusEvent(FOCUS_OUT);
+ HandleFocusEvent((XFocusChangeEvent *) &event);
+ break;
+ case ClientMessage:
+ HandleClientMessageEvent((XClientMessageEvent *) &event);
break;
default:
break;
}
}
- else if (JoystickButton()==JOY_BUTTON_NEW_PRESSED)
+ else if (JoystickButton() == JOY_BUTTON_NEW_PRESSED)
{
int joy=Joystick();
}
}
- if (game_status!=MAINMENU)
+ if (game_status != MAINMENU)
StopAnimation();
if (!(ays_state & AYS_STAY_OPEN))
{
CloseDoor(DOOR_CLOSE_1);
- if (!(ays_state & AYS_STAY_CLOSED) &&
- (game_status==PLAYING || game_status==LEVELED))
+ if (!(ays_state & AYS_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,
return(result);
}
-void OpenDoor(unsigned int door_state)
+unsigned int OpenDoor(unsigned int door_state)
{
+ unsigned int new_door_state;
+
if (door_state & DOOR_COPY_BACK)
{
XCopyArea(display,pix[PIX_DB_DOOR],pix[PIX_DB_DOOR],gc,
door_state &= ~DOOR_COPY_BACK;
}
- MoveDoor(door_state);
- ClearEventQueue();
+ new_door_state = MoveDoor(door_state);
+
+ return(new_door_state);
}
-void CloseDoor(unsigned int door_state)
+unsigned int CloseDoor(unsigned int door_state)
{
+ 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);
- MoveDoor(door_state);
- ClearEventQueue();
+ new_door_state = MoveDoor(door_state);
+
+ return(new_door_state);
}
-void MoveDoor(unsigned int door_state)
+unsigned int GetDoorState()
{
- static int door1 = DOOR_CLOSE_1;
- static int door2 = DOOR_OPEN_2;
- int x, start, stepsize = 4;
+ return(MoveDoor(DOOR_GET_STATE));
+}
+
+unsigned int MoveDoor(unsigned int door_state)
+{
+ static unsigned int door1 = DOOR_OPEN_1;
+ static unsigned int door2 = DOOR_CLOSE_2;
+ static long door_delay = 0;
+ int x, start, stepsize = 2;
+ long door_delay_value = stepsize * 5;
+
+ if (door_state == DOOR_GET_STATE)
+ return(door1 | door2);
if (door1==DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
door_state &= ~DOOR_OPEN_1;
else if (door2==DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
door_state &= ~DOOR_CLOSE_2;
- if (door_state & DOOR_ACTION)
+ if (quick_doors)
{
- if (door_state & DOOR_OPEN_1)
- {
- XCopyArea(display,pix[PIX_DOOR],pix[PIX_DOOR],gc,
- 104,136, 8,8, 146,136);
- if (!(door_state & DOOR_NO_DELAY))
- {
- int i;
-
- XCopyArea(display,pix[PIX_DOOR],window,gc,
- 104,136, 8,8, DX+46,DY+136);
- XFlush(display);
- for(i=0;i<30;i++)
- {
- if (game_status==MAINMENU)
- DoAnimation();
- Delay(10000);
- }
- }
- }
- else if (door_state & DOOR_CLOSE_1)
- XCopyArea(display,pix[PIX_DOOR],pix[PIX_DOOR],gc,
- 88,136, 8,8, 146,136);
+ stepsize = 20;
+ door_delay_value = 0;
+ StopSound(SND_OEFFNEN);
+ }
+ if (door_state & DOOR_ACTION)
+ {
if (!(door_state & DOOR_NO_DELAY))
PlaySoundStereo(SND_OEFFNEN,PSND_MAX_RIGHT);
start = ((door_state & DOOR_NO_DELAY) ? DXSIZE : 0);
- for(x=start;x<=DXSIZE;x+=stepsize)
+ for(x=start; x<=DXSIZE; x+=stepsize)
{
+ 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,
XFillRectangle(display,drawto,gc,DX,DY+DYSIZE-i/2,DXSIZE,i/2);
- XSetClipOrigin(display,clip_gc[PIX_DOOR],DX-DXSIZE+i,DY);
+ XSetClipOrigin(display,clip_gc[PIX_DOOR],
+ DX-i,(DY+j)-DOOR_GFX_PAGEY1);
XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- DXSIZE-i,0, i,30, DX,DY);
+ DXSIZE,DOOR_GFX_PAGEY1, i,77, DX+DXSIZE-i,DY+j);
XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- DXSIZE-i,DYSIZE-30, i,30, DX,DY+DYSIZE-30);
- XSetClipOrigin(display,clip_gc[PIX_DOOR],DX-i,DY);
+ 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,0, i,30, DX+DXSIZE-i,DY);
+ DXSIZE-i,DOOR_GFX_PAGEY1+j, i,77-j, DX,DY);
XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- DXSIZE,DYSIZE-30, i,30, DX+DXSIZE-i,DY+DYSIZE-30);
- if (i>14)
- {
- XSetClipOrigin(display,clip_gc[PIX_DOOR],DX-i,DY);
- XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- DXSIZE+14,30,i-14,DYSIZE-60,DX+DXSIZE+14-i,DY+30);
- XSetClipOrigin(display,clip_gc[PIX_DOOR],DX-DXSIZE+i,DY);
- XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- DXSIZE-i,30,i-14,DYSIZE-60,DX,DY+30);
- }
+ 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);
+
redraw_mask |= REDRAW_DOOR_1;
}
if (door_state & DOOR_ACTION_2)
{
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,
XFillRectangle(display,drawto,gc,VX,VY+VYSIZE-i/2,VXSIZE,i/2);
XSetClipOrigin(display,clip_gc[PIX_DOOR],
- VX-VXSIZE+i,VY-DOOR_GFX_PAGEY2);
+ 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, i,VYSIZE, VX,VY);
+ VXSIZE-i,DOOR_GFX_PAGEY2+VYSIZE/2, i,VYSIZE/2,
+ VX,VY+VYSIZE/2-j);
XSetClipOrigin(display,clip_gc[PIX_DOOR],
- VX-i,VY-DOOR_GFX_PAGEY2);
+ VX-i,(VY+j)-DOOR_GFX_PAGEY2);
XCopyArea(display,pix[PIX_DOOR],drawto,clip_gc[PIX_DOOR],
- VXSIZE,DOOR_GFX_PAGEY2, i,VYSIZE, VX+VXSIZE-i,VY);
+ VXSIZE,DOOR_GFX_PAGEY2+VYSIZE/2, i,VYSIZE/2-j,
+ VX+VXSIZE-i,VY+VYSIZE/2+j);
redraw_mask |= REDRAW_DOOR_2;
}
BackToFront();
- Delay(stepsize*5000);
- if (game_status==MAINMENU)
+ if (game_status == MAINMENU)
DoAnimation();
}
}
door1 = door_state & DOOR_ACTION_1;
if (door_state & DOOR_ACTION_2)
door2 = door_state & DOOR_ACTION_2;
-}
-
-long mainCounter(int mode)
-{
- static struct timeval base_time = { 0, 0 };
- struct timeval current_time;
- long counter_ms;
-
- gettimeofday(¤t_time,NULL);
- if (mode==0 || current_time.tv_sec<base_time.tv_sec)
- base_time = current_time;
-
- counter_ms = (current_time.tv_sec - base_time.tv_sec)*1000
- + (current_time.tv_usec - base_time.tv_usec)/1000;
-
- if (mode==1)
- return(counter_ms/10); /* return 1/100 secs since last init */
- else
- return(counter_ms); /* return 1/1000 secs since last init */
-}
-
-void InitCounter() /* set counter back to zero */
-{
- mainCounter(0);
-}
-
-long Counter() /* returns 1/100 secs since last call of InitCounter() */
-{
- return(mainCounter(1));
-}
-
-long Counter2() /* returns 1/1000 secs since last call of InitCounter() */
-{
- return(mainCounter(2));
-}
-
-void WaitCounter(long value) /* wait for counter to reach value */
-{
- long wait;
-
- while((wait=value-Counter())>0)
- microsleep(wait*10000);
-}
-void WaitCounter2(long value) /* wait for counter to reach value */
-{
- long wait;
-
- while((wait=value-Counter2())>0)
- microsleep(wait*1000);
-}
-
-void Delay(long value)
-{
- microsleep(value);
-}
-
-BOOL DelayReached(long *counter_var, int delay)
-{
- long actual_counter = Counter();
-
- if (actual_counter>*counter_var+delay || actual_counter<*counter_var)
- {
- *counter_var = actual_counter;
- return(TRUE);
- }
- else
- return(FALSE);
+ return(door1 | door2);
}
int ReadPixel(Drawable d, int x, int y)
return(XGetPixel(pixelimage,0,0));
}
-static struct JoystickInfo joystick[2] =
-{
- JOYSTICK_XLEFT, JOYSTICK_XRIGHT, JOYSTICK_XMIDDLE,
- JOYSTICK_YUPPER, JOYSTICK_YLOWER, JOYSTICK_YMIDDLE,
-
- JOYSTICK_XLEFT, JOYSTICK_XRIGHT, JOYSTICK_XMIDDLE,
- JOYSTICK_YUPPER, JOYSTICK_YLOWER, JOYSTICK_YMIDDLE
-};
-
-void LoadJoystickData()
-{
- int i;
- char cookie[256];
- FILE *file;
-
- if (joystick_status==JOYSTICK_OFF)
- return;
-
- if (!(file=fopen(JOYDAT_FILE,"r")))
- return;
-
- fscanf(file,"%s",cookie);
- if (strcmp(cookie,JOYSTICK_COOKIE)) /* ungültiges Format? */
- {
- fprintf(stderr,"%s: wrong format of joystick file!\n",progname);
- fclose(file);
- return;
- }
-
- for(i=0;i<2;i++)
- {
- fscanf(file,"%s",cookie);
- fscanf(file, "%d %d %d \n",
- &joystick[i].xleft, &joystick[i].xmiddle, &joystick[i].xright);
- fscanf(file, "%d %d %d \n",
- &joystick[i].yupper, &joystick[i].ymiddle, &joystick[i].ylower);
- }
- fclose(file);
-
- CheckJoystickData();
-}
-
-void SaveJoystickData()
-{
- int i;
- FILE *file;
-
- if (joystick_status==JOYSTICK_OFF)
- return;
-
- CheckJoystickData();
-
- if (!(file=fopen(JOYDAT_FILE,"w")))
- {
- fprintf(stderr,"%s: cannot save joystick calibration data!\n",progname);
- return;
- }
-
- fprintf(file,"%s\n",JOYSTICK_COOKIE); /* Formatkennung */
- for(i=0;i<2;i++)
- {
- fprintf(file,"JOYSTICK_%d_DATA\n",i);
- fprintf(file, "%d %d %d \n",
- joystick[i].xleft, joystick[i].xmiddle, joystick[i].xright);
- fprintf(file, "%d %d %d \n",
- joystick[i].yupper, joystick[i].ymiddle, joystick[i].ylower);
- }
- fclose(file);
-
- chmod(JOYDAT_FILE, JOYDAT_PERMS);
-}
-
-void CheckJoystickData()
-{
- int i;
- int distance = 100;
-
- for(i=0;i<2;i++)
- {
- if (joystick[i].xmiddle <= distance)
- joystick[i].xmiddle = distance;
- if (joystick[i].ymiddle <= distance)
- joystick[i].ymiddle = distance;
-
- if (joystick[i].xleft >= joystick[i].xmiddle)
- joystick[i].xleft = joystick[i].xmiddle-distance;
- if (joystick[i].xright <= joystick[i].xmiddle)
- joystick[i].xright = joystick[i].xmiddle+distance;
-
- if (joystick[i].yupper >= joystick[i].ymiddle)
- joystick[i].yupper = joystick[i].ymiddle-distance;
- if (joystick[i].ylower <= joystick[i].ymiddle)
- joystick[i].ylower = joystick[i].ymiddle+distance;
- }
-}
-
-int JoystickPosition(int middle, int margin, int actual)
-{
- long range, pos;
- int percentage;
-
- if (margin<middle && actual>middle)
- return(0);
- if (margin>middle && actual<middle)
- return(0);
-
- range=ABS(margin-middle);
- pos=ABS(actual-middle);
- percentage=(int)(pos*100/range);
- if (percentage>100)
- percentage=100;
-
- return(percentage);
-}
-
-int Joystick()
-{
- struct joystick_control
- {
- int buttons;
- int x;
- int y;
- } joy_ctrl;
-
- int js_x,js_y, js_b1,js_b2;
- int left, right, up, down;
- int result=0;
-
- if (joystick_status==JOYSTICK_OFF)
- return(0);
-
- if (read(joystick_device, &joy_ctrl, sizeof(joy_ctrl)) != sizeof(joy_ctrl))
- {
- fprintf(stderr,"%s: cannot read joystick settings - no joystick support\n",progname);
- joystick_status = JOYSTICK_OFF;
- return(0);
- }
-
- js_x = joy_ctrl.x;
- js_y = joy_ctrl.y;
- js_b1 = joy_ctrl.buttons & 1;
- js_b2 = joy_ctrl.buttons & 2;
-
- left = JoystickPosition(joystick[joystick_nr].xmiddle,
- joystick[joystick_nr].xleft, js_x);
- right = JoystickPosition(joystick[joystick_nr].xmiddle,
- joystick[joystick_nr].xright, js_x);
- up = JoystickPosition(joystick[joystick_nr].ymiddle,
- joystick[joystick_nr].yupper, js_y);
- down = JoystickPosition(joystick[joystick_nr].ymiddle,
- joystick[joystick_nr].ylower, js_y);
-
- if (left>JOYSTICK_PERCENT)
- result |= JOY_LEFT;
- else if (right>JOYSTICK_PERCENT)
- result |= JOY_RIGHT;
- if (up>JOYSTICK_PERCENT)
- result |= JOY_UP;
- else if (down>JOYSTICK_PERCENT)
- result |= JOY_DOWN;
- if (js_b1)
- result |= JOY_BUTTON_1;
- if (js_b2)
- result |= JOY_BUTTON_2;
-
- return(result);
-}
-
-int JoystickButton()
-{
- static int last_joy_button=0;
- int joy_button=(Joystick() & JOY_BUTTON);
- int result;
-
- if (joy_button)
- {
- if (last_joy_button)
- result=JOY_BUTTON_PRESSED;
- else
- result=JOY_BUTTON_NEW_PRESSED;
- }
- else
- {
- if (last_joy_button)
- result=JOY_BUTTON_NEW_RELEASED;
- else
- result=JOY_BUTTON_NOT_PRESSED;
- }
-
- last_joy_button = joy_button;
- return(result);
-}
-
-void CalibrateJoystick()
+int el2gfx(int element)
{
- struct joystick_control
- {
- int buttons;
- int x;
- int y;
- } joy_ctrl;
-
- int new_joystick_xleft, new_joystick_xright, new_joystick_xmiddle;
- int new_joystick_yupper, new_joystick_ylower, new_joystick_ymiddle;
-
- if (joystick_status==JOYSTICK_OFF)
- goto error_out;
-
- ClearWindow();
- DrawText(SX+16, SY+7*32, "MOVE JOYSTICK TO",FS_BIG,FC_YELLOW);
- DrawText(SX+16, SY+8*32, " THE UPPER LEFT ",FS_BIG,FC_YELLOW);
- DrawText(SX+16, SY+9*32, "AND PRESS BUTTON",FS_BIG,FC_YELLOW);
- BackToFront();
-
- joy_ctrl.buttons = 0;
- while(Joystick() & JOY_BUTTON);
- while(!joy_ctrl.buttons)
- {
- if (read(joystick_device, &joy_ctrl, sizeof(joy_ctrl)) != sizeof(joy_ctrl))
- {
- joystick_status=JOYSTICK_OFF;
- goto error_out;
- }
- Delay(10000);
- }
-
- new_joystick_xleft = joy_ctrl.x;
- new_joystick_yupper = joy_ctrl.y;
-
- ClearWindow();
- DrawText(SX+16, SY+7*32, "MOVE JOYSTICK TO",FS_BIG,FC_YELLOW);
- DrawText(SX+32, SY+8*32, "THE LOWER RIGHT",FS_BIG,FC_YELLOW);
- DrawText(SX+16, SY+9*32, "AND PRESS BUTTON",FS_BIG,FC_YELLOW);
- BackToFront();
-
- joy_ctrl.buttons = 0;
- while(Joystick() & JOY_BUTTON);
- while(!joy_ctrl.buttons)
- {
- if (read(joystick_device, &joy_ctrl, sizeof(joy_ctrl)) != sizeof(joy_ctrl))
- {
- joystick_status=JOYSTICK_OFF;
- goto error_out;
- }
- Delay(10000);
- }
-
- new_joystick_xright = joy_ctrl.x;
- new_joystick_ylower = joy_ctrl.y;
-
- ClearWindow();
- DrawText(SX+32, SY+16+7*32, "CENTER JOYSTICK",FS_BIG,FC_YELLOW);
- DrawText(SX+16, SY+16+8*32, "AND PRESS BUTTON",FS_BIG,FC_YELLOW);
- BackToFront();
-
- joy_ctrl.buttons = 0;
- while(Joystick() & JOY_BUTTON);
- while(!joy_ctrl.buttons)
+ switch(element)
{
- if (read(joystick_device, &joy_ctrl, sizeof(joy_ctrl)) != sizeof(joy_ctrl))
+ 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_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_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_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:
{
- joystick_status=JOYSTICK_OFF;
- goto error_out;
+ if (IS_CHAR(element))
+ return(GFX_CHAR_START + (element-EL_CHAR_START));
+ else
+ return(-1);
}
- Delay(10000);
}
-
- new_joystick_xmiddle = joy_ctrl.x;
- new_joystick_ymiddle = joy_ctrl.y;
-
- joystick[joystick_nr].xleft = new_joystick_xleft;
- joystick[joystick_nr].yupper = new_joystick_yupper;
- joystick[joystick_nr].xright = new_joystick_xright;
- joystick[joystick_nr].ylower = new_joystick_ylower;
- joystick[joystick_nr].xmiddle = new_joystick_xmiddle;
- joystick[joystick_nr].ymiddle = new_joystick_ymiddle;
-
- CheckJoystickData();
-
- DrawSetupScreen();
- while(Joystick() & JOY_BUTTON);
- return;
-
- error_out:
-
- ClearWindow();
- DrawText(SX+16, SY+16, "NO JOYSTICK",FS_BIG,FC_YELLOW);
- DrawText(SX+16, SY+48, " AVAILABLE ",FS_BIG,FC_YELLOW);
- Delay(3000000);
- DrawSetupScreen();
}
projects / rocksndiamonds.git / blobdiff