void DrawMaskedBorder_FIELD()
{
- if (game_status >= GAME_MODE_TITLE &&
- game_status <= GAME_MODE_PLAYING &&
- border.draw_masked[game_status])
+ if (global.border_status >= GAME_MODE_TITLE &&
+ global.border_status <= GAME_MODE_PLAYING &&
+ border.draw_masked[global.border_status])
DrawMaskedBorder_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
}
void DrawMaskedBorder_DOOR_1()
{
if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
- (game_status != GAME_MODE_EDITOR ||
+ (global.border_status != GAME_MODE_EDITOR ||
border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
DrawMaskedBorder_Rect(DX, DY, DXSIZE, DYSIZE);
}
void DrawMaskedBorder_DOOR_2()
{
if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
- game_status != GAME_MODE_EDITOR)
+ global.border_status != GAME_MODE_EDITOR)
DrawMaskedBorder_Rect(VX, VY, VXSIZE, VYSIZE);
}
#if 1
if (global.autoplay_leveldir)
- fading.fade_mode = FADE_MODE_NONE;
+ {
+ // fading.fade_mode = FADE_MODE_NONE;
+
+ return;
+ }
#endif
#if 1
if (fading.fade_mode == FADE_MODE_NONE)
+ {
+ BackToFront();
+
return;
+ }
#endif
if (fade_mask & REDRAW_FIELD)
fade_delay = fading.fade_delay;
post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
- draw_border_function = DrawMaskedBorder_FIELD;
+ if (border.draw_masked_when_fading)
+ draw_border_function = DrawMaskedBorder_FIELD; /* update when fading */
+ else
+ DrawMaskedBorder_FIELD(); /* draw once */
}
else /* REDRAW_ALL */
{
void FadeIn(int fade_mask)
{
+#if 0
+ global.border_status = game_status;
+#endif
+
+#if 0
+ global.fading_status = game_status;
+
+ if (global.fading_type == TYPE_ENTER_MENU)
+ fading = menu.enter_menu;
+ else if (global.fading_type == TYPE_LEAVE_MENU)
+ fading = menu.leave_menu;
+ else if (global.fading_type == TYPE_ENTER_SCREEN)
+ fading = menu.enter_screen[global.fading_status];
+ else if (global.fading_type == TYPE_LEAVE_SCREEN)
+ fading = menu.leave_screen[global.fading_status];
+
+ printf("::: FadeIn: %s [0x%08x] [%d]\n",
+ global.fading_type == TYPE_ENTER_MENU ? "enter_menu" :
+ global.fading_type == TYPE_LEAVE_MENU ? "leave_menu" :
+ global.fading_type == TYPE_ENTER_SCREEN ? "enter_screen" :
+ global.fading_type == TYPE_LEAVE_SCREEN ? "leave_screen" : "(?)",
+ global.fading_type,
+ global.fading_status);
+#endif
+
#if 1
// printf("::: now fading in...\n");
void FadeOut(int fade_mask)
{
+#if 0
+ if (global.fading_type == TYPE_ENTER_MENU)
+ fading = menu.enter_menu;
+ else if (global.fading_type == TYPE_LEAVE_MENU)
+ fading = menu.leave_menu;
+ else if (global.fading_type == TYPE_ENTER_SCREEN)
+ fading = menu.enter_screen[global.fading_status];
+ else if (global.fading_type == TYPE_LEAVE_SCREEN)
+ fading = menu.leave_screen[global.fading_status];
+
+ printf("::: FadeOut: %s [0x%08x] [%d]\n",
+ global.fading_type == TYPE_ENTER_MENU ? "enter_menu" :
+ global.fading_type == TYPE_LEAVE_MENU ? "leave_menu" :
+ global.fading_type == TYPE_ENTER_SCREEN ? "enter_screen" :
+ global.fading_type == TYPE_LEAVE_SCREEN ? "leave_screen" : "(?)",
+ global.fading_type,
+ global.fading_status);
+#endif
+
#if 1
// printf("::: fading.fade_mode == %d\n", fading.fade_mode);
FadeExt(fade_mask, FADE_MODE_FADE_OUT);
#endif
#endif
+
+#if 1
+ global.border_status = game_status;
+#endif
}
void FadeCross(int fade_mask)
BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
}
+#if 0
+void FadeSetEnterMenu()
+{
+ global.fading_type = TYPE_ENTER_MENU;
+}
+
+void FadeSetLeaveMenu()
+{
+ global.fading_type = TYPE_LEAVE_MENU;
+}
+
+void FadeSetEnterScreen()
+{
+ global.fading_type = TYPE_ENTER_SCREEN;
+}
+
+void FadeSetLeaveScreen()
+{
+ // global.fading_type = TYPE_LEAVE_SCREEN;
+
+ global.fading_type = (global.fading_type == TYPE_ENTER_SCREEN ?
+ TYPE_LEAVE_SCREEN : TYPE_LEAVE_MENU);
+}
+
+#else
+
static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
{
static struct TitleFadingInfo fading_leave_stored;
{
fading = menu.enter_menu;
+#if 0
+ printf("::: storing enter_menu\n");
+#endif
+
FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
{
fading = menu.leave_menu;
+#if 0
+ printf("::: storing leave_menu\n");
+#endif
+
FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
{
fading = menu.enter_screen[game_status];
+#if 0
+ printf("::: storing leave_screen[%d]\n", game_status);
+#endif
+
+#if 0
+ printf("::: - %d, %d / %d, %d\n",
+ menu.enter_screen[game_status].fade_mode,
+ menu.enter_screen[game_status].fade_delay,
+ menu.leave_screen[game_status].fade_mode,
+ menu.leave_screen[game_status].fade_delay);
+#endif
+
FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); /* store */
}
void FadeSetLeaveScreen()
{
+#if 0
+ printf("::: recalling last stored value\n");
+#endif
+
FadeSetLeaveNext(menu.leave_screen[game_status], FALSE); /* recall */
}
+#endif
+
void FadeSetFromType(int type)
{
if (type & TYPE_ENTER_SCREEN)
sync_frame);
}
-void getSizedGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y,
- int tilesize_raw)
+void getSizedGraphicSource(int graphic, int frame, int tilesize_raw,
+ Bitmap **bitmap, int *x, int *y)
{
struct
{
{ 0, 1, 2, 3 }, /* 16 x 16 */
{ 0, 1, 0, 1 }, /* 32 x 32 */
};
+ struct GraphicInfo *g = &graphic_info[graphic];
+ Bitmap *src_bitmap = g->bitmap;
int tilesize = MIN(MAX(1, tilesize_raw), TILESIZE);
int offset_calc_pos = log_2(tilesize);
- Bitmap *src_bitmap = graphic_info[graphic].bitmap;
int width_mult = offset_calc[offset_calc_pos].width_mult;
int width_div = offset_calc[offset_calc_pos].width_div;
int height_mult = offset_calc[offset_calc_pos].height_mult;
int height_div = offset_calc[offset_calc_pos].height_div;
int startx = src_bitmap->width * width_mult / width_div;
int starty = src_bitmap->height * height_mult / height_div;
- int src_x = startx + graphic_info[graphic].src_x * tilesize / TILESIZE;
- int src_y = starty + graphic_info[graphic].src_y * tilesize / TILESIZE;
+ int src_x = g->src_x * tilesize / TILESIZE;
+ int src_y = g->src_y * tilesize / TILESIZE;
+ int width = g->width * tilesize / TILESIZE;
+ int height = g->height * tilesize / TILESIZE;
+ int offset_x = g->offset_x * tilesize / TILESIZE;
+ int offset_y = g->offset_y * tilesize / TILESIZE;
+
+ if (g->offset_y == 0) /* frames are ordered horizontally */
+ {
+ int max_width = g->anim_frames_per_line * width;
+ int pos = (src_y / height) * max_width + src_x + frame * offset_x;
+
+ src_x = pos % max_width;
+ src_y = src_y % height + pos / max_width * height;
+ }
+ else if (g->offset_x == 0) /* frames are ordered vertically */
+ {
+ int max_height = g->anim_frames_per_line * height;
+ int pos = (src_x / width) * max_height + src_y + frame * offset_y;
+
+ src_x = src_x % width + pos / max_height * width;
+ src_y = pos % max_height;
+ }
+ else /* frames are ordered diagonally */
+ {
+ src_x = src_x + frame * offset_x;
+ src_y = src_y + frame * offset_y;
+ }
*bitmap = src_bitmap;
- *x = src_x;
- *y = src_y;
+ *x = startx + src_x;
+ *y = starty + src_y;
}
void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
{
#if 1
- getSizedGraphicSource(graphic, bitmap, x, y, MINI_TILESIZE);
+ getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
#else
struct GraphicInfo *g = &graphic_info[graphic];
int mini_startx = 0;
BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dst_x, dst_y);
}
-void DrawSizedGraphic(int x, int y, int graphic, int tilesize)
+void DrawSizedGraphic(int x, int y, int graphic, int frame, int tilesize)
{
DrawSizedGraphicExt(drawto, SX + x * tilesize, SY + y * tilesize, graphic,
- tilesize);
+ frame, tilesize);
MarkTileDirty(x / tilesize, y / tilesize);
}
-void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int tilesize)
+void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int frame,
+ int tilesize)
{
Bitmap *src_bitmap;
int src_x, src_y;
- getSizedGraphicSource(graphic, &src_bitmap, &src_x, &src_y, tilesize);
+ getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
BlitBitmap(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
}
int src_x, src_y;
int graphic = el2preimg(element);
- getSizedGraphicSource(graphic, &src_bitmap, &src_x, &src_y, tilesize);
+ getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize, dst_x,dst_y);
}
if (game_status == GAME_MODE_PLAYING && local_player->LevelSolved_GameEnd)
{
HandleGameActions();
- BackToFront();
}
else
{
Delay(10);
}
+ BackToFront();
+
#else
DoAnimation();
return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
}
-int el2doorimg(int element)
+int el2panelimg(int element)
{
element = GFX_ELEMENT(element);
- return element_info[element].special_graphic[GFX_SPECIAL_ARG_DOOR];
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
}
int font2baseimg(int font_nr)
return belt_move_dir[belt_dir_nr];
}
-int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
+int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
{
static int belt_base_element[4] =
{
EL_CONVEYOR_BELT_3_LEFT,
EL_CONVEYOR_BELT_4_LEFT
};
- int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
return belt_base_element[belt_nr] + belt_dir_nr;
}
-int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
+int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
+{
+ int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
+
+ return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
+}
+
+int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
{
static int belt_base_element[4] =
{
EL_CONVEYOR_BELT_3_SWITCH_LEFT,
EL_CONVEYOR_BELT_4_SWITCH_LEFT
};
- int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
return belt_base_element[belt_nr] + belt_dir_nr;
}
+int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
+{
+ int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
+
+ return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
+}
+
int getNumActivePlayers_EM()
{
int num_players = 0;
GfxFrame[x][y] = 0;
}
+void SetGfxAnimation_EM(int tile, int frame_em, int x, int y)
+{
+#if 0
+ int element = object_mapping[tile].element_rnd;
+#endif
+ int action = object_mapping[tile].action;
+ int direction = object_mapping[tile].direction;
+ boolean is_backside = object_mapping[tile].is_backside;
+ boolean action_removing = (action == ACTION_DIGGING ||
+ action == ACTION_SNAPPING ||
+ action == ACTION_COLLECTING);
+
+#if 0
+ printf("::: SET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+#endif
+
+#if 1
+ if (action_removing)
+ {
+#if 0
+ printf("::: %d, %d: action_removing [%s]\n", x, y, EL_NAME(element));
+#endif
+
+ GfxFrame[x][y] = 7 - frame_em;
+ }
+ else if (action == ACTION_FALLING ||
+ action == ACTION_MOVING ||
+ action == ACTION_PUSHING ||
+ action == ACTION_EATING ||
+ action == ACTION_FILLING ||
+ action == ACTION_EMPTYING)
+ {
+ int move_dir =
+ (action == ACTION_FALLING ||
+ action == ACTION_FILLING ||
+ action == ACTION_EMPTYING ? MV_DOWN : direction);
+
+ if (is_backside)
+ {
+ GfxFrame[x][y]++;
+
+ if (move_dir == MV_LEFT)
+ GfxFrame[x - 1][y] = GfxFrame[x][y];
+ else if (move_dir == MV_RIGHT)
+ GfxFrame[x + 1][y] = GfxFrame[x][y];
+ else if (move_dir == MV_UP)
+ GfxFrame[x][y - 1] = GfxFrame[x][y];
+ else if (move_dir == MV_DOWN)
+ GfxFrame[x][y + 1] = GfxFrame[x][y];
+ }
+
+#if 0
+ printf("::: %d, %d: %s, %d, %d [%d]\n", x, y, EL_NAME(element), is_backside,
+ move_dir, GfxFrame[x][y]);
+#endif
+ }
+ else
+ GfxFrame[x][y]++;
+#else
+ GfxFrame[x][y] = 7 - frame_em;
+#endif
+}
+
void getGraphicSourceObjectExt_EM(int tile, int frame_em,
Bitmap **src_bitmap, int *src_x, int *src_y,
int x, int y)
struct GraphicInfo *g = &graphic_info[graphic];
int sync_frame;
+#if 0
+ printf("::: GET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+#endif
+
+#if 0
+ if (GfxFrame[x][y] < 8)
+ printf("::: %d, %d: %d [%s]\n", x, y, GfxFrame[x][y], EL_NAME(element));
+#endif
+
+#if 1
+ if (graphic_info[graphic].anim_global_sync)
+ sync_frame = FrameCounter;
+ else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
+ sync_frame = GfxFrame[x][y];
+ else
+ sync_frame = 0; /* steel border */
+#else
if (graphic_info[graphic].anim_global_sync)
sync_frame = FrameCounter;
else
sync_frame = 7 - frame_em;
+#endif
SetRandomAnimationValue(x, y);