From: Holger Schemel Date: Sun, 14 May 2023 22:04:43 +0000 (+0200) Subject: added flipping and rotating tiles in brushes in level editor X-Git-Tag: 4.3.6.0~21 X-Git-Url: https://git.artsoft.org/?a=commitdiff_plain;h=34b1ec9d816877389df293fb4f9ec10cc2a43729;p=rocksndiamonds.git added flipping and rotating tiles in brushes in level editor --- diff --git a/src/editor.c b/src/editor.c index b0eb01b4..c0168923 100644 --- a/src/editor.c +++ b/src/editor.c @@ -12356,10 +12356,308 @@ static void SelectArea(int from_x, int from_y, int to_x, int to_y, MAX_CB_NUM_LINES * \ MAX_CB_PART_SIZE) -static short getFlippedTile(short tile, int mode) +static int getFlippedTileX(int element) { - // flip tile (yet to be added) - return tile; + switch (element) + { + case EL_BD_BUTTERFLY_LEFT: return EL_BD_BUTTERFLY_RIGHT; + case EL_BD_BUTTERFLY_RIGHT: return EL_BD_BUTTERFLY_LEFT; + + case EL_BD_FIREFLY_LEFT: return EL_BD_FIREFLY_RIGHT; + case EL_BD_FIREFLY_RIGHT: return EL_BD_FIREFLY_LEFT; + + case EL_BUG_LEFT: return EL_BUG_RIGHT; + case EL_BUG_RIGHT: return EL_BUG_LEFT; + + case EL_SPACESHIP_LEFT: return EL_SPACESHIP_RIGHT; + case EL_SPACESHIP_RIGHT: return EL_SPACESHIP_LEFT; + + case EL_PACMAN_LEFT: return EL_PACMAN_RIGHT; + case EL_PACMAN_RIGHT: return EL_PACMAN_LEFT; + + case EL_ARROW_LEFT: return EL_ARROW_RIGHT; + case EL_ARROW_RIGHT: return EL_ARROW_LEFT; + + case EL_MOLE_LEFT: return EL_MOLE_RIGHT; + case EL_MOLE_RIGHT: return EL_MOLE_LEFT; + + case EL_BALLOON_SWITCH_LEFT: return EL_BALLOON_SWITCH_RIGHT; + case EL_BALLOON_SWITCH_RIGHT: return EL_BALLOON_SWITCH_LEFT; + + case EL_YAMYAM_LEFT: return EL_YAMYAM_RIGHT; + case EL_YAMYAM_RIGHT: return EL_YAMYAM_LEFT; + + case EL_SP_PORT_LEFT: return EL_SP_PORT_RIGHT; + case EL_SP_PORT_RIGHT: return EL_SP_PORT_LEFT; + + case EL_SP_GRAVITY_PORT_LEFT: return EL_SP_GRAVITY_PORT_RIGHT; + case EL_SP_GRAVITY_PORT_RIGHT: return EL_SP_GRAVITY_PORT_LEFT; + + case EL_SP_GRAVITY_ON_PORT_LEFT: return EL_SP_GRAVITY_ON_PORT_RIGHT; + case EL_SP_GRAVITY_ON_PORT_RIGHT: return EL_SP_GRAVITY_ON_PORT_LEFT; + + case EL_SP_GRAVITY_OFF_PORT_LEFT: return EL_SP_GRAVITY_OFF_PORT_RIGHT; + case EL_SP_GRAVITY_OFF_PORT_RIGHT: return EL_SP_GRAVITY_OFF_PORT_LEFT; + + case EL_CONVEYOR_BELT_1_LEFT: return EL_CONVEYOR_BELT_1_RIGHT; + case EL_CONVEYOR_BELT_1_RIGHT: return EL_CONVEYOR_BELT_1_LEFT; + + case EL_CONVEYOR_BELT_2_LEFT: return EL_CONVEYOR_BELT_2_RIGHT; + case EL_CONVEYOR_BELT_2_RIGHT: return EL_CONVEYOR_BELT_2_LEFT; + + case EL_CONVEYOR_BELT_3_LEFT: return EL_CONVEYOR_BELT_3_RIGHT; + case EL_CONVEYOR_BELT_3_RIGHT: return EL_CONVEYOR_BELT_3_LEFT; + + case EL_CONVEYOR_BELT_4_LEFT: return EL_CONVEYOR_BELT_4_RIGHT; + case EL_CONVEYOR_BELT_4_RIGHT: return EL_CONVEYOR_BELT_4_LEFT; + + case EL_SPRING_LEFT: return EL_SPRING_RIGHT; + case EL_SPRING_RIGHT: return EL_SPRING_LEFT; + + case EL_SP_CHIP_LEFT: return EL_SP_CHIP_RIGHT; + case EL_SP_CHIP_RIGHT: return EL_SP_CHIP_LEFT; + + case EL_TUBE_VERTICAL_LEFT: return EL_TUBE_VERTICAL_RIGHT; + case EL_TUBE_VERTICAL_RIGHT: return EL_TUBE_VERTICAL_LEFT; + case EL_TUBE_LEFT_UP: return EL_TUBE_RIGHT_UP; + case EL_TUBE_LEFT_DOWN: return EL_TUBE_RIGHT_DOWN; + case EL_TUBE_RIGHT_UP: return EL_TUBE_LEFT_UP; + case EL_TUBE_RIGHT_DOWN: return EL_TUBE_LEFT_DOWN; + + case EL_DC_STEELWALL_1_LEFT: return EL_DC_STEELWALL_1_RIGHT; + case EL_DC_STEELWALL_1_RIGHT: return EL_DC_STEELWALL_1_LEFT; + case EL_DC_STEELWALL_1_TOPLEFT: return EL_DC_STEELWALL_1_TOPRIGHT; + case EL_DC_STEELWALL_1_TOPRIGHT: return EL_DC_STEELWALL_1_TOPLEFT; + case EL_DC_STEELWALL_1_BOTTOMLEFT: return EL_DC_STEELWALL_1_BOTTOMRIGHT; + case EL_DC_STEELWALL_1_BOTTOMRIGHT: return EL_DC_STEELWALL_1_BOTTOMLEFT; + case EL_DC_STEELWALL_1_TOPLEFT_2: return EL_DC_STEELWALL_1_TOPRIGHT_2; + case EL_DC_STEELWALL_1_TOPRIGHT_2: return EL_DC_STEELWALL_1_TOPLEFT_2; + case EL_DC_STEELWALL_1_BOTTOMLEFT_2: return EL_DC_STEELWALL_1_BOTTOMRIGHT_2; + case EL_DC_STEELWALL_1_BOTTOMRIGHT_2: return EL_DC_STEELWALL_1_BOTTOMLEFT_2; + + case EL_DC_STEELWALL_2_LEFT: return EL_DC_STEELWALL_2_RIGHT; + case EL_DC_STEELWALL_2_RIGHT: return EL_DC_STEELWALL_2_LEFT; + + case EL_ACID_POOL_TOPLEFT: return EL_ACID_POOL_TOPRIGHT; + case EL_ACID_POOL_TOPRIGHT: return EL_ACID_POOL_TOPLEFT; + case EL_ACID_POOL_BOTTOMLEFT: return EL_ACID_POOL_BOTTOMRIGHT; + case EL_ACID_POOL_BOTTOMRIGHT: return EL_ACID_POOL_BOTTOMLEFT; + } + + return element; +} + +static int getFlippedTileY(int element) +{ + switch (element) + { + case EL_BD_BUTTERFLY_UP: return EL_BD_BUTTERFLY_DOWN; + case EL_BD_BUTTERFLY_DOWN: return EL_BD_BUTTERFLY_UP; + + case EL_BD_FIREFLY_UP: return EL_BD_FIREFLY_DOWN; + case EL_BD_FIREFLY_DOWN: return EL_BD_FIREFLY_UP; + + case EL_BUG_UP: return EL_BUG_DOWN; + case EL_BUG_DOWN: return EL_BUG_UP; + + case EL_SPACESHIP_UP: return EL_SPACESHIP_DOWN; + case EL_SPACESHIP_DOWN: return EL_SPACESHIP_UP; + + case EL_PACMAN_UP: return EL_PACMAN_DOWN; + case EL_PACMAN_DOWN: return EL_PACMAN_UP; + + case EL_ARROW_UP: return EL_ARROW_DOWN; + case EL_ARROW_DOWN: return EL_ARROW_UP; + + case EL_MOLE_UP: return EL_MOLE_DOWN; + case EL_MOLE_DOWN: return EL_MOLE_UP; + + case EL_BALLOON_SWITCH_UP: return EL_BALLOON_SWITCH_DOWN; + case EL_BALLOON_SWITCH_DOWN: return EL_BALLOON_SWITCH_UP; + + case EL_YAMYAM_UP: return EL_YAMYAM_DOWN; + case EL_YAMYAM_DOWN: return EL_YAMYAM_UP; + + case EL_SP_PORT_UP: return EL_SP_PORT_DOWN; + case EL_SP_PORT_DOWN: return EL_SP_PORT_UP; + + case EL_SP_GRAVITY_PORT_UP: return EL_SP_GRAVITY_PORT_DOWN; + case EL_SP_GRAVITY_PORT_DOWN: return EL_SP_GRAVITY_PORT_UP; + + case EL_SP_GRAVITY_ON_PORT_UP: return EL_SP_GRAVITY_ON_PORT_DOWN; + case EL_SP_GRAVITY_ON_PORT_DOWN: return EL_SP_GRAVITY_ON_PORT_UP; + + case EL_SP_GRAVITY_OFF_PORT_UP: return EL_SP_GRAVITY_OFF_PORT_DOWN; + case EL_SP_GRAVITY_OFF_PORT_DOWN: return EL_SP_GRAVITY_OFF_PORT_UP; + + case EL_SP_CHIP_TOP: return EL_SP_CHIP_BOTTOM; + case EL_SP_CHIP_BOTTOM: return EL_SP_CHIP_TOP; + + case EL_TUBE_HORIZONTAL_UP: return EL_TUBE_HORIZONTAL_DOWN; + case EL_TUBE_HORIZONTAL_DOWN: return EL_TUBE_HORIZONTAL_UP; + case EL_TUBE_LEFT_UP: return EL_TUBE_LEFT_DOWN; + case EL_TUBE_LEFT_DOWN: return EL_TUBE_LEFT_UP; + case EL_TUBE_RIGHT_UP: return EL_TUBE_RIGHT_DOWN; + case EL_TUBE_RIGHT_DOWN: return EL_TUBE_RIGHT_UP; + + case EL_DC_STEELWALL_1_TOP: return EL_DC_STEELWALL_1_BOTTOM; + case EL_DC_STEELWALL_1_BOTTOM: return EL_DC_STEELWALL_1_TOP; + case EL_DC_STEELWALL_1_TOPLEFT: return EL_DC_STEELWALL_1_BOTTOMLEFT; + case EL_DC_STEELWALL_1_TOPRIGHT: return EL_DC_STEELWALL_1_BOTTOMRIGHT; + case EL_DC_STEELWALL_1_BOTTOMLEFT: return EL_DC_STEELWALL_1_TOPLEFT; + case EL_DC_STEELWALL_1_BOTTOMRIGHT: return EL_DC_STEELWALL_1_TOPRIGHT; + case EL_DC_STEELWALL_1_TOPLEFT_2: return EL_DC_STEELWALL_1_BOTTOMLEFT_2; + case EL_DC_STEELWALL_1_TOPRIGHT_2: return EL_DC_STEELWALL_1_BOTTOMRIGHT_2; + case EL_DC_STEELWALL_1_BOTTOMLEFT_2: return EL_DC_STEELWALL_1_TOPLEFT_2; + case EL_DC_STEELWALL_1_BOTTOMRIGHT_2: return EL_DC_STEELWALL_1_TOPRIGHT_2; + + case EL_DC_STEELWALL_2_TOP: return EL_DC_STEELWALL_2_BOTTOM; + case EL_DC_STEELWALL_2_BOTTOM: return EL_DC_STEELWALL_2_TOP; + + case EL_EMC_WALL_1: return EL_EMC_WALL_3; + case EL_EMC_WALL_3: return EL_EMC_WALL_1; + } + + return element; +} + +static int getFlippedTileXY(int element) +{ + switch (element) + { + case EL_BD_BUTTERFLY_LEFT: return EL_BD_BUTTERFLY_UP; + case EL_BD_BUTTERFLY_RIGHT: return EL_BD_BUTTERFLY_DOWN; + case EL_BD_BUTTERFLY_UP: return EL_BD_BUTTERFLY_LEFT; + case EL_BD_BUTTERFLY_DOWN: return EL_BD_BUTTERFLY_RIGHT; + + case EL_BD_FIREFLY_LEFT: return EL_BD_FIREFLY_UP; + case EL_BD_FIREFLY_RIGHT: return EL_BD_FIREFLY_DOWN; + case EL_BD_FIREFLY_UP: return EL_BD_FIREFLY_LEFT; + case EL_BD_FIREFLY_DOWN: return EL_BD_FIREFLY_RIGHT; + + case EL_BUG_LEFT: return EL_BUG_UP; + case EL_BUG_RIGHT: return EL_BUG_DOWN; + case EL_BUG_UP: return EL_BUG_LEFT; + case EL_BUG_DOWN: return EL_BUG_RIGHT; + + case EL_SPACESHIP_LEFT: return EL_SPACESHIP_UP; + case EL_SPACESHIP_RIGHT: return EL_SPACESHIP_DOWN; + case EL_SPACESHIP_UP: return EL_SPACESHIP_LEFT; + case EL_SPACESHIP_DOWN: return EL_SPACESHIP_RIGHT; + + case EL_PACMAN_LEFT: return EL_PACMAN_UP; + case EL_PACMAN_RIGHT: return EL_PACMAN_DOWN; + case EL_PACMAN_UP: return EL_PACMAN_LEFT; + case EL_PACMAN_DOWN: return EL_PACMAN_RIGHT; + + case EL_ARROW_LEFT: return EL_ARROW_UP; + case EL_ARROW_RIGHT: return EL_ARROW_DOWN; + case EL_ARROW_UP: return EL_ARROW_LEFT; + case EL_ARROW_DOWN: return EL_ARROW_RIGHT; + + case EL_MOLE_LEFT: return EL_MOLE_UP; + case EL_MOLE_RIGHT: return EL_MOLE_DOWN; + case EL_MOLE_UP: return EL_MOLE_LEFT; + case EL_MOLE_DOWN: return EL_MOLE_RIGHT; + + case EL_BALLOON_SWITCH_LEFT: return EL_BALLOON_SWITCH_UP; + case EL_BALLOON_SWITCH_RIGHT: return EL_BALLOON_SWITCH_DOWN; + case EL_BALLOON_SWITCH_UP: return EL_BALLOON_SWITCH_LEFT; + case EL_BALLOON_SWITCH_DOWN: return EL_BALLOON_SWITCH_RIGHT; + + case EL_YAMYAM_LEFT: return EL_YAMYAM_UP; + case EL_YAMYAM_RIGHT: return EL_YAMYAM_DOWN; + case EL_YAMYAM_UP: return EL_YAMYAM_LEFT; + case EL_YAMYAM_DOWN: return EL_YAMYAM_RIGHT; + + case EL_SP_PORT_LEFT: return EL_SP_PORT_UP; + case EL_SP_PORT_RIGHT: return EL_SP_PORT_DOWN; + case EL_SP_PORT_UP: return EL_SP_PORT_LEFT; + case EL_SP_PORT_DOWN: return EL_SP_PORT_RIGHT; + + case EL_SP_GRAVITY_PORT_LEFT: return EL_SP_GRAVITY_PORT_UP; + case EL_SP_GRAVITY_PORT_RIGHT: return EL_SP_GRAVITY_PORT_DOWN; + case EL_SP_GRAVITY_PORT_UP: return EL_SP_GRAVITY_PORT_LEFT; + case EL_SP_GRAVITY_PORT_DOWN: return EL_SP_GRAVITY_PORT_RIGHT; + + case EL_SP_GRAVITY_ON_PORT_LEFT: return EL_SP_GRAVITY_ON_PORT_UP; + case EL_SP_GRAVITY_ON_PORT_RIGHT: return EL_SP_GRAVITY_ON_PORT_DOWN; + case EL_SP_GRAVITY_ON_PORT_UP: return EL_SP_GRAVITY_ON_PORT_LEFT; + case EL_SP_GRAVITY_ON_PORT_DOWN: return EL_SP_GRAVITY_ON_PORT_RIGHT; + + case EL_SP_GRAVITY_OFF_PORT_LEFT: return EL_SP_GRAVITY_OFF_PORT_UP; + case EL_SP_GRAVITY_OFF_PORT_RIGHT: return EL_SP_GRAVITY_OFF_PORT_DOWN; + case EL_SP_GRAVITY_OFF_PORT_UP: return EL_SP_GRAVITY_OFF_PORT_LEFT; + case EL_SP_GRAVITY_OFF_PORT_DOWN: return EL_SP_GRAVITY_OFF_PORT_RIGHT; + + case EL_SP_CHIP_LEFT: return EL_SP_CHIP_TOP; + case EL_SP_CHIP_RIGHT: return EL_SP_CHIP_BOTTOM; + case EL_SP_CHIP_TOP: return EL_SP_CHIP_LEFT; + case EL_SP_CHIP_BOTTOM: return EL_SP_CHIP_RIGHT; + + case EL_TUBE_VERTICAL: return EL_TUBE_HORIZONTAL; + case EL_TUBE_HORIZONTAL: return EL_TUBE_VERTICAL; + case EL_TUBE_VERTICAL_LEFT: return EL_TUBE_HORIZONTAL_UP; + case EL_TUBE_VERTICAL_RIGHT: return EL_TUBE_HORIZONTAL_DOWN; + case EL_TUBE_HORIZONTAL_UP: return EL_TUBE_VERTICAL_LEFT; + case EL_TUBE_HORIZONTAL_DOWN: return EL_TUBE_VERTICAL_RIGHT; + case EL_TUBE_LEFT_DOWN: return EL_TUBE_RIGHT_UP; + case EL_TUBE_RIGHT_UP: return EL_TUBE_LEFT_DOWN; + + case EL_DC_STEELWALL_1_LEFT: return EL_DC_STEELWALL_1_TOP; + case EL_DC_STEELWALL_1_RIGHT: return EL_DC_STEELWALL_1_BOTTOM; + case EL_DC_STEELWALL_1_TOP: return EL_DC_STEELWALL_1_LEFT; + case EL_DC_STEELWALL_1_BOTTOM: return EL_DC_STEELWALL_1_RIGHT; + case EL_DC_STEELWALL_1_HORIZONTAL: return EL_DC_STEELWALL_1_VERTICAL; + case EL_DC_STEELWALL_1_VERTICAL: return EL_DC_STEELWALL_1_HORIZONTAL; + case EL_DC_STEELWALL_1_TOPRIGHT: return EL_DC_STEELWALL_1_BOTTOMLEFT; + case EL_DC_STEELWALL_1_BOTTOMLEFT: return EL_DC_STEELWALL_1_TOPRIGHT; + case EL_DC_STEELWALL_1_TOPRIGHT_2: return EL_DC_STEELWALL_1_BOTTOMLEFT_2; + case EL_DC_STEELWALL_1_BOTTOMLEFT_2: return EL_DC_STEELWALL_1_TOPRIGHT_2; + + case EL_DC_STEELWALL_2_LEFT: return EL_DC_STEELWALL_2_TOP; + case EL_DC_STEELWALL_2_RIGHT: return EL_DC_STEELWALL_2_BOTTOM; + case EL_DC_STEELWALL_2_TOP: return EL_DC_STEELWALL_2_LEFT; + case EL_DC_STEELWALL_2_BOTTOM: return EL_DC_STEELWALL_2_RIGHT; + case EL_DC_STEELWALL_2_HORIZONTAL: return EL_DC_STEELWALL_2_VERTICAL; + case EL_DC_STEELWALL_2_VERTICAL: return EL_DC_STEELWALL_2_HORIZONTAL; + + case EL_EXPANDABLE_WALL_HORIZONTAL: return EL_EXPANDABLE_WALL_VERTICAL; + case EL_EXPANDABLE_WALL_VERTICAL: return EL_EXPANDABLE_WALL_HORIZONTAL; + + case EL_EXPANDABLE_STEELWALL_HORIZONTAL: return EL_EXPANDABLE_STEELWALL_VERTICAL; + case EL_EXPANDABLE_STEELWALL_VERTICAL: return EL_EXPANDABLE_STEELWALL_HORIZONTAL; + } + + return element; +} + +static int getFlippedTile(int element, int mode) +{ + if (IS_MM_ELEMENT(element)) + { + // get MM game element + element = map_element_RND_to_MM(element); + + // get flipped game element + element = (mode == CB_FLIP_BRUSH_X ? getFlippedTileX_MM(element) : + mode == CB_FLIP_BRUSH_Y ? getFlippedTileY_MM(element) : + mode == CB_FLIP_BRUSH_XY ? getFlippedTileXY_MM(element) : + element); + + // get RND game element again + element = map_element_MM_to_RND(element); + } + else + { + // get flipped game element + element = (mode == CB_FLIP_BRUSH_X ? getFlippedTileX(element) : + mode == CB_FLIP_BRUSH_Y ? getFlippedTileY(element) : + mode == CB_FLIP_BRUSH_XY ? getFlippedTileXY(element) : + element); + } + + return element; } static void SwapFlippedTiles(short *tile1, short *tile2, int mode) @@ -12736,7 +13034,7 @@ static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y, else if (mode == CB_FLIP_BRUSH_X) { for (y = 0; y < brush_height; y++) - for (x = 0; x < brush_width / 2; x++) + for (x = 0; x < (brush_width + 1) / 2; x++) SwapFlippedTiles(&brush_buffer[x][y], &brush_buffer[brush_width - x - 1][y], mode); @@ -12744,7 +13042,7 @@ static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y, } else if (mode == CB_FLIP_BRUSH_Y) { - for (y = 0; y < brush_height / 2; y++) + for (y = 0; y < (brush_height + 1) / 2; y++) for (x = 0; x < brush_width; x++) SwapFlippedTiles(&brush_buffer[x][y], &brush_buffer[x][brush_height - y - 1], mode); @@ -12755,8 +13053,8 @@ static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y, { CopyBrushExt(0, 0, 0, 0, 0, CB_DELETE_OLD_CURSOR); - for (y = 1; y < MAX(brush_width, brush_height); y++) - for (x = 0; x < y; x++) + for (y = 0; y < MAX(brush_width, brush_height); y++) + for (x = 0; x <= y; x++) SwapFlippedTiles(&brush_buffer[x][y], &brush_buffer[y][x], mode); diff --git a/src/game_mm/export.h b/src/game_mm/export.h index 11ee7258..184ce216 100644 --- a/src/game_mm/export.h +++ b/src/game_mm/export.h @@ -252,6 +252,10 @@ void SaveNativeLevel_MM(char *); int getFieldbufferOffsetX_MM(void); int getFieldbufferOffsetY_MM(void); +int getFlippedTileX_MM(int); +int getFlippedTileY_MM(int); +int getFlippedTileXY_MM(int); + void BlitScreenToBitmap_MM(Bitmap *); void RedrawPlayfield_MM(void); diff --git a/src/game_mm/mm_tools.c b/src/game_mm/mm_tools.c index 6a2067a4..aa9c2a5d 100644 --- a/src/game_mm/mm_tools.c +++ b/src/game_mm/mm_tools.c @@ -1222,6 +1222,103 @@ int get_rotated_element(int element, int step) return base_element + (element_phase + step + num_elements) % num_elements; } +static boolean has_full_rotation(int element) +{ + return (IS_BEAMER(element) || + IS_MCDUFFIN(element) || + IS_LASER(element) || + IS_RECEIVER(element) || + IS_PACMAN(element)); +} + +#define MM_FLIP_X 0 +#define MM_FLIP_Y 1 +#define MM_FLIP_XY 2 + +static int getFlippedTileExt_MM(int element, int mode) +{ + if (IS_WALL(element)) + { + int base = WALL_BASE(element); + int bits = WALL_BITS(element); + + if (mode == MM_FLIP_X) + { + bits = ((bits & 1) << 1 | + (bits & 2) >> 1 | + (bits & 4) << 1 | + (bits & 8) >> 1); + } + else if (mode == MM_FLIP_Y) + { + bits = ((bits & 1) << 2 | + (bits & 2) << 2 | + (bits & 4) >> 2 | + (bits & 8) >> 2); + } + else if (mode == MM_FLIP_XY) + { + bits = ((bits & 1) << 0 | + (bits & 2) << 1 | + (bits & 4) >> 1 | + (bits & 8) >> 0); + } + + element = base | bits; + } + else + { + int base_element = get_base_element(element); + int num_elements = get_num_elements(element); + int element_phase = element - base_element; + + if (IS_GRID_STEEL(element) || IS_GRID_WOOD(element)) + { + if ((mode == MM_FLIP_XY && element_phase < 2) || + (mode != MM_FLIP_XY && element_phase > 1)) + element_phase ^= 1; + } + else + { + int num_elements_flip = num_elements; + + if (has_full_rotation(element)) + { + if (mode == MM_FLIP_X) + num_elements_flip = num_elements / 2; + else if (mode == MM_FLIP_XY) + num_elements_flip = num_elements * 3 / 4; + } + else + { + if (mode == MM_FLIP_XY) + num_elements_flip = num_elements / 2; + } + + element_phase = num_elements_flip - element_phase; + } + + element = base_element + (element_phase + num_elements) % num_elements; + } + + return element; +} + +int getFlippedTileX_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_X); +} + +int getFlippedTileY_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_Y); +} + +int getFlippedTileXY_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_XY); +} + int map_wall_from_base_element(int element) { switch (element)