{
int phase;
- if (mode == ANIM_PINGPONG)
+ if (mode & ANIM_PINGPONG)
{
int max_anim_frames = 2 * frames - 2;
else
phase = (FrameCounter % (delay * frames)) / delay;
- if (mode == ANIM_REVERSE)
+ if (mode & ANIM_REVERSE)
phase = -phase;
return phase;
}
-static int getNewGraphicAnimationFrame(int graphic, int sync_frame)
+int getNewGraphicAnimationFrame(int graphic, int sync_frame)
{
int num_frames = new_graphic_info[graphic].anim_frames;
int delay = new_graphic_info[graphic].anim_delay;
int mode = new_graphic_info[graphic].anim_mode;
- int frame;
+ int frame = 0;
/* animation synchronized with global frame counter, not move position */
if (new_graphic_info[graphic].anim_global_sync || sync_frame < 0)
sync_frame = FrameCounter;
- if (mode & ANIM_PINGPONG) /* use border frames once */
+ if (mode & ANIM_LOOP) /* normal, looping animation */
+ {
+ frame = (sync_frame % (delay * num_frames)) / delay;
+ }
+ else if (mode & ANIM_LINEAR) /* normal, non-looping animation */
+ {
+ frame = sync_frame / delay;
+
+ if (frame > num_frames - 1)
+ frame = num_frames - 1;
+ }
+ else if (mode & ANIM_PINGPONG) /* use border frames once */
{
int max_anim_frames = 2 * num_frames - 2;
frame = (sync_frame % (delay * max_anim_frames)) / delay;
frame = (frame < num_frames ? frame : max_anim_frames - frame - 1);
}
- else /* mode == ANIM_NORMAL || mode == ANIM_REVERSE */
- frame = (sync_frame % (delay * num_frames)) / delay;
if (mode & ANIM_REVERSE) /* use reverse animation direction */
frame = num_frames - frame - 1;
void DrawNewGraphicAnimationExt(int x, int y, int graphic, int mask_mode)
{
+#if 0
int delay = new_graphic_info[graphic].anim_delay;
if (!(FrameCounter % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#else
+ if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#endif
{
int frame = getNewGraphicAnimationFrame(graphic, -1);
Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
int src_x = new_graphic_info[graphic].src_x;
int src_y = new_graphic_info[graphic].src_y;
+ int offset_x = new_graphic_info[graphic].offset_x;
+ int offset_y = new_graphic_info[graphic].offset_y;
- if (new_graphic_info[graphic].anim_vertical)
- src_y += frame * TILEY;
- else
- src_x += frame * TILEX;
+ src_x += frame * offset_x;
+ src_y += frame * offset_y;
BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
}
GC drawing_gc = src_bitmap->stored_clip_gc;
int src_x = new_graphic_info[graphic].src_x;
int src_y = new_graphic_info[graphic].src_y;
+ int offset_x = new_graphic_info[graphic].offset_x;
+ int offset_y = new_graphic_info[graphic].offset_y;
- if (new_graphic_info[graphic].anim_vertical)
- src_y += frame * TILEY;
- else
- src_x += frame * TILEX;
+ src_x += frame * offset_x;
+ src_y += frame * offset_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, 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 DrawNewMiniGraphic(int x, int y, int graphic)
+{
+ DrawNewMiniGraphicExt(drawto,
+ SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic);
+ MarkTileDirty(x / 2, y / 2);
}
void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
}
}
+void getNewMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
+{
+ Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+ int mini_startx = 0;
+ int mini_starty = src_bitmap->height * 2 / 3;
+ int src_x = mini_startx + new_graphic_info[graphic].src_x / 2;
+ int src_y = mini_starty + new_graphic_info[graphic].src_y / 2;
+
+ *bitmap = src_bitmap;
+ *x = src_x;
+ *y = src_y;
+}
+
void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
{
Bitmap *bitmap;
BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
}
+void DrawNewMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
+{
+#if 1
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+
+ getNewMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+#else
+ Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+ int mini_startx = src_bitmap->width * 2 / 3;
+ int mini_starty = src_bitmap->height * 2 / 3;
+ int src_x = mini_startx + new_graphic_info[graphic].src_x / 2;
+ int src_y = mini_starty + new_graphic_info[graphic].src_y / 2;
+#endif
+
+ 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 cut_mode, int mask_mode)
{
GC drawing_gc;
int src_x;
int src_y;
+ int offset_x;
+ int offset_y;
int width = TILEX, height = TILEY;
int cx = 0, cy = 0;
drawing_gc = src_bitmap->stored_clip_gc;
src_x = new_graphic_info[graphic].src_x;
src_y = new_graphic_info[graphic].src_y;
+ offset_x = new_graphic_info[graphic].offset_x;
+ offset_y = new_graphic_info[graphic].offset_y;
- if (new_graphic_info[graphic].anim_vertical)
- src_y += frame * TILEY;
- else
- src_x += frame * TILEX;
+ src_x += frame * offset_x;
+ src_y += frame * offset_y;
src_x += cx;
src_y += cy;
}
else if (element == EL_SP_ELECTRON)
{
- graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_NORMAL);
+ graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_LOOP);
}
else if (element == EL_MOLE || element == EL_PENGUIN ||
element == EL_PIG || element == EL_DRAGON)
}
else if (element == EL_SATELLITE)
{
- graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_NORMAL);
+ graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_LOOP);
}
else if (element == EL_ACID)
{
- graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_NORMAL);
+ graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_LOOP);
}
else if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
{
DrawGraphic(x, y, graphic);
}
+inline static int getFramePosition(int x, int y)
+{
+ int element = Feld[x][y];
+ int frame_pos = -1;
+
+ 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);
+
+ return frame_pos;
+}
+
+inline static int getGfxAction(int x, int y)
+{
+ int gfx_action = GFX_ACTION_DEFAULT;
+
+ if (GfxAction[x][y] != GFX_ACTION_DEFAULT)
+ gfx_action = GfxAction[x][y];
+ else if (IS_MOVING(x, y))
+ gfx_action = GFX_ACTION_MOVING;
+
+ return gfx_action;
+}
+
void DrawNewScreenElementExt(int x, int y, int dx, int dy, int element,
- int cut_mode, int mask_mode)
+ int cut_mode, int mask_mode)
{
int ux = LEVELX(x), uy = LEVELY(y);
int move_dir = MovDir[ux][uy];
- int move_pos = ABS(MovPos[ux][uy]) / (TILEX / 8);
- int gfx_action = (IS_MOVING(ux,uy) ? GFX_ACTION_MOVING : GFX_ACTION_DEFAULT);
+ int move_pos = getFramePosition(ux, uy);
+ int gfx_action = getGfxAction(ux, uy);
int graphic = el_dir_act2img(element, move_dir, gfx_action);
int frame = getNewGraphicAnimationFrame(graphic, move_pos);
-#if 0
- int phase8 = move_pos;
- int phase4 = phase8 / 2;
- int phase2 = phase8 / 4;
-#endif
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(ux - 1, uy) || IS_MAUER(Feld[ux - 1][uy]))
left_stopped = TRUE;
- if (!IN_LEV_FIELD(ux+1, uy) || IS_MAUER(Feld[ux+1][uy]))
+ if (!IN_LEV_FIELD(ux + 1, uy) || IS_MAUER(Feld[ux + 1][uy]))
right_stopped = TRUE;
if (left_stopped && right_stopped)
graphic = IMG_WALL;
else if (left_stopped)
+ {
graphic = IMG_WALL_GROWING_ACTIVE_RIGHT;
+ frame = new_graphic_info[graphic].anim_frames - 1;
+ }
else if (right_stopped)
+ {
graphic = IMG_WALL_GROWING_ACTIVE_LEFT;
+ frame = new_graphic_info[graphic].anim_frames - 1;
+ }
}
#if 0
else if ((element == EL_ROCK ||
graphic += phase2;
}
}
+#endif
else if (IS_AMOEBOID(element) || element == EL_AMOEBA_DRIPPING)
{
- graphic = (element == EL_AMOEBA_DEAD ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
+ graphic = (element == EL_BD_AMOEBA ? IMG_BD_AMOEBA_PART1 :
+ element == EL_AMOEBA_WET ? IMG_AMOEBA_WET_PART1 :
+ element == EL_AMOEBA_DRY ? IMG_AMOEBA_DRY_PART1 :
+ element == EL_AMOEBA_FULL ? IMG_AMOEBA_FULL_PART1 :
+ IMG_AMOEBA_DEAD_PART1);
+
graphic += (x + 2 * y + 4) % 4;
}
-#endif
if (dx || dy)
DrawNewGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
DrawMiniGraphic(x, y, graphic);
}
+void DrawNewMiniElement(int x, int y, int element)
+{
+ int graphic;
+
+#if 0
+ if (!element)
+ {
+ DrawNewMiniGraphic(x, y, -1);
+ return;
+ }
+#endif
+
+ graphic = el2img(element);
+ DrawNewMiniGraphic(x, y, graphic);
+}
+
void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
{
int x = sx + scroll_x, y = sy + scroll_y;
}
}
+void DrawNewMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
+{
+ int x = sx + scroll_x, y = sy + scroll_y;
+
+ if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
+ DrawNewMiniElement(sx, sy, EL_EMPTY);
+ else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
+ DrawNewMiniElement(sx, sy, Feld[x][y]);
+ else
+ {
+ int steel_type, steel_position;
+ int border[6][2] =
+ {
+ { IMG_STEELWALL_TOPLEFT, IMG_INVISIBLE_STEELWALL_TOPLEFT },
+ { IMG_STEELWALL_TOPRIGHT, IMG_INVISIBLE_STEELWALL_TOPRIGHT },
+ { IMG_STEELWALL_BOTTOMLEFT, IMG_INVISIBLE_STEELWALL_BOTTOMLEFT },
+ { IMG_STEELWALL_BOTTOMRIGHT, IMG_INVISIBLE_STEELWALL_BOTTOMRIGHT },
+ { IMG_STEELWALL_VERTICAL, IMG_INVISIBLE_STEELWALL_VERTICAL },
+ { IMG_STEELWALL_HORIZONTAL, IMG_INVISIBLE_STEELWALL_HORIZONTAL }
+ };
+
+ steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
+ steel_position = (x == -1 && y == -1 ? 0 :
+ x == lev_fieldx && y == -1 ? 1 :
+ x == -1 && y == lev_fieldy ? 2 :
+ x == lev_fieldx && y == lev_fieldy ? 3 :
+ x == -1 || x == lev_fieldx ? 4 :
+ y == -1 || y == lev_fieldy ? 5 : -1);
+
+ if (steel_position != -1)
+ DrawNewMiniGraphic(sx, sy, border[steel_position][steel_type]);
+ }
+}
+
void DrawMicroElement(int xpos, int ypos, int element)
{
int graphic;
MICRO_TILEX, MICRO_TILEY, xpos, ypos);
}
+void getNewMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
+{
+ Bitmap *src_bitmap = new_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 + new_graphic_info[graphic].src_x / 8;
+ int src_y = mini_starty + new_graphic_info[graphic].src_y / 8;
+
+ *bitmap = src_bitmap;
+ *x = src_x;
+ *y = src_y;
+}
+
+void DrawNewMicroElement(int xpos, int ypos, int element)
+{
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+ int graphic;
+
+ if (element == EL_EMPTY)
+ return;
+
+ graphic = el2img(element);
+
+ getNewMicroGraphicSource(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;
for(x=BX1; x<=BX2; x++)
for(y=BY1; y<=BY2; y++)
- DrawScreenField(x, y);
+ DrawNewScreenField(x, y);
redraw_mask |= REDRAW_FIELD;
}
redraw_mask |= REDRAW_FIELD;
}
+void DrawNewMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
+{
+ int x,y;
+
+ for(x=0; x<size_x; x++)
+ for(y=0; y<size_y; y++)
+ DrawNewMiniElementOrWall(x, y, scroll_x, scroll_y);
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
static void DrawMicroLevelExt(int xpos, int ypos, int from_x, int from_y)
{
int x, y;
redraw_mask |= REDRAW_MICROLEVEL;
}
+static void DrawNewMicroLevelExt(int xpos, int ypos, int from_x, int from_y)
+{
+ int x, y;
+
+ ClearRectangle(drawto, xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
+
+ 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;
+
+ xpos += MICRO_TILEX;
+ ypos += MICRO_TILEY;
+
+ for(x=-1; x<=STD_LEV_FIELDX; x++)
+ {
+ for(y=-1; y<=STD_LEV_FIELDY; y++)
+ {
+ int lx = from_x + x, ly = from_y + y;
+
+ if (lx >= 0 && lx < lev_fieldx && ly >= 0 && ly < lev_fieldy)
+ DrawNewMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
+ Ur[lx][ly]);
+ else if (lx >= -1 && lx < lev_fieldx+1 && ly >= -1 && ly < lev_fieldy+1)
+ DrawNewMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
+ BorderElement);
+ }
+ }
+
+ redraw_mask |= REDRAW_MICROLEVEL;
+}
+
#define MICROLABEL_EMPTY 0
#define MICROLABEL_LEVEL_NAME 1
#define MICROLABEL_CREATED_BY 2
label_state = 1;
label_counter = 0;
- DrawMicroLevelExt(xpos, ypos, from_x, from_y);
+ DrawNewMicroLevelExt(xpos, ypos, from_x, from_y);
DrawMicroLevelLabelExt(label_state);
/* initialize delay counters */
#if 1
int graphic_NEW = element_info[element].graphic[GFX_ACTION_DEFAULT];
+#if DEBUG
+ if (graphic_NEW < 0)
+ Error(ERR_WARN, "element %d -> graphic %d -- probably crashing now...",
+ element, graphic_NEW);
+#endif
+
return graphic_NEW;
#else
break;
}
- return IMG_EMPTY_SPACE;
+ return IMG_EMPTY;
#endif
}
projects / rocksndiamonds.git / blobdiff