printf(" MovDir: %d\n", MovDir[x][y]);
printf(" MovDelay: %d\n", MovDelay[x][y]);
printf(" ChangeDelay: %d\n", ChangeDelay[x][y]);
- printf(" Count: %d\n", Count[x][y]);
+ printf(" CustomValue: %d\n", CustomValue[x][y]);
printf(" GfxElement: %d\n", GfxElement[x][y]);
printf(" GfxAction: %d\n", GfxAction[x][y]);
printf(" GfxFrame: %d\n", GfxFrame[x][y]);
IS_MOVING(xx, yy))
continue;
+#if 1
+ if (Feld[xx][yy] == EL_ELEMENT_SNAPPING)
+ continue;
+#endif
+
element = TILE_GFX_ELEMENT(xx, yy);
if (!GFX_CRUMBLED(element))
continue;
#endif
+#if 1
+ graphic = el_act2crm(element, ACTION_DEFAULT);
+#else
graphic = el_act2crm(Feld[xx][yy], ACTION_DEFAULT);
+#endif
crumbled_border_size = graphic_info[graphic].border_size;
getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
if (!IN_LEV_FIELD(x, y))
return;
+#if 1
+ if (Feld[x][y] == EL_ELEMENT_SNAPPING &&
+ GFX_CRUMBLED(GfxElement[x][y]))
+ {
+ DrawLevelFieldCrumbledSandDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
+ return;
+ }
+#endif
+
+#if 1
+ graphic = el_act2crm(TILE_GFX_ELEMENT(x, y), ACTION_DEFAULT);
+#else
graphic = el_act2crm(Feld[x][y], ACTION_DEFAULT);
+#endif
DrawLevelFieldCrumbledSandExt(x, y, graphic, 0);
}
DrawGraphicAnimation(sx, sy, graphic);
+#if 1
+ if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
+ DrawLevelFieldCrumbledSand(x, y);
+#else
if (GFX_CRUMBLED(Feld[x][y]))
DrawLevelFieldCrumbledSand(x, y);
+#endif
}
void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
{
- if (player->use_murphy_graphic)
+ if (player->use_murphy)
{
/* this works only because currently only one player can be "murphy" ... */
static int last_horizontal_dir = MV_LEFT;
return graphic;
}
else
- return el_act_dir2img(player->element_nr, player->GfxAction, move_dir);
+ return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
}
static boolean equalGraphics(int graphic1, int graphic2)
{
GfxElement[jx][jy] = EL_UNDEFINED;
+ /* make sure that pushed elements are drawn with correct frame rate */
+ if (player->is_pushing && player->is_moving)
+ GfxFrame[jx][jy] = player->StepFrame;
+
DrawLevelField(jx, jy);
}
}
player->is_moving, player_is_moving);
#endif
+#if 1
if (player->is_pushing && player->is_moving)
{
int px = SCREENX(jx), py = SCREENY(jy);
/* masked drawing is needed for EMC style (double) movement graphics */
DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
}
+#endif
/* ----------------------------------------------------------------------- */
/* draw things in front of player (active dynamite or dynabombs) */
return EL_UNKNOWN;
}
+void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
+{
+ struct LevelInfo_EM *level_em = level->native_em_level;
+ struct LEVEL *lev = level_em->lev;
+ int i, j;
+
+ for (i = 0; i < level->num_android_clone_elements; i++)
+ {
+ int element_rnd = level->android_clone_element[i];
+ int element_em = map_element_RND_to_EM(element_rnd);
+
+ for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
+ if (em_object_mapping_list[j].element_rnd == element_rnd)
+ lev->android_array[em_object_mapping_list[j].element_em] = element_em;
+ }
+}
+
+void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
+{
+ struct LevelInfo_EM *level_em = level->native_em_level;
+ struct LEVEL *lev = level_em->lev;
+ int i, j;
+
+ level->num_android_clone_elements = 0;
+
+ for (i = 0; i < TILE_MAX; i++)
+ {
+ int element_em = lev->android_array[i];
+ int element_rnd;
+ boolean element_found = FALSE;
+
+ if (element_em == Xblank)
+ continue;
+
+ element_rnd = map_element_EM_to_RND(element_em);
+
+ for (j = 0; j < level->num_android_clone_elements; j++)
+ if (level->android_clone_element[j] == element_rnd)
+ element_found = TRUE;
+
+ if (!element_found)
+ {
+ level->android_clone_element[level->num_android_clone_elements++] =
+ element_rnd;
+
+ if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
+ break;
+ }
+ }
+
+ if (level->num_android_clone_elements == 0)
+ {
+ level->num_android_clone_elements = 1;
+ level->android_clone_element[0] = EL_EMPTY;
+ }
+}
+
#if 0
int map_element_RND_to_EM(int element_rnd)
#endif
+int map_direction_RND_to_EM(int direction)
+{
+ return (direction == MV_UP ? 0 :
+ direction == MV_RIGHT ? 1 :
+ direction == MV_DOWN ? 2 :
+ direction == MV_LEFT ? 3 :
+ -1);
+}
+
+int map_direction_EM_to_RND(int direction)
+{
+ return (direction == 0 ? MV_UP :
+ direction == 1 ? MV_RIGHT :
+ direction == 2 ? MV_DOWN :
+ direction == 3 ? MV_LEFT :
+ MV_NONE);
+}
+
int get_next_element(int element)
{
switch(element)
{
element = GFX_ELEMENT(element);
- if (direction == MV_NO_MOVING)
+ if (direction == MV_NONE)
return element_info[element].graphic[action];
direction = MV_DIR_BIT(direction);
int el_act_dir2img(int element, int action, int direction)
{
element = GFX_ELEMENT(element);
- direction = MV_DIR_BIT(direction); /* default: MV_NO_MOVING => MV_DOWN */
+ direction = MV_DIR_BIT(direction); /* default: MV_NONE => MV_DOWN */
/* direction_graphic[][] == graphic[] for undefined direction graphics */
return element_info[element].direction_graphic[action][direction];
{
element = GFX_ELEMENT(element);
- if (direction == MV_NO_MOVING)
+ if (direction == MV_NONE)
return element_info[element].crumbled[action];
direction = MV_DIR_BIT(direction);
static int el_act_dir2crm(int element, int action, int direction)
{
element = GFX_ELEMENT(element);
- direction = MV_DIR_BIT(direction); /* default: MV_NO_MOVING => MV_DOWN */
+ direction = MV_DIR_BIT(direction); /* default: MV_NONE => MV_DOWN */
/* direction_graphic[][] == graphic[] for undefined direction graphics */
return element_info[element].direction_crumbled[action][direction];
return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
}
+int font2baseimg(int font_nr)
+{
+ return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
+}
+
int getGameFrameDelay_EM(int native_em_game_frame_delay)
{
int game_frame_delay_value;
object_mapping[i].element_rnd = EL_UNKNOWN;
object_mapping[i].is_backside = FALSE;
object_mapping[i].action = ACTION_DEFAULT;
- object_mapping[i].direction = MV_NO_MOVING;
+ object_mapping[i].direction = MV_NONE;
}
/* always start with reliable default values */
{
player_mapping[p][i].element_rnd = EL_UNKNOWN;
player_mapping[p][i].action = ACTION_DEFAULT;
- player_mapping[p][i].direction = MV_NO_MOVING;
+ player_mapping[p][i].direction = MV_NONE;
}
}
{
int effective_element = element;
int effective_action = action;
- int graphic = (direction == MV_NO_MOVING ?
+ int graphic = (direction == MV_NONE ?
el_act2img(effective_element, effective_action) :
el_act_dir2img(effective_element, effective_action,
direction));
projects / rocksndiamonds.git / blobdiff