{ "bd_magic_wall.active.frames", "4" },
{ "bd_magic_wall.active.mode_reverse", "true" },
{ "bd_magic_wall.active.delay", "4" },
+ { "bd_magic_wall.active.global_sync", "true" },
{ "bd_magic_wall_filling", "RocksElements.pcx" },
{ "bd_magic_wall_filling.xpos", "12" },
{ "bd_magic_wall_filling.ypos", "10" },
{ "bd_magic_wall_filling.frames", "4" },
{ "bd_magic_wall_filling.mode_reverse", "true" },
{ "bd_magic_wall_filling.delay", "4" },
+ { "bd_magic_wall_filling.global_sync", "true" },
{ "bd_magic_wall_full", "RocksElements.pcx" },
{ "bd_magic_wall_full.xpos", "12" },
{ "bd_magic_wall_full.ypos", "10" },
{ "bd_magic_wall_full.frames", "4" },
{ "bd_magic_wall_full.mode_reverse", "true" },
{ "bd_magic_wall_full.delay", "4" },
+ { "bd_magic_wall_full.global_sync", "true" },
{ "bd_magic_wall_emptying", "RocksElements.pcx" },
{ "bd_magic_wall_emptying.xpos", "12" },
{ "bd_magic_wall_emptying.ypos", "10" },
{ "bd_magic_wall_emptying.frames", "4" },
{ "bd_magic_wall_emptying.mode_reverse", "true" },
{ "bd_magic_wall_emptying.delay", "4" },
+ { "bd_magic_wall_emptying.global_sync", "true" },
{ "bd_magic_wall_dead", "RocksElements.pcx" },
{ "bd_magic_wall_dead.xpos", "12" },
{ "bd_magic_wall_dead.ypos", "10" },
{ "magic_wall.active.frames", "4" },
{ "magic_wall.active.mode_reverse", "true" },
{ "magic_wall.active.delay", "4" },
+ { "magic_wall.active.global_sync", "true" },
{ "magic_wall_filling", "RocksElements.pcx" },
{ "magic_wall_filling.xpos", "0" },
{ "magic_wall_filling.ypos", "8" },
{ "magic_wall_filling.frames", "4" },
{ "magic_wall_filling.mode_reverse", "true" },
{ "magic_wall_filling.delay", "4" },
+ { "magic_wall_filling.global_sync", "true" },
{ "magic_wall_full", "RocksElements.pcx" },
{ "magic_wall_full.xpos", "0" },
{ "magic_wall_full.ypos", "8" },
{ "magic_wall_full.frames", "4" },
{ "magic_wall_full.mode_reverse", "true" },
{ "magic_wall_full.delay", "4" },
+ { "magic_wall_full.global_sync", "true" },
{ "magic_wall_emptying", "RocksElements.pcx" },
{ "magic_wall_emptying.xpos", "0" },
{ "magic_wall_emptying.ypos", "8" },
{ "magic_wall_emptying.frames", "4" },
{ "magic_wall_emptying.mode_reverse", "true" },
{ "magic_wall_emptying.delay", "4" },
+ { "magic_wall_emptying.global_sync", "true" },
{ "magic_wall_dead", "RocksElements.pcx" },
{ "magic_wall_dead.xpos", "0" },
{ "magic_wall_dead.ypos", "8" },
-#define COMPILE_DATE_STRING "[2003-01-26 04:01]"
+#define COMPILE_DATE_STRING "[2003-01-27 02:14]"
{
static unsigned long action_delay = 0;
unsigned long action_delay_value = GameFrameDelay;
- int graphic = el2img(properties_element);
int xpos = 1, ypos = 2;
if (edit_mode != ED_MODE_PROPERTIES)
if (!DelayReached(&action_delay, action_delay_value))
return;
-#if 1
DrawGraphicAnimationExt(drawto,
SX + xpos * TILEX,
SY + ypos * TILEY + MINI_TILEY / 2,
- graphic, -1, NO_MASKING);
-
-#else
- DrawGraphicAnimationExt(drawto,
- SX + xpos * TILEX,
- SY + ypos * TILEY + MINI_TILEY / 2,
- el_dir_act2img(properties_element,
- MV_NO_MOVING,
- ...), -1, NO_MASKING);
-#endif
+ el2img(properties_element), -1, NO_MASKING);
MarkTileDirty(xpos, ypos);
MarkTileDirty(xpos, ypos + 1);
GfxFrame[x][y] = 0;
GfxAction[x][y] = ACTION_DEFAULT;
+
+#if 0
+ if (Feld[x][y] == EL_ROCK)
+ printf("ResetGfxAnimation: EL_ROCK [%d, %d]\n",
+ JustStopped[x][y], MovDir[x][y]);
+#endif
}
void InitMovingField(int x, int y, int direction)
if (!JustStopped[x][y] || direction != MovDir[x][y])
ResetGfxAnimation(x, y);
- MovDir[x][y] = direction;
- MovDir[newx][newy] = direction;
+ MovDir[newx][newy] = MovDir[x][y] = direction;
if (Feld[newx][newy] == EL_EMPTY)
Feld[newx][newy] = EL_BLOCKED;
GfxAction[x][y] = ACTION_FALLING;
else
GfxAction[x][y] = ACTION_MOVING;
+
+ GfxFrame[newx][newy] = GfxFrame[x][y];
+ GfxAction[newx][newy] = GfxAction[x][y];
+ GfxRandom[newx][newy] = GfxRandom[x][y];
}
void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
void CheckDynamite(int x, int y)
{
-#if 0
- int element = Feld[x][y];
-#endif
-
if (MovDelay[x][y] != 0) /* dynamite is still waiting to explode */
{
MovDelay[x][y]--;
if (MovDelay[x][y] != 0)
{
-#if 0
- if (checkDrawLevelGraphicAnimation(x, y, el2img(element)))
-#endif
- DrawDynamite(x, y);
+ DrawDynamite(x, y);
+ /* !!! correct: "PlaySoundLevelActionIfLoop" etc. !!! */
PlaySoundLevelAction(x, y, ACTION_ACTIVE);
return;
return;
object_hit = (!IS_FREE(x, y+1) && (!IS_MOVING(x, y+1) ||
- MovDir[x][y+1]!=MV_DOWN ||
- MovPos[x][y+1]<=TILEY/2));
+ MovDir[x][y+1] != MV_DOWN ||
+ MovPos[x][y+1] <= TILEY / 2));
if (object_hit)
smashed = MovingOrBlocked2Element(x, y+1);
}
return;
}
+#if 1
+ if (lastline || object_hit)
+ {
+#if 0
+ MovDir[x][y] = 0;
+#endif
+ ResetGfxAnimation(x, y);
+ DrawLevelField(x, y);
+ }
+#endif
+
if ((element == EL_BOMB ||
element == EL_SP_DISK_ORANGE ||
element == EL_DX_SUPABOMB) &&
}
else if (IS_FREE(x, y+1))
{
+ if (JustStopped[x][y]) /* prevent animation from being restarted */
+ MovDir[x][y] = MV_DOWN;
+
InitMovingField(x, y, MV_DOWN);
started_moving = TRUE;
}
element == EL_DARK_YAMYAM)
{
#if 1
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
#else
if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
{
#endif
}
else if (element == EL_SP_ELECTRON)
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
else if (element == EL_DRAGON)
{
int i;
element == EL_SP_SNIKSNAK || element == EL_MOLE)
DrawLevelField(x, y);
else if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
else if (element == EL_SATELLITE)
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
else if (element == EL_SP_ELECTRON)
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
if (DONT_TOUCH(element))
TestIfBadThingTouchesHero(x, y);
MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
MovDelay[newx][newy] = 0;
+#if 0
+ /* all done in "InitMovingField()" */
GfxAction[newx][newy] = GfxAction[x][y]; /* keep action one frame */
GfxRandom[newx][newy] = GfxRandom[x][y]; /* keep same random value */
- GfxAction[x][y] = ACTION_DEFAULT;
+#endif
+ /* copy animation control values to new field */
+ GfxFrame[newx][newy] = GfxFrame[x][y];
+ GfxAction[newx][newy] = GfxAction[x][y];
+ GfxRandom[newx][newy] = GfxRandom[x][y];
+
+ ResetGfxAnimation(x, y); /* reset animation values for old field */
+
+#if 1
#if 0
if (!CAN_MOVE(element))
MovDir[newx][newy] = 0;
if (!CAN_MOVE(element) ||
(element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
MovDir[newx][newy] = 0;
+#endif
#endif
DrawLevelField(x, y);
PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
}
-void SiebAktivieren(int x, int y, int type)
-{
- int graphic = (type == 1 ? IMG_MAGIC_WALL_FULL : IMG_BD_MAGIC_WALL_FULL);
-
- ContinueLevelGraphicAnimation(x, y, graphic);
-}
-
void CheckExit(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
{
int graphic = IMG_TRAP_ACTIVE;
- /* if animation frame already drawn, correct crumbled sand border */
- if (IS_ANIMATED(graphic))
- if (checkDrawLevelGraphicAnimation(x, y, graphic))
- DrawCrumbledSand(SCREENX(x), SCREENY(y));
+ /* if new animation frame was drawn, correct crumbled sand border */
+ if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ DrawCrumbledSand(SCREENX(x), SCREENY(y));
}
static void ChangeElement(int x, int y)
if (MovDelay[x][y] != 0) /* continue element change */
{
if (IS_ANIMATED(el2img(element)))
- ContinueLevelElementAnimation(x, y, element);
+ DrawLevelElementAnimationIfNeeded(x, y, element);
if (changing_element[element].change_function)
changing_element[element].change_function(x, y);
{
static unsigned long action_delay = 0;
unsigned long action_delay_value;
- int sieb_x = 0, sieb_y = 0;
+ int magic_wall_x = 0, magic_wall_y = 0;
int i, x, y, element, graphic;
byte *recorded_player_action;
byte summarized_player_action = 0;
element = Feld[x][y];
graphic = el2img(element);
+#if 1
+ if (graphic_info[graphic].anim_global_sync)
+ GfxFrame[x][y] = FrameCounter;
+#endif
+
if (ANIM_MODE(graphic) == ANIM_RANDOM &&
IS_NEW_FRAME(GfxFrame[x][y], graphic))
ResetRandomAnimationValue(x, y);
#if 1
if (IS_ANIMATED(graphic))
- ContinueLevelGraphicAnimation(x, y, graphic);
+ DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
#endif
continue;
{
StartMoving(x, y);
-#if 1
-#if 0
- if (Feld[x][y] == EL_EMERALD &&
- IS_ANIMATED(graphic) &&
- !IS_MOVING(x, y))
- ContinueLevelGraphicAnimation(x, y, graphic);
-#else
if (IS_ANIMATED(graphic) &&
- !IS_MOVING(x, y))
- ContinueLevelGraphicAnimation(x, y, graphic);
-#endif
-#endif
+ !IS_MOVING(x, y) &&
+ !Stop[x][y])
+ DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
if (IS_GEM(element) || element == EL_SP_INFOTRON)
EdelsteinFunkeln(x, y);
element == EL_SHIELD_NORMAL ||
element == EL_SHIELD_DEADLY) &&
IS_ANIMATED(graphic))
- ContinueLevelGraphicAnimation(x, y, graphic);
+ DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
#endif
else if (IS_MOVING(x, y))
else if (element == EL_EXPLOSION)
; /* drawing of correct explosion animation is handled separately */
else if (IS_ANIMATED(graphic))
- ContinueLevelGraphicAnimation(x, y, graphic);
+ DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
#endif
if (IS_BELT_ACTIVE(element))
boolean sieb = FALSE;
int jx = local_player->jx, jy = local_player->jy;
- if (element == EL_MAGIC_WALL_FULL ||
- element == EL_MAGIC_WALL_ACTIVE ||
- element == EL_MAGIC_WALL_EMPTYING)
- {
- SiebAktivieren(x, y, 1);
- sieb = TRUE;
- }
- else if (element == EL_BD_MAGIC_WALL_FULL ||
- element == EL_BD_MAGIC_WALL_ACTIVE ||
- element == EL_BD_MAGIC_WALL_EMPTYING)
- {
- SiebAktivieren(x, y, 2);
- sieb = TRUE;
- }
-
/* play the element sound at the position nearest to the player */
- if (sieb && ABS(x-jx)+ABS(y-jy) < ABS(sieb_x-jx)+ABS(sieb_y-jy))
+ if ((element == EL_MAGIC_WALL_FULL ||
+ element == EL_MAGIC_WALL_ACTIVE ||
+ element == EL_MAGIC_WALL_EMPTYING ||
+ element == EL_BD_MAGIC_WALL_FULL ||
+ element == EL_BD_MAGIC_WALL_ACTIVE ||
+ element == EL_BD_MAGIC_WALL_EMPTYING) &&
+ ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
{
- sieb_x = x;
- sieb_y = y;
+ magic_wall_x = x;
+ magic_wall_y = y;
}
}
}
{
if (!(game.magic_wall_time_left % 4))
{
- int element = Feld[sieb_x][sieb_y];
+ int element = Feld[magic_wall_x][magic_wall_y];
if (element == EL_BD_MAGIC_WALL_FULL ||
element == EL_BD_MAGIC_WALL_ACTIVE ||
element == EL_BD_MAGIC_WALL_EMPTYING)
- PlaySoundLevel(sieb_x, sieb_y, SND_BD_MAGIC_WALL_ACTIVE);
+ PlaySoundLevel(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
else
- PlaySoundLevel(sieb_x, sieb_y, SND_MAGIC_WALL_ACTIVE);
+ PlaySoundLevel(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
}
if (game.magic_wall_time_left > 0)
#define ANIM_MODE(g) (graphic_info[g].anim_mode)
#define IS_ANIMATED(g) (ANIM_FRAMES(g) > 1)
-#define IS_NEW_FRAME(f, g) ((f) % ANIM_DELAY(g) == 0)
+#define IS_NEW_DELAY(f, g) ((f) % ANIM_DELAY(g) == 0)
+#define IS_NEW_FRAME(f, g) (IS_ANIMATED(g) && IS_NEW_DELAY(f, g))
#define IS_LOOP_SOUND(s) (sound_info[s].loop)
}
}
-static int getGraphicAnimationPhase(int frames, int delay, int mode)
-{
- int phase;
-
- if (mode & ANIM_PINGPONG)
- {
- 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;
-
- return phase;
-}
-
void SetRandomAnimationValue(int x, int y)
{
anim.random_frame = GfxRandom[x][y];
DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
}
-inline boolean checkDrawGraphicAnimation(int sx, int sy, int graphic)
-{
- int lx = LEVELX(sx), ly = LEVELY(sy);
-
- return (IN_SCR_FIELD(sx, sy) && IS_NEW_FRAME(GfxFrame[lx][ly], graphic));
-}
-
-inline boolean checkDrawLevelGraphicAnimation(int lx, int ly, int graphic)
-{
- int sx = SCREENX(lx), sy = SCREENY(ly);
-
- return (IN_SCR_FIELD(sx, sy) && IS_NEW_FRAME(GfxFrame[lx][ly], graphic));
-}
-
-inline boolean DrawGraphicAnimation(int x, int y, int graphic)
+inline void DrawGraphicAnimation(int x, int y, int graphic)
{
int lx = LEVELX(x), ly = LEVELY(y);
-#if 0
- if (!checkDrawGraphicAnimation(x, y, graphic))
- return FALSE;
-#else
if (!IN_SCR_FIELD(x, y))
- return FALSE;
-#endif
+ return;
DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
graphic, GfxFrame[lx][ly], NO_MASKING);
MarkTileDirty(x, y);
-
- return TRUE;
}
-boolean DrawLevelGraphicAnimation(int x, int y, int graphic)
+void DrawLevelGraphicAnimation(int x, int y, int graphic)
{
- return DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
}
-boolean DrawLevelElementAnimation(int x, int y, int element)
+void DrawLevelElementAnimation(int x, int y, int element)
{
- return DrawGraphicAnimation(SCREENX(x), SCREENY(y), el2img(element));
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), el2img(element));
}
-inline void ContinueLevelGraphicAnimation(int x, int y, int graphic)
+inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
{
+ int sx = SCREENX(x), sy = SCREENY(y);
+
+ if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
+ return;
+
if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
return;
- DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+ DrawGraphicAnimation(sx, sy, graphic);
}
-void ContinueLevelElementAnimation(int x, int y, int element)
+void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
{
- ContinueLevelGraphicAnimation(x, y, el2img(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);
}
void DrawAllPlayers()
if ((sxx || syy) && IS_PUSHABLE(element))
{
- graphic = el_dir_act2img(element, player->MovDir, ACTION_MOVING);
+ graphic = el_act_dir2img(element, ACTION_MOVING, player->MovDir);
#if 1
frame = getGraphicAnimationFrame(graphic, player->GfxPos);
MarkTileDirty(x,y);
}
-void DrawGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic,
+void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy, int graphic,
int frame, int cut_mode)
{
DrawGraphicShifted(x,y, dx,dy, graphic, frame, cut_mode, USE_MASKING);
}
-inline static int getFramePosition(int x, int y)
-{
- int frame_pos = -1; /* default: global synchronization */
-#if 0
- int element = Feld[x][y];
-
- if (element == EL_QUICKSAND_FULL ||
- element == EL_MAGIC_WALL_FULL ||
- element == EL_BD_MAGIC_WALL_FULL)
- frame_pos = -1;
- else if (IS_MOVING(x, y) || CAN_MOVE(element) || CAN_FALL(element))
- frame_pos = ABS(MovPos[x][y]) / (TILEX / 8);
-#else
-
- frame_pos = ABS(MovPos[x][y]) / (TILEX / 8);
-
- frame_pos = GfxFrame[x][y];
-
-#endif
-
- return frame_pos;
-}
-
-inline static int getGfxAction(int x, int y)
-{
- int gfx_action = ACTION_DEFAULT;
-
-#if 0
- if (GfxAction[x][y] != ACTION_DEFAULT)
- gfx_action = GfxAction[x][y];
- else if (IS_MOVING(x, y))
- gfx_action = ACTION_MOVING;
-#else
- gfx_action = GfxAction[x][y];
-#endif
-
-#if DEBUG
- if (gfx_action < 0)
- printf("getGfxAction: THIS SHOULD NEVER HAPPEN: GfxAction[%d][%d] == %d\n",
- x, y, gfx_action);
-#endif
-
- return gfx_action;
-}
-
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 lx = LEVELX(x), ly = LEVELY(y);
int graphic;
int frame;
- if (IN_LEV_FIELD(ux, uy))
+ if (IN_LEV_FIELD(lx, ly))
{
- int move_dir = MovDir[ux][uy];
- int move_pos = getFramePosition(ux, uy);
- int gfx_action = getGfxAction(ux, uy);
-
- SetRandomAnimationValue(ux, uy);
+ SetRandomAnimationValue(lx, ly);
- graphic = el_dir_act2img(element, move_dir, gfx_action);
- frame = getGraphicAnimationFrame(graphic, move_pos);
+ graphic = el_act_dir2img(element, GfxAction[lx][ly], MovDir[lx][ly]);
+ frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
}
- else
+ else /* border element */
{
graphic = el2img(element);
- frame = getGraphicAnimationFrame(graphic, 0);
+ frame = getGraphicAnimationFrame(graphic, -1);
}
if (element == EL_WALL_GROWING)
{
boolean left_stopped = FALSE, right_stopped = FALSE;
- if (!IN_LEV_FIELD(ux - 1, uy) || IS_MAUER(Feld[ux - 1][uy]))
+ if (!IN_LEV_FIELD(lx - 1, ly) || IS_MAUER(Feld[lx - 1][ly]))
left_stopped = TRUE;
- if (!IN_LEV_FIELD(ux + 1, uy) || IS_MAUER(Feld[ux + 1][uy]))
+ if (!IN_LEV_FIELD(lx + 1, ly) || IS_MAUER(Feld[lx + 1][ly]))
right_stopped = TRUE;
if (left_stopped && right_stopped)
Bitmap *src_bitmap;
int src_x, src_y;
int i, width, height, cx,cy;
- int ux = LEVELX(x), uy = LEVELY(y);
+ int lx = LEVELX(x), ly = LEVELY(y);
int element, graphic;
int snip = 4;
static int xy[4][2] =
{ 0, +1 }
};
- if (!IN_LEV_FIELD(ux, uy))
+ if (!IN_LEV_FIELD(lx, ly))
return;
- element = Feld[ux][uy];
+ element = Feld[lx][ly];
if (element == EL_SAND ||
element == EL_LANDMINE ||
for(i=0; i<4; i++)
{
- int uxx, uyy;
+ int lxx, lyy;
- uxx = ux + xy[i][0];
- uyy = uy + xy[i][1];
- if (!IN_LEV_FIELD(uxx, uyy))
+ lxx = lx + xy[i][0];
+ lyy = ly + xy[i][1];
+ if (!IN_LEV_FIELD(lxx, lyy))
element = EL_STEELWALL;
else
- element = Feld[uxx][uyy];
+ element = Feld[lxx][lyy];
if (element == EL_SAND ||
element == EL_LANDMINE ||
for(i=0; i<4; i++)
{
- int xx, yy, uxx, uyy;
+ int xx, yy, lxx, lyy;
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_SAND &&
- Feld[uxx][uyy] != EL_LANDMINE &&
- Feld[uxx][uyy] != EL_TRAP &&
- Feld[uxx][uyy] != EL_TRAP_ACTIVE) ||
+ lxx = lx + xy[i][0];
+ lyy = ly + xy[i][1];
+
+ if (!IN_LEV_FIELD(lxx, lyy) ||
+ (Feld[lxx][lyy] != EL_SAND &&
+ Feld[lxx][lyy] != EL_LANDMINE &&
+ Feld[lxx][lyy] != EL_TRAP &&
+ Feld[lxx][lyy] != EL_TRAP_ACTIVE) ||
!IN_SCR_FIELD(xx, yy))
continue;
void DrawScreenField(int x, int y)
{
- int ux = LEVELX(x), uy = LEVELY(y);
+ int lx = LEVELX(x), ly = LEVELY(y);
int element, content;
- if (!IN_LEV_FIELD(ux, uy))
+ if (!IN_LEV_FIELD(lx, ly))
{
- if (ux < -1 || ux > lev_fieldx || uy < -1 || uy > lev_fieldy)
+ if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
element = EL_EMPTY;
else
element = BorderElement;
return;
}
- element = Feld[ux][uy];
- content = Store[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 (element == EL_QUICKSAND_EMPTYING ||
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[ux][uy], element, cut_mode);
+ DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
else
- DrawScreenElementShifted(x, y, 0, MovPos[ux][uy], content, cut_mode);
+ DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
if (content == EL_ACID)
- DrawLevelElementThruMask(ux, uy + 1, 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;
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 ||
}
}
-int el2img(int element)
+int el_act_dir2img(int element, int action, int direction)
{
- int graphic = element_info[element].graphic[ACTION_DEFAULT];
+ direction = MV_DIR_BIT(direction);
-#if DEBUG
- if (graphic < 0)
- Error(ERR_WARN, "element %d -> graphic %d -- probably crashing now...",
- element, graphic);
-#endif
+ return element_info[element].direction_graphic[action][direction];
+}
- return graphic;
+int el_act2img(int element, int action)
+{
+ return element_info[element].graphic[action];
}
int el_dir2img(int element, int direction)
{
- return el_dir_act2img(element, direction, ACTION_DEFAULT);
+ return el_act_dir2img(element, ACTION_DEFAULT, direction);
}
-int el_dir_act2img(int element, int direction, int action)
+int el2img(int element)
{
-#if DEBUG
- if (element < 0)
- {
- printf("el_dir_act2img: THIS SHOULD NEVER HAPPEN: element == %d\n",
- element);
-
- return IMG_EMPTY;
- }
-
- if (action < 0)
- {
- printf("el_dir_act2img: THIS SHOULD NEVER HAPPEN: action == %d\n",
- action);
-
- return IMG_EMPTY;
- }
-#endif
-
- direction = MV_DIR_BIT(direction);
-
- return element_info[element].direction_graphic[action][direction];
+ return element_info[element].graphic[ACTION_DEFAULT];
}
void SetRandomAnimationValue(int, int);
int getGraphicAnimationFrame(int, int);
void DrawGraphicAnimationExt(DrawBuffer *, int, int, int, int, int);
-boolean checkDrawGraphicAnimation(int, int, int);
-boolean checkDrawLevelGraphicAnimation(int, int, int);
-boolean DrawGraphicAnimation(int, int, int);
-boolean DrawLevelGraphicAnimation(int, int, int);
-boolean DrawLevelElementAnimation(int, int, int);
-void ContinueLevelGraphicAnimation(int, int, int);
-void ContinueLevelElementAnimation(int, int, int);
+void DrawGraphicAnimation(int, int, int);
+void DrawLevelGraphicAnimation(int, int, int);
+void DrawLevelElementAnimation(int, int, int);
+void DrawLevelGraphicAnimationIfNeeded(int, int, int);
+void DrawLevelElementAnimationIfNeeded(int, int, int);
void DrawAllPlayers(void);
void DrawPlayerField(int, int);
void FreeToolButtons();
int get_next_element(int);
-int el2img(int);
+int el_act_dir2img(int, int, int);
+int el_act2img(int, int);
int el_dir2img(int, int);
-int el_dir_act2img(int, int, int);
+int el2img(int);
#endif /* TOOLS_H */
projects / rocksndiamonds.git / commitdiff