+ case MV_DOWN:
+ if (from_y < level_ysize - preview.ysize)
+ {
+ from_y += preview.step_offset;
+ from_y = (from_y > level_ysize - preview.ysize ?
+ level_ysize - preview.ysize : from_y);
+ }
+ else
+ scroll_direction = MV_LEFT;
+ break;
+
+ default:
+ break;
+ }
+
+ DrawPreviewLevelPlayfieldExt(from_x, from_y);
+ }
+
+ /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
+ /* redraw micro level label, if needed */
+ if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
+ !strEqual(level.author, ANONYMOUS_NAME) &&
+ !strEqual(level.author, leveldir_current->name) &&
+ DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
+ {
+ int max_label_counter = 23;
+
+ if (leveldir_current->imported_from != NULL &&
+ strlen(leveldir_current->imported_from) > 0)
+ max_label_counter += 14;
+ if (leveldir_current->imported_by != NULL &&
+ strlen(leveldir_current->imported_by) > 0)
+ max_label_counter += 14;
+
+ label_counter = (label_counter + 1) % max_label_counter;
+ label_state = (label_counter >= 0 && label_counter <= 7 ?
+ MICROLABEL_LEVEL_NAME :
+ label_counter >= 9 && label_counter <= 12 ?
+ MICROLABEL_LEVEL_AUTHOR_HEAD :
+ label_counter >= 14 && label_counter <= 21 ?
+ MICROLABEL_LEVEL_AUTHOR :
+ label_counter >= 23 && label_counter <= 26 ?
+ MICROLABEL_IMPORTED_FROM_HEAD :
+ label_counter >= 28 && label_counter <= 35 ?
+ MICROLABEL_IMPORTED_FROM :
+ label_counter >= 37 && label_counter <= 40 ?
+ MICROLABEL_IMPORTED_BY_HEAD :
+ label_counter >= 42 && label_counter <= 49 ?
+ MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
+
+ if (leveldir_current->imported_from == NULL &&
+ (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
+ label_state == MICROLABEL_IMPORTED_FROM))
+ label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
+ MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
+
+ DrawPreviewLevelLabelExt(label_state);
+ }
+
+ game_status = last_game_status; /* restore current game status */
+}
+
+void DrawPreviewLevelInitial()
+{
+ DrawPreviewLevelExt(TRUE);
+}
+
+void DrawPreviewLevelAnimation()
+{
+ DrawPreviewLevelExt(FALSE);
+}
+
+inline static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+ int graphic, int sync_frame,
+ int mask_mode)
+{
+ int frame = getGraphicAnimationFrame(graphic, sync_frame);
+
+ if (mask_mode == USE_MASKING)
+ DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
+ else
+ DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
+}
+
+void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+ int graphic, int sync_frame, int mask_mode)
+{
+ int frame = getGraphicAnimationFrame(graphic, sync_frame);
+
+ if (mask_mode == USE_MASKING)
+ DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
+ else
+ DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
+}
+
+inline static void DrawGraphicAnimation(int x, int y, int graphic)
+{
+ int lx = LEVELX(x), ly = LEVELY(y);
+
+ if (!IN_SCR_FIELD(x, y))
+ return;
+
+ DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
+ graphic, GfxFrame[lx][ly], NO_MASKING);
+
+ MarkTileDirty(x, y);
+}
+
+void DrawFixedGraphicAnimation(int x, int y, int graphic)
+{
+ int lx = LEVELX(x), ly = LEVELY(y);
+
+ if (!IN_SCR_FIELD(x, y))
+ return;
+
+ DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
+ graphic, GfxFrame[lx][ly], NO_MASKING);
+ MarkTileDirty(x, y);
+}
+
+void DrawLevelGraphicAnimation(int x, int y, int graphic)
+{
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+}
+
+void DrawLevelElementAnimation(int x, int y, int element)
+{
+ int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+}
+
+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(sx, sy, graphic);
+
+#if 1
+ if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
+ DrawLevelFieldCrumbled(x, y);
+#else
+ if (GFX_CRUMBLED(Feld[x][y]))
+ DrawLevelFieldCrumbled(x, y);
+#endif
+}
+
+void DrawLevelElementAnimationIfNeeded(int x, int y, int 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], GfxDir[x][y]);
+
+ if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ return;
+
+ DrawGraphicAnimation(sx, sy, graphic);
+
+ if (GFX_CRUMBLED(element))
+ DrawLevelFieldCrumbled(x, y);
+}
+
+static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
+{
+ if (player->use_murphy)
+ {
+ /* this works only because currently only one player can be "murphy" ... */
+ static int last_horizontal_dir = MV_LEFT;
+ int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
+
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ last_horizontal_dir = move_dir;
+
+ if (graphic == IMG_SP_MURPHY) /* undefined => use special graphic */
+ {
+ int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
+
+ graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
+ }
+
+ return graphic;
+ }
+ else
+ return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
+}
+
+static boolean equalGraphics(int graphic1, int graphic2)
+{
+ struct GraphicInfo *g1 = &graphic_info[graphic1];
+ struct GraphicInfo *g2 = &graphic_info[graphic2];
+
+ return (g1->bitmap == g2->bitmap &&
+ g1->src_x == g2->src_x &&
+ g1->src_y == g2->src_y &&
+ g1->anim_frames == g2->anim_frames &&
+ g1->anim_delay == g2->anim_delay &&
+ g1->anim_mode == g2->anim_mode);
+}
+
+void DrawAllPlayers()
+{
+ int i;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].active)
+ DrawPlayer(&stored_player[i]);
+}
+
+void DrawPlayerField(int x, int y)
+{
+ if (!IS_PLAYER(x, y))
+ return;
+
+ DrawPlayer(PLAYERINFO(x, y));
+}
+
+#define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
+
+void DrawPlayer(struct PlayerInfo *player)
+{
+ int jx = player->jx;
+ int jy = player->jy;
+ int move_dir = player->MovDir;
+ int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
+ int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
+ int last_jx = (player->is_moving ? jx - dx : jx);
+ int last_jy = (player->is_moving ? jy - dy : jy);
+ int next_jx = jx + dx;
+ int next_jy = jy + dy;
+ boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
+ boolean player_is_opaque = FALSE;
+ int sx = SCREENX(jx), sy = SCREENY(jy);
+ int sxx = 0, syy = 0;
+ int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
+ int graphic;
+ int action = ACTION_DEFAULT;
+ int last_player_graphic = getPlayerGraphic(player, move_dir);
+ int last_player_frame = player->Frame;
+ int frame = 0;
+
+ /* GfxElement[][] is set to the element the player is digging or collecting;
+ remove also for off-screen player if the player is not moving anymore */
+ if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
+ GfxElement[jx][jy] = EL_UNDEFINED;
+
+ if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
+ return;
+
+#if DEBUG
+ if (!IN_LEV_FIELD(jx, jy))
+ {
+ printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
+ printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
+ printf("DrawPlayerField(): This should never happen!\n");
+ return;
+ }
+#endif
+
+ if (element == EL_EXPLOSION)
+ return;
+
+ action = (player->is_pushing ? ACTION_PUSHING :
+ player->is_digging ? ACTION_DIGGING :
+ player->is_collecting ? ACTION_COLLECTING :
+ player->is_moving ? ACTION_MOVING :
+ player->is_snapping ? ACTION_SNAPPING :
+ player->is_dropping ? ACTION_DROPPING :
+ player->is_waiting ? player->action_waiting : ACTION_DEFAULT);
+
+ if (player->is_waiting)
+ move_dir = player->dir_waiting;
+
+ InitPlayerGfxAnimation(player, action, move_dir);
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things in the field the player is leaving, if needed */
+ /* ----------------------------------------------------------------------- */
+
+ if (player->is_moving)
+ {
+ if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
+ {
+ DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
+
+ if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_EM_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
+ DrawDynamite(last_jx, last_jy);
+ else
+ DrawLevelFieldThruMask(last_jx, last_jy);
+ }
+ else if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_EM_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
+ DrawDynamite(last_jx, last_jy);
+#if 0
+ /* !!! this is not enough to prevent flickering of players which are
+ moving next to each others without a free tile between them -- this
+ can only be solved by drawing all players layer by layer (first the
+ background, then the foreground etc.) !!! => TODO */
+ else if (!IS_PLAYER(last_jx, last_jy))
+ DrawLevelField(last_jx, last_jy);
+#else
+ else
+ DrawLevelField(last_jx, last_jy);
+#endif
+
+ if (player->is_pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+ }
+
+ if (!IN_SCR_FIELD(sx, sy))
+ return;
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things behind the player, if needed */
+ /* ----------------------------------------------------------------------- */
+
+ if (Back[jx][jy])
+ DrawLevelElement(jx, jy, Back[jx][jy]);
+ else if (IS_ACTIVE_BOMB(element))
+ DrawLevelElement(jx, jy, EL_EMPTY);
+ else
+ {
+ if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
+ {
+ int old_element = GfxElement[jx][jy];
+ int old_graphic = el_act_dir2img(old_element, action, move_dir);
+ int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
+
+ if (GFX_CRUMBLED(old_element))
+ DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
+ else
+ DrawGraphic(sx, sy, old_graphic, frame);
+
+ if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
+ player_is_opaque = TRUE;
+ }
+ else
+ {
+ GfxElement[jx][jy] = EL_UNDEFINED;
+
+ /* make sure that pushed elements are drawn with correct frame rate */
+ graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+
+ if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
+ GfxFrame[jx][jy] = player->StepFrame;
+
+ DrawLevelField(jx, jy);
+ }
+ }
+
+#if !DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ /* ----------------------------------------------------------------------- */
+ /* draw player himself */
+ /* ----------------------------------------------------------------------- */
+
+ graphic = getPlayerGraphic(player, move_dir);
+
+ /* in the case of changed player action or direction, prevent the current
+ animation frame from being restarted for identical animations */
+ if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
+ player->Frame = last_player_frame;
+
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
+
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+
+ if (player_is_opaque)
+ DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
+ else
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+
+ if (SHIELD_ON(player))
+ {
+ int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
+ IMG_SHIELD_NORMAL_ACTIVE);
+ int frame = getGraphicAnimationFrame(graphic, -1);
+
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ }
+#endif
+
+#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+#endif
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things the player is pushing, if needed */
+ /* ----------------------------------------------------------------------- */
+
+ if (player->is_pushing && player->is_moving)
+ {
+ int px = SCREENX(jx), py = SCREENY(jy);
+ int pxx = (TILEX - ABS(sxx)) * dx;
+ int pyy = (TILEY - ABS(syy)) * dy;
+ int gfx_frame = GfxFrame[jx][jy];
+
+ int graphic;
+ int sync_frame;
+ int frame;
+
+ if (!IS_MOVING(jx, jy)) /* push movement already finished */
+ {
+ element = Feld[next_jx][next_jy];
+ gfx_frame = GfxFrame[next_jx][next_jy];
+ }
+
+ graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+
+ sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
+ frame = getGraphicAnimationFrame(graphic, sync_frame);
+
+ /* draw background element under pushed element (like the Sokoban field) */
+ if (game.use_masked_pushing && IS_MOVING(jx, jy))
+ {
+ /* this allows transparent pushing animation over non-black background */
+
+ if (Back[jx][jy])
+ DrawLevelElement(jx, jy, Back[jx][jy]);
+ else
+ DrawLevelElement(jx, jy, EL_EMPTY);
+
+ if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+ else
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+ }
+ else if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+
+#if 1
+ /* do not draw (EM style) pushing animation when pushing is finished */
+ /* (two-tile animations usually do not contain start and end frame) */
+ if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
+ DrawLevelElement(next_jx, next_jy, Feld[next_jx][next_jy]);
+ else
+ DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
+#else
+ /* masked drawing is needed for EMC style (double) movement graphics */
+ /* !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!! */
+ DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
+#endif
+ }
+
+#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ /* ----------------------------------------------------------------------- */
+ /* draw player himself */
+ /* ----------------------------------------------------------------------- */
+
+ graphic = getPlayerGraphic(player, move_dir);
+
+ /* in the case of changed player action or direction, prevent the current
+ animation frame from being restarted for identical animations */
+ if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
+ player->Frame = last_player_frame;
+
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
+
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+
+ if (player_is_opaque)
+ DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
+ else
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+
+ if (SHIELD_ON(player))
+ {
+ int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
+ IMG_SHIELD_NORMAL_ACTIVE);
+ int frame = getGraphicAnimationFrame(graphic, -1);
+
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ }
+#endif
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things in front of player (active dynamite or dynabombs) */
+ /* ----------------------------------------------------------------------- */
+
+ if (IS_ACTIVE_BOMB(element))
+ {
+ graphic = el2img(element);
+ frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
+
+ if (game.emulation == EMU_SUPAPLEX)
+ DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
+ else
+ DrawGraphicThruMask(sx, sy, graphic, frame);
+ }
+
+ if (player_is_moving && last_element == EL_EXPLOSION)
+ {
+ int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
+ GfxElement[last_jx][last_jy] : EL_EMPTY);
+ int graphic = el_act2img(element, ACTION_EXPLODING);
+ int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
+ int phase = ExplodePhase[last_jx][last_jy] - 1;
+ int frame = getGraphicAnimationFrame(graphic, phase - delay);
+
+ if (phase >= delay)
+ DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
+ }
+
+ /* ----------------------------------------------------------------------- */
+ /* draw elements the player is just walking/passing through/under */
+ /* ----------------------------------------------------------------------- */
+
+ if (player_is_moving)
+ {
+ /* handle the field the player is leaving ... */
+ if (IS_ACCESSIBLE_INSIDE(last_element))
+ DrawLevelField(last_jx, last_jy);
+ else if (IS_ACCESSIBLE_UNDER(last_element))
+ DrawLevelFieldThruMask(last_jx, last_jy);
+ }
+
+ /* do not redraw accessible elements if the player is just pushing them */
+ if (!player_is_moving || !player->is_pushing)
+ {
+ /* ... and the field the player is entering */
+ if (IS_ACCESSIBLE_INSIDE(element))
+ DrawLevelField(jx, jy);
+ else if (IS_ACCESSIBLE_UNDER(element))
+ DrawLevelFieldThruMask(jx, jy);
+ }
+
+ MarkTileDirty(sx, sy);
+}
+
+/* ------------------------------------------------------------------------- */
+
+void WaitForEventToContinue()
+{
+ boolean still_wait = TRUE;
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ button_status = MB_RELEASED;
+
+ ClearEventQueue();
+
+ while (still_wait)
+ {
+ if (PendingEvent())
+ {
+ Event event;
+
+ NextEvent(&event);
+
+ switch (event.type)
+ {
+ case EVENT_BUTTONPRESS:
+ case EVENT_KEYPRESS:
+ still_wait = FALSE;
+ break;
+
+ case EVENT_KEYRELEASE:
+ ClearPlayerAction();
+ break;
+
+ default:
+ HandleOtherEvents(&event);
+ break;
+ }
+ }
+ else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+ {
+ still_wait = FALSE;
+ }
+
+ DoAnimation();
+
+ /* don't eat all CPU time */
+ Delay(10);
+ }
+}
+
+#define MAX_REQUEST_LINES 13
+#define MAX_REQUEST_LINE_FONT1_LEN 7
+#define MAX_REQUEST_LINE_FONT2_LEN 10
+
+static int RequestHandleEvents(unsigned int req_state)
+{
+ boolean level_solved = (game_status == GAME_MODE_PLAYING &&
+ local_player->LevelSolved_GameEnd);
+ int width = request.width;
+ int height = request.height;
+ int sx, sy;
+ int result;
+
+ setRequestPosition(&sx, &sy, FALSE);
+
+ button_status = MB_RELEASED;
+
+ request_gadget_id = -1;
+ result = -1;
+
+ while (result < 0)
+ {
+ if (level_solved)
+ {
+ SetDrawtoField(DRAW_FIELDBUFFER);
+
+ HandleGameActions();
+
+ SetDrawtoField(DRAW_BACKBUFFER);
+
+ if (global.use_envelope_request)
+ {
+ /* copy current state of request area to middle of playfield area */
+ BlitBitmap(bitmap_db_cross, drawto, sx, sy, width, height, sx, sy);
+ }
+ }
+
+ if (PendingEvent())
+ {
+ Event event;
+
+ while (NextValidEvent(&event))
+ {
+ switch (event.type)
+ {
+ case EVENT_BUTTONPRESS:
+ case EVENT_BUTTONRELEASE:
+ case EVENT_MOTIONNOTIFY:
+ {
+ int mx, my;
+
+ if (event.type == EVENT_MOTIONNOTIFY)
+ {
+ if (!button_status)
+ continue;
+
+ motion_status = TRUE;
+ mx = ((MotionEvent *) &event)->x;
+ my = ((MotionEvent *) &event)->y;
+ }
+ else
+ {
+ motion_status = FALSE;
+ mx = ((ButtonEvent *) &event)->x;
+ my = ((ButtonEvent *) &event)->y;
+ if (event.type == EVENT_BUTTONPRESS)
+ button_status = ((ButtonEvent *) &event)->button;
+ else
+ button_status = MB_RELEASED;
+ }
+
+ /* this sets 'request_gadget_id' */
+ HandleGadgets(mx, my, button_status);
+
+ switch (request_gadget_id)
+ {
+ case TOOL_CTRL_ID_YES:
+ result = TRUE;
+ break;
+ case TOOL_CTRL_ID_NO:
+ result = FALSE;
+ break;
+ case TOOL_CTRL_ID_CONFIRM:
+ result = TRUE | FALSE;
+ break;
+
+ case TOOL_CTRL_ID_PLAYER_1:
+ result = 1;
+ break;
+ case TOOL_CTRL_ID_PLAYER_2:
+ result = 2;
+ break;
+ case TOOL_CTRL_ID_PLAYER_3:
+ result = 3;
+ break;
+ case TOOL_CTRL_ID_PLAYER_4:
+ result = 4;
+ break;
+
+ default:
+ break;
+ }
+
+ break;
+ }
+
+ case EVENT_KEYPRESS:
+ switch (GetEventKey((KeyEvent *)&event, TRUE))
+ {
+ case KSYM_space:
+ if (req_state & REQ_CONFIRM)
+ result = 1;
+ break;
+
+ case KSYM_Return:
+#if defined(TARGET_SDL2)
+ case KSYM_Menu:
+#endif
+ result = 1;
+ break;
+
+ case KSYM_Escape:
+#if defined(TARGET_SDL2)
+ case KSYM_Back:
+#endif
+ result = 0;
+ break;
+
+ default:
+ break;
+ }
+
+ if (req_state & REQ_PLAYER)
+ result = 0;
+ break;
+
+ case EVENT_KEYRELEASE:
+ ClearPlayerAction();
+ break;
+
+ default:
+ HandleOtherEvents(&event);
+ break;
+ }
+ }
+ }
+ else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+ {
+ int joy = AnyJoystick();
+
+ if (joy & JOY_BUTTON_1)
+ result = 1;
+ else if (joy & JOY_BUTTON_2)
+ result = 0;
+ }
+
+ if (level_solved)
+ {
+ if (global.use_envelope_request)
+ {
+ /* copy back current state of pressed buttons inside request area */
+ BlitBitmap(drawto, bitmap_db_cross, sx, sy, width, height, sx, sy);
+ }
+ }
+ else
+ {
+ DoAnimation();
+
+ if (!PendingEvent()) /* delay only if no pending events */
+ Delay(10);
+ }
+
+ BackToFront();
+ }
+
+ return result;
+}
+
+static boolean RequestDoor(char *text, unsigned int req_state)
+{
+ unsigned int old_door_state;
+ int last_game_status = game_status; /* save current game status */
+ int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
+ int font_nr = FONT_TEXT_2;
+ char *text_ptr;
+ int result;
+ int ty;
+
+ if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
+ {
+ max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
+ font_nr = FONT_TEXT_1;
+ }
+
+ if (game_status == GAME_MODE_PLAYING)
+ BlitScreenToBitmap(backbuffer);
+
+ /* disable deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOff(TRUE);
+
+ SetMouseCursor(CURSOR_DEFAULT);
+
+#if defined(NETWORK_AVALIABLE)
+ /* pause network game while waiting for request to answer */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_PausePlaying();
+#endif
+
+ old_door_state = GetDoorState();
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ UnmapAllGadgets();
+
+ /* draw released gadget before proceeding */
+ // BackToFront();
+
+ if (old_door_state & DOOR_OPEN_1)
+ {
+ CloseDoor(DOOR_CLOSE_1);
+
+ /* save old door content */
+ BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
+ 0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
+ }
+
+ SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ /* clear door drawing field */
+ DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+ /* force DOOR font inside door area */
+ game_status = GAME_MODE_PSEUDO_DOOR;
+
+ /* write text for request */
+ for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
+ {
+ char text_line[max_request_line_len + 1];
+ int tx, tl, tc = 0;
+
+ if (!*text_ptr)
+ break;
+
+ for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
+ {
+ tc = *(text_ptr + tx);
+ // if (!tc || tc == ' ')
+ if (!tc || tc == ' ' || tc == '?' || tc == '!')
+ break;
+ }
+
+ if ((tc == '?' || tc == '!') && tl == 0)
+ tl = 1;
+
+ if (!tl)
+ {
+ text_ptr++;
+ ty--;
+ continue;
+ }
+
+ strncpy(text_line, text_ptr, tl);
+ text_line[tl] = 0;
+
+ DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
+ DY + 8 + ty * (getFontHeight(font_nr) + 2),
+ text_line, font_nr);
+
+ text_ptr += tl + (tc == ' ' ? 1 : 0);
+ // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
+ }
+
+ game_status = last_game_status; /* restore current game status */
+
+ if (req_state & REQ_ASK)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+ }
+ else if (req_state & REQ_CONFIRM)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+ }
+ else if (req_state & REQ_PLAYER)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
+ }
+
+ /* copy request gadgets to door backbuffer */
+ BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
+
+ OpenDoor(DOOR_OPEN_1);
+
+ if (!(req_state & REQUEST_WAIT_FOR_INPUT))
+ {
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+ return FALSE;
+ }
+
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
+
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
+
+ UnmapToolButtons();
+
+ if (!(req_state & REQ_STAY_OPEN))
+ {
+ CloseDoor(DOOR_CLOSE_1);
+
+ if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
+ (req_state & REQ_REOPEN))
+ OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+ }
+
+ RemapAllGadgets();
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+#if defined(NETWORK_AVALIABLE)
+ /* continue network game after request */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_ContinuePlaying();
+#endif
+
+ /* restore deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOn();
+
+ return result;
+}
+
+static boolean RequestEnvelope(char *text, unsigned int req_state)
+{
+ int result;
+
+ if (game_status == GAME_MODE_PLAYING)
+ BlitScreenToBitmap(backbuffer);
+
+ /* disable deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOff(TRUE);
+
+ SetMouseCursor(CURSOR_DEFAULT);
+
+#if defined(NETWORK_AVALIABLE)
+ /* pause network game while waiting for request to answer */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_PausePlaying();
+#endif
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ UnmapAllGadgets();
+
+ // (replace with setting corresponding request background)
+ // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ /* clear door drawing field */
+ // DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+ ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
+
+ if (!(req_state & REQUEST_WAIT_FOR_INPUT))
+ {
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+ return FALSE;
+ }
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
+
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
+
+ UnmapToolButtons();
+
+ ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
+
+ RemapAllGadgets();
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+#if defined(NETWORK_AVALIABLE)
+ /* continue network game after request */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_ContinuePlaying();
+#endif
+
+ /* restore deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOn();
+
+ return result;
+}
+
+boolean Request(char *text, unsigned int req_state)
+{
+ if (global.use_envelope_request)
+ return RequestEnvelope(text, req_state);
+ else
+ return RequestDoor(text, req_state);
+}
+
+static int compareDoorPartOrderInfo(const void *object1, const void *object2)
+{
+ const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
+ const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
+ int compare_result;
+
+ if (dpo1->sort_priority != dpo2->sort_priority)
+ compare_result = dpo1->sort_priority - dpo2->sort_priority;
+ else
+ compare_result = dpo1->nr - dpo2->nr;
+
+ return compare_result;
+}
+
+void InitGraphicCompatibilityInfo_Doors()
+{
+ struct
+ {
+ int door_token;
+ int part_1, part_8;
+ struct DoorInfo *door;
+ }
+ doors[] =
+ {
+ { DOOR_1, IMG_DOOR_1_GFX_PART_1, IMG_DOOR_1_GFX_PART_8, &door_1 },
+ { DOOR_2, IMG_DOOR_2_GFX_PART_1, IMG_DOOR_2_GFX_PART_8, &door_2 },
+
+ { -1, -1, -1, NULL }
+ };
+ struct Rect door_rect_list[] =
+ {
+ { DX, DY, DXSIZE, DYSIZE },
+ { VX, VY, VXSIZE, VYSIZE }
+ };
+ int i, j;
+
+ for (i = 0; doors[i].door_token != -1; i++)
+ {
+ int door_token = doors[i].door_token;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
+ int part_1 = doors[i].part_1;
+ int part_8 = doors[i].part_8;
+ int part_2 = part_1 + 1;
+ int part_3 = part_1 + 2;
+ struct DoorInfo *door = doors[i].door;
+ struct Rect *door_rect = &door_rect_list[door_index];
+ boolean door_gfx_redefined = FALSE;
+
+ /* check if any door part graphic definitions have been redefined */
+
+ for (j = 0; door_part_controls[j].door_token != -1; j++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[j];
+ struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
+
+ if (dpc->door_token == door_token && fi->redefined)
+ door_gfx_redefined = TRUE;
+ }
+
+ /* check for old-style door graphic/animation modifications */
+
+ if (!door_gfx_redefined)
+ {
+ if (door->anim_mode & ANIM_STATIC_PANEL)
+ {
+ door->panel.step_xoffset = 0;
+ door->panel.step_yoffset = 0;
+ }
+
+ if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
+ {
+ struct GraphicInfo *g_part_1 = &graphic_info[part_1];
+ struct GraphicInfo *g_part_2 = &graphic_info[part_2];
+ int num_door_steps, num_panel_steps;
+
+ /* remove door part graphics other than the two default wings */
+
+ for (j = 0; door_part_controls[j].door_token != -1; j++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[j];
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+
+ if (dpc->graphic >= part_3 &&
+ dpc->graphic <= part_8)
+ g->bitmap = NULL;
+ }
+
+ /* set graphics and screen positions of the default wings */
+
+ g_part_1->width = door_rect->width;
+ g_part_1->height = door_rect->height;
+ g_part_2->width = door_rect->width;
+ g_part_2->height = door_rect->height;
+ g_part_2->src_x = door_rect->width;
+ g_part_2->src_y = g_part_1->src_y;
+
+ door->part_2.x = door->part_1.x;
+ door->part_2.y = door->part_1.y;
+
+ if (door->width != -1)
+ {
+ g_part_1->width = door->width;
+ g_part_2->width = door->width;
+
+ // special treatment for graphics and screen position of right wing
+ g_part_2->src_x += door_rect->width - door->width;
+ door->part_2.x += door_rect->width - door->width;
+ }
+
+ if (door->height != -1)
+ {
+ g_part_1->height = door->height;
+ g_part_2->height = door->height;
+
+ // special treatment for graphics and screen position of bottom wing
+ g_part_2->src_y += door_rect->height - door->height;
+ door->part_2.y += door_rect->height - door->height;
+ }
+
+ /* set animation delays for the default wings and panels */
+
+ door->part_1.step_delay = door->step_delay;
+ door->part_2.step_delay = door->step_delay;
+ door->panel.step_delay = door->step_delay;
+
+ /* set animation draw order for the default wings */
+
+ door->part_1.sort_priority = 2; /* draw left wing over ... */
+ door->part_2.sort_priority = 1; /* ... right wing */
+
+ /* set animation draw offset for the default wings */
+
+ if (door->anim_mode & ANIM_HORIZONTAL)
+ {
+ door->part_1.step_xoffset = door->step_offset;
+ door->part_1.step_yoffset = 0;
+ door->part_2.step_xoffset = door->step_offset * -1;
+ door->part_2.step_yoffset = 0;
+
+ num_door_steps = g_part_1->width / door->step_offset;
+ }
+ else // ANIM_VERTICAL
+ {
+ door->part_1.step_xoffset = 0;
+ door->part_1.step_yoffset = door->step_offset;
+ door->part_2.step_xoffset = 0;
+ door->part_2.step_yoffset = door->step_offset * -1;
+
+ num_door_steps = g_part_1->height / door->step_offset;
+ }
+
+ /* set animation draw offset for the default panels */
+
+ if (door->step_offset > 1)
+ {
+ num_panel_steps = 2 * door_rect->height / door->step_offset;
+ door->panel.start_step = num_panel_steps - num_door_steps;
+ door->panel.start_step_closing = door->panel.start_step;
+ }
+ else
+ {
+ num_panel_steps = door_rect->height / door->step_offset;
+ door->panel.start_step = num_panel_steps - num_door_steps / 2;
+ door->panel.start_step_closing = door->panel.start_step;
+ door->panel.step_delay *= 2;
+ }
+ }
+ }
+ }
+}
+
+void InitDoors()
+{
+ int i;
+
+ for (i = 0; door_part_controls[i].door_token != -1; i++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[i];
+ struct DoorPartOrderInfo *dpo = &door_part_order[i];
+
+ /* initialize "start_step_opening" and "start_step_closing", if needed */
+ if (dpc->pos->start_step_opening == 0 &&
+ dpc->pos->start_step_closing == 0)
+ {
+ // dpc->pos->start_step_opening = dpc->pos->start_step;
+ dpc->pos->start_step_closing = dpc->pos->start_step;
+ }
+
+ /* fill structure for door part draw order (sorted below) */
+ dpo->nr = i;
+ dpo->sort_priority = dpc->pos->sort_priority;
+ }
+
+ /* sort door part controls according to sort_priority and graphic number */
+ qsort(door_part_order, MAX_DOOR_PARTS,
+ sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
+}
+
+unsigned int OpenDoor(unsigned int door_state)
+{
+ if (door_state & DOOR_COPY_BACK)
+ {
+ if (door_state & DOOR_OPEN_1)
+ BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
+ 1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
+
+ if (door_state & DOOR_OPEN_2)
+ BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
+ 1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
+
+ door_state &= ~DOOR_COPY_BACK;
+ }
+
+ return MoveDoor(door_state);
+}
+
+unsigned int CloseDoor(unsigned int door_state)
+{
+ unsigned int old_door_state = GetDoorState();
+
+ if (!(door_state & DOOR_NO_COPY_BACK))
+ {
+ if (old_door_state & DOOR_OPEN_1)
+ BlitBitmap(backbuffer, bitmap_db_door_1,
+ DX, DY, DXSIZE, DYSIZE, 0, 0);
+
+ if (old_door_state & DOOR_OPEN_2)
+ BlitBitmap(backbuffer, bitmap_db_door_2,
+ VX, VY, VXSIZE, VYSIZE, 0, 0);
+
+ door_state &= ~DOOR_NO_COPY_BACK;
+ }
+
+ return MoveDoor(door_state);
+}
+
+unsigned int GetDoorState()
+{
+ return MoveDoor(DOOR_GET_STATE);
+}
+
+unsigned int SetDoorState(unsigned int door_state)
+{
+ return MoveDoor(door_state | DOOR_SET_STATE);
+}
+
+int euclid(int a, int b)
+{
+ return (b ? euclid(b, a % b) : a);
+}
+
+unsigned int MoveDoor(unsigned int door_state)
+{
+ struct Rect door_rect_list[] =
+ {
+ { DX, DY, DXSIZE, DYSIZE },
+ { VX, VY, VXSIZE, VYSIZE }
+ };
+ static int door1 = DOOR_OPEN_1;
+ static int door2 = DOOR_CLOSE_2;
+ unsigned int door_delay = 0;
+ unsigned int door_delay_value;
+ int i;
+
+ if (door_state == DOOR_GET_STATE)
+ return (door1 | door2);
+
+ if (door_state & DOOR_SET_STATE)
+ {
+ if (door_state & DOOR_ACTION_1)
+ door1 = door_state & DOOR_ACTION_1;
+ if (door_state & DOOR_ACTION_2)
+ door2 = door_state & DOOR_ACTION_2;
+
+ return (door1 | door2);
+ }
+
+ if (!(door_state & DOOR_FORCE_REDRAW))
+ {
+ if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
+ door_state &= ~DOOR_OPEN_1;
+ else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
+ door_state &= ~DOOR_CLOSE_1;
+ if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
+ door_state &= ~DOOR_OPEN_2;
+ else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
+ door_state &= ~DOOR_CLOSE_2;
+ }
+
+ if (global.autoplay_leveldir)
+ {
+ door_state |= DOOR_NO_DELAY;
+ door_state &= ~DOOR_CLOSE_ALL;
+ }
+
+ if (game_status == GAME_MODE_EDITOR)
+ door_state |= DOOR_NO_DELAY;
+
+ if (door_state & DOOR_ACTION)
+ {
+ boolean door_panel_drawn[NUM_DOORS];
+ boolean panel_has_doors[NUM_DOORS];
+ boolean door_part_skip[MAX_DOOR_PARTS];
+ boolean door_part_done[MAX_DOOR_PARTS];
+ boolean door_part_done_all;
+ int num_steps[MAX_DOOR_PARTS];
+ int max_move_delay = 0; // delay for complete animations of all doors
+ int max_step_delay = 0; // delay (ms) between two animation frames
+ int num_move_steps = 0; // number of animation steps for all doors
+ int max_move_delay_doors_only = 0; // delay for doors only (no panel)
+ int num_move_steps_doors_only = 0; // steps for doors only (no panel)
+ int current_move_delay = 0;
+ int start = 0;
+ int k;
+
+ for (i = 0; i < NUM_DOORS; i++)
+ panel_has_doors[i] = FALSE;
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[i];
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+ int door_token = dpc->door_token;
+
+ door_part_done[i] = FALSE;
+ door_part_skip[i] = (!(door_state & door_token) ||
+ !g->bitmap);
+ }
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ {
+ int nr = door_part_order[i].nr;
+ struct DoorPartControlInfo *dpc = &door_part_controls[nr];
+ struct DoorPartPosInfo *pos = dpc->pos;
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+ int door_token = dpc->door_token;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
+ boolean is_panel = DOOR_PART_IS_PANEL(nr);
+ int step_xoffset = ABS(pos->step_xoffset);
+ int step_yoffset = ABS(pos->step_yoffset);
+ int step_delay = pos->step_delay;
+ int current_door_state = door_state & door_token;
+ boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
+ boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
+ boolean part_opening = (is_panel ? door_closing : door_opening);
+ int start_step = (part_opening ? pos->start_step_opening :
+ pos->start_step_closing);
+ float move_xsize = (step_xoffset ? g->width : 0);
+ float move_ysize = (step_yoffset ? g->height : 0);
+ int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
+ int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
+ int move_steps = (move_xsteps && move_ysteps ?
+ MIN(move_xsteps, move_ysteps) :
+ move_xsteps ? move_xsteps : move_ysteps) - start_step;
+ int move_delay = move_steps * step_delay;
+
+ if (door_part_skip[nr])
+ continue;
+
+ max_move_delay = MAX(max_move_delay, move_delay);
+ max_step_delay = (max_step_delay == 0 ? step_delay :
+ euclid(max_step_delay, step_delay));
+ num_steps[nr] = move_steps;
+
+ if (!is_panel)
+ {
+ max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
+
+ panel_has_doors[door_index] = TRUE;
+ }
+ }
+
+ max_step_delay = MAX(1, max_step_delay); // prevent division by zero
+
+ num_move_steps = max_move_delay / max_step_delay;
+ num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
+
+ door_delay_value = max_step_delay;
+
+ if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
+ {
+ start = num_move_steps - 1;
+ }
+ else
+ {
+ /* opening door sound has priority over simultaneously closing door */
+ if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
+ PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
+ else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
+ PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
+ }
+
+ for (k = start; k < num_move_steps; k++)
+ {
+ int last_frame = num_move_steps - 1; // last frame of this "for" loop
+
+ door_part_done_all = TRUE;
+
+ for (i = 0; i < NUM_DOORS; i++)
+ door_panel_drawn[i] = FALSE;
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ {
+ int nr = door_part_order[i].nr;
+ struct DoorPartControlInfo *dpc = &door_part_controls[nr];
+ struct DoorPartPosInfo *pos = dpc->pos;
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+ int door_token = dpc->door_token;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
+ boolean is_panel = DOOR_PART_IS_PANEL(nr);
+ boolean is_panel_and_door_has_closed = FALSE;
+ struct Rect *door_rect = &door_rect_list[door_index];
+ Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
+ bitmap_db_door_2);
+ Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
+ int current_door_state = door_state & door_token;
+ boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
+ boolean door_closing = !door_opening;
+ boolean part_opening = (is_panel ? door_closing : door_opening);
+ boolean part_closing = !part_opening;
+ int start_step = (part_opening ? pos->start_step_opening :
+ pos->start_step_closing);
+ int step_delay = pos->step_delay;
+ int step_factor = step_delay / max_step_delay;
+ int k1 = (step_factor ? k / step_factor + 1 : k);
+ int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
+ int kk = MAX(0, k2);
+ int g_src_x = 0;
+ int g_src_y = 0;
+ int src_x, src_y, src_xx, src_yy;
+ int dst_x, dst_y, dst_xx, dst_yy;
+ int width, height;
+
+ if (door_part_skip[nr])
+ continue;
+
+ if (!(door_state & door_token))
+ continue;
+
+ if (!g->bitmap)
+ continue;
+
+ if (!is_panel)
+ {
+ int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
+ int kk_door = MAX(0, k2_door);
+ int sync_frame = kk_door * door_delay_value;
+ int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
+
+ getGraphicSource(dpc->graphic, frame, &bitmap, &g_src_x, &g_src_y);
+ }
+
+ // draw door panel
+
+ if (!door_panel_drawn[door_index])
+ {
+ ClearRectangle(drawto, door_rect->x, door_rect->y,
+ door_rect->width, door_rect->height);
+
+ door_panel_drawn[door_index] = TRUE;
+ }
+
+ // draw opening or closing door parts
+
+ if (pos->step_xoffset < 0) // door part on right side
+ {
+ src_xx = 0;
+ dst_xx = pos->x + ABS(kk * pos->step_xoffset);
+ width = g->width;
+
+ if (dst_xx + width > door_rect->width)
+ width = door_rect->width - dst_xx;
+ }
+ else // door part on left side
+ {
+ src_xx = 0;
+ dst_xx = pos->x - kk * pos->step_xoffset;
+
+ if (dst_xx < 0)
+ {
+ src_xx = ABS(dst_xx);
+ dst_xx = 0;
+ }
+
+ width = g->width - src_xx;
+
+ if (width > door_rect->width)
+ width = door_rect->width;
+
+ // printf("::: k == %d [%d] \n", k, start_step);
+ }
+
+ if (pos->step_yoffset < 0) // door part on bottom side
+ {
+ src_yy = 0;
+ dst_yy = pos->y + ABS(kk * pos->step_yoffset);
+ height = g->height;
+
+ if (dst_yy + height > door_rect->height)
+ height = door_rect->height - dst_yy;
+ }
+ else // door part on top side
+ {
+ src_yy = 0;
+ dst_yy = pos->y - kk * pos->step_yoffset;
+
+ if (dst_yy < 0)
+ {
+ src_yy = ABS(dst_yy);
+ dst_yy = 0;
+ }
+
+ height = g->height - src_yy;
+ }
+
+ src_x = g_src_x + src_xx;
+ src_y = g_src_y + src_yy;
+
+ dst_x = door_rect->x + dst_xx;
+ dst_y = door_rect->y + dst_yy;
+
+ is_panel_and_door_has_closed =
+ (is_panel &&
+ door_closing &&
+ panel_has_doors[door_index] &&
+ k >= num_move_steps_doors_only - 1);
+
+ if (width >= 0 && width <= g->width &&
+ height >= 0 && height <= g->height &&
+ !is_panel_and_door_has_closed)
+ {
+ if (is_panel || !pos->draw_masked)
+ BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ else
+ BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ }
+
+ redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
+
+ if ((part_opening && (width < 0 || height < 0)) ||
+ (part_closing && (width >= g->width && height >= g->height)))
+ door_part_done[nr] = TRUE;
+
+ // continue door part animations, but not panel after door has closed
+ if (!door_part_done[nr] && !is_panel_and_door_has_closed)
+ door_part_done_all = FALSE;
+ }
+
+ if (!(door_state & DOOR_NO_DELAY))
+ {
+ BackToFront();
+
+ if (game_status == GAME_MODE_MAIN)
+ DoAnimation();
+
+ SkipUntilDelayReached(&door_delay, door_delay_value, &k, last_frame);
+
+ current_move_delay += max_step_delay;
+ }
+
+ if (door_part_done_all)
+ break;
+ }
+ }
+
+ if (door_state & DOOR_ACTION_1)
+ door1 = door_state & DOOR_ACTION_1;
+ if (door_state & DOOR_ACTION_2)
+ door2 = door_state & DOOR_ACTION_2;
+
+ return (door1 | door2);
+}
+
+static boolean useSpecialEditorDoor()
+{
+ int graphic = IMG_GLOBAL_BORDER_EDITOR;
+ boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
+
+ // do not draw special editor door if editor border defined or redefined
+ if (graphic_info[graphic].bitmap != NULL || redefined)
+ return FALSE;
+
+ // do not draw special editor door if global border defined to be empty
+ if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
+ return FALSE;
+
+ // do not draw special editor door if viewport definitions do not match
+ if (EX != VX ||
+ EY >= VY ||
+ EXSIZE != VXSIZE ||
+ EY + EYSIZE != VY + VYSIZE)
+ return FALSE;
+
+ return TRUE;
+}
+
+void DrawSpecialEditorDoor()
+{
+ struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+ int top_border_width = gfx1->width;
+ int top_border_height = gfx1->height;
+ int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+ int ex = EX - outer_border;
+ int ey = EY - outer_border;
+ int vy = VY - outer_border;
+ int exsize = EXSIZE + 2 * outer_border;
+
+ if (!useSpecialEditorDoor())
+ return;
+
+ /* draw bigger level editor toolbox window */
+ BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
+ top_border_width, top_border_height, ex, ey - top_border_height);
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
+ exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
+
+ redraw_mask |= REDRAW_ALL;
+}
+
+void UndrawSpecialEditorDoor()
+{
+ struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+ int top_border_width = gfx1->width;
+ int top_border_height = gfx1->height;
+ int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+ int ex = EX - outer_border;
+ int ey = EY - outer_border;
+ int ey_top = ey - top_border_height;
+ int exsize = EXSIZE + 2 * outer_border;
+ int eysize = EYSIZE + 2 * outer_border;
+
+ if (!useSpecialEditorDoor())
+ return;
+
+ /* draw normal tape recorder window */
+ if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
+ {
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ ex, ey_top, top_border_width, top_border_height,
+ ex, ey_top);
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ ex, ey, exsize, eysize, ex, ey);
+ }
+ else
+ {
+ // if screen background is set to "[NONE]", clear editor toolbox window
+ ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
+ ClearRectangle(drawto, ex, ey, exsize, eysize);
+ }
+
+ redraw_mask |= REDRAW_ALL;
+}
+
+
+/* ---------- new tool button stuff ---------------------------------------- */
+
+static struct
+{
+ int graphic;
+ struct TextPosInfo *pos;
+ int gadget_id;
+ char *infotext;
+} toolbutton_info[NUM_TOOL_BUTTONS] =
+{
+ {
+ IMG_REQUEST_BUTTON_GFX_YES, &request.button.yes,
+ TOOL_CTRL_ID_YES, "yes"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_NO, &request.button.no,
+ TOOL_CTRL_ID_NO, "no"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_CONFIRM, &request.button.confirm,
+ TOOL_CTRL_ID_CONFIRM, "confirm"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_1, &request.button.player_1,
+ TOOL_CTRL_ID_PLAYER_1, "player 1"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_2, &request.button.player_2,
+ TOOL_CTRL_ID_PLAYER_2, "player 2"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_3, &request.button.player_3,
+ TOOL_CTRL_ID_PLAYER_3, "player 3"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_4, &request.button.player_4,
+ TOOL_CTRL_ID_PLAYER_4, "player 4"
+ }
+};
+
+void CreateToolButtons()
+{
+ int i;
+
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ {
+ struct GraphicInfo *gfx = &graphic_info[toolbutton_info[i].graphic];
+ struct TextPosInfo *pos = toolbutton_info[i].pos;
+ struct GadgetInfo *gi;
+ Bitmap *deco_bitmap = None;
+ int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
+ unsigned int event_mask = GD_EVENT_RELEASED;
+ int dx = DX;
+ int dy = DY;
+ int gd_x = gfx->src_x;
+ int gd_y = gfx->src_y;
+ int gd_xp = gfx->src_x + gfx->pressed_xoffset;
+ int gd_yp = gfx->src_y + gfx->pressed_yoffset;
+ int id = i;
+
+ if (global.use_envelope_request)
+ setRequestPosition(&dx, &dy, TRUE);
+
+ if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
+ {
+ int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
+
+ getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
+ pos->size, &deco_bitmap, &deco_x, &deco_y);
+ deco_xpos = (gfx->width - pos->size) / 2;
+ deco_ypos = (gfx->height - pos->size) / 2;
+ }
+
+ gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_INFO_TEXT, toolbutton_info[i].infotext,
+ GDI_X, dx + GDI_ACTIVE_POS(pos->x),
+ GDI_Y, dy + GDI_ACTIVE_POS(pos->y),
+ GDI_WIDTH, gfx->width,
+ GDI_HEIGHT, gfx->height,
+ GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
+ GDI_STATE, GD_BUTTON_UNPRESSED,
+ GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
+ GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
+ GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
+ GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
+ GDI_DECORATION_SIZE, pos->size, pos->size,
+ GDI_DECORATION_SHIFTING, 1, 1,
+ GDI_DIRECT_DRAW, FALSE,
+ GDI_EVENT_MASK, event_mask,
+ GDI_CALLBACK_ACTION, HandleToolButtons,
+ GDI_END);
+
+ if (gi == NULL)
+ Error(ERR_EXIT, "cannot create gadget");
+
+ tool_gadget[id] = gi;
+ }
+}
+
+void FreeToolButtons()
+{
+ int i;
+
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ FreeGadget(tool_gadget[i]);
+}
+
+static void UnmapToolButtons()
+{
+ int i;
+
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ UnmapGadget(tool_gadget[i]);
+}
+
+static void HandleToolButtons(struct GadgetInfo *gi)
+{
+ request_gadget_id = gi->custom_id;
+}
+
+static struct Mapping_EM_to_RND_object
+{
+ int element_em;
+ boolean is_rnd_to_em_mapping; /* unique mapping EM <-> RND */
+ boolean is_backside; /* backside of moving element */
+
+ int element_rnd;
+ int action;
+ int direction;
+}
+em_object_mapping_list[] =
+{
+ {
+ Xblank, TRUE, FALSE,
+ EL_EMPTY, -1, -1
+ },
+ {
+ Yacid_splash_eB, FALSE, FALSE,
+ EL_ACID_SPLASH_RIGHT, -1, -1
+ },
+ {
+ Yacid_splash_wB, FALSE, FALSE,
+ EL_ACID_SPLASH_LEFT, -1, -1
+ },
+
+#ifdef EM_ENGINE_BAD_ROLL
+ {
+ Xstone_force_e, FALSE, FALSE,
+ EL_ROCK, -1, MV_BIT_RIGHT
+ },
+ {
+ Xstone_force_w, FALSE, FALSE,
+ EL_ROCK, -1, MV_BIT_LEFT
+ },
+ {
+ Xnut_force_e, FALSE, FALSE,
+ EL_NUT, -1, MV_BIT_RIGHT
+ },
+ {
+ Xnut_force_w, FALSE, FALSE,
+ EL_NUT, -1, MV_BIT_LEFT
+ },
+ {
+ Xspring_force_e, FALSE, FALSE,
+ EL_SPRING, -1, MV_BIT_RIGHT
+ },
+ {
+ Xspring_force_w, FALSE, FALSE,
+ EL_SPRING, -1, MV_BIT_LEFT
+ },
+ {
+ Xemerald_force_e, FALSE, FALSE,
+ EL_EMERALD, -1, MV_BIT_RIGHT
+ },
+ {
+ Xemerald_force_w, FALSE, FALSE,
+ EL_EMERALD, -1, MV_BIT_LEFT
+ },
+ {
+ Xdiamond_force_e, FALSE, FALSE,
+ EL_DIAMOND, -1, MV_BIT_RIGHT
+ },
+ {
+ Xdiamond_force_w, FALSE, FALSE,
+ EL_DIAMOND, -1, MV_BIT_LEFT
+ },
+ {
+ Xbomb_force_e, FALSE, FALSE,
+ EL_BOMB, -1, MV_BIT_RIGHT
+ },
+ {
+ Xbomb_force_w, FALSE, FALSE,
+ EL_BOMB, -1, MV_BIT_LEFT
+ },
+#endif /* EM_ENGINE_BAD_ROLL */
+
+ {
+ Xstone, TRUE, FALSE,
+ EL_ROCK, -1, -1
+ },
+ {
+ Xstone_pause, FALSE, FALSE,
+ EL_ROCK, -1, -1
+ },
+ {
+ Xstone_fall, FALSE, FALSE,
+ EL_ROCK, -1, -1
+ },
+ {
+ Ystone_s, FALSE, FALSE,
+ EL_ROCK, ACTION_FALLING, -1
+ },
+ {
+ Ystone_sB, FALSE, TRUE,
+ EL_ROCK, ACTION_FALLING, -1
+ },
+ {
+ Ystone_e, FALSE, FALSE,
+ EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ystone_eB, FALSE, TRUE,
+ EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ystone_w, FALSE, FALSE,
+ EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ystone_wB, FALSE, TRUE,
+ EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Xnut, TRUE, FALSE,
+ EL_NUT, -1, -1
+ },
+ {
+ Xnut_pause, FALSE, FALSE,
+ EL_NUT, -1, -1
+ },
+ {
+ Xnut_fall, FALSE, FALSE,
+ EL_NUT, -1, -1
+ },
+ {
+ Ynut_s, FALSE, FALSE,
+ EL_NUT, ACTION_FALLING, -1
+ },
+ {
+ Ynut_sB, FALSE, TRUE,
+ EL_NUT, ACTION_FALLING, -1
+ },
+ {
+ Ynut_e, FALSE, FALSE,
+ EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ynut_eB, FALSE, TRUE,
+ EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ynut_w, FALSE, FALSE,
+ EL_NUT, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ynut_wB, FALSE, TRUE,
+ EL_NUT, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Xbug_n, TRUE, FALSE,
+ EL_BUG_UP, -1, -1
+ },
+ {
+ Xbug_e, TRUE, FALSE,
+ EL_BUG_RIGHT, -1, -1
+ },
+ {
+ Xbug_s, TRUE, FALSE,
+ EL_BUG_DOWN, -1, -1
+ },
+ {
+ Xbug_w, TRUE, FALSE,
+ EL_BUG_LEFT, -1, -1
+ },
+ {
+ Xbug_gon, FALSE, FALSE,
+ EL_BUG_UP, -1, -1
+ },
+ {
+ Xbug_goe, FALSE, FALSE,
+ EL_BUG_RIGHT, -1, -1
+ },
+ {
+ Xbug_gos, FALSE, FALSE,
+ EL_BUG_DOWN, -1, -1
+ },
+ {
+ Xbug_gow, FALSE, FALSE,
+ EL_BUG_LEFT, -1, -1
+ },
+ {
+ Ybug_n, FALSE, FALSE,
+ EL_BUG, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Ybug_nB, FALSE, TRUE,
+ EL_BUG, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Ybug_e, FALSE, FALSE,
+ EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ybug_eB, FALSE, TRUE,
+ EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ybug_s, FALSE, FALSE,
+ EL_BUG, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Ybug_sB, FALSE, TRUE,
+ EL_BUG, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Ybug_w, FALSE, FALSE,
+ EL_BUG, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ybug_wB, FALSE, TRUE,
+ EL_BUG, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ybug_w_n, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
+ },
+ {
+ Ybug_n_e, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
+ },
+ {
+ Ybug_e_s, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
+ },
+ {
+ Ybug_s_w, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
+ },
+ {
+ Ybug_e_n, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
+ },
+ {
+ Ybug_s_e, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
+ },
+ {
+ Ybug_w_s, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
+ },
+ {
+ Ybug_n_w, FALSE, FALSE,
+ EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
+ },
+ {
+ Ybug_stone, FALSE, FALSE,
+ EL_BUG, ACTION_SMASHED_BY_ROCK, -1
+ },
+ {
+ Ybug_spring, FALSE, FALSE,
+ EL_BUG, ACTION_SMASHED_BY_SPRING, -1
+ },
+ {
+ Xtank_n, TRUE, FALSE,
+ EL_SPACESHIP_UP, -1, -1
+ },
+ {
+ Xtank_e, TRUE, FALSE,
+ EL_SPACESHIP_RIGHT, -1, -1
+ },
+ {
+ Xtank_s, TRUE, FALSE,
+ EL_SPACESHIP_DOWN, -1, -1
+ },
+ {
+ Xtank_w, TRUE, FALSE,
+ EL_SPACESHIP_LEFT, -1, -1
+ },
+ {
+ Xtank_gon, FALSE, FALSE,
+ EL_SPACESHIP_UP, -1, -1
+ },
+ {
+ Xtank_goe, FALSE, FALSE,
+ EL_SPACESHIP_RIGHT, -1, -1
+ },
+ {
+ Xtank_gos, FALSE, FALSE,
+ EL_SPACESHIP_DOWN, -1, -1
+ },
+ {
+ Xtank_gow, FALSE, FALSE,
+ EL_SPACESHIP_LEFT, -1, -1
+ },
+ {
+ Ytank_n, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Ytank_nB, FALSE, TRUE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Ytank_e, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ytank_eB, FALSE, TRUE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ytank_s, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Ytank_sB, FALSE, TRUE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Ytank_w, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ytank_wB, FALSE, TRUE,
+ EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ytank_w_n, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
+ },
+ {
+ Ytank_n_e, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
+ },
+ {
+ Ytank_e_s, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
+ },
+ {
+ Ytank_s_w, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
+ },
+ {
+ Ytank_e_n, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
+ },
+ {
+ Ytank_s_e, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
+ },
+ {
+ Ytank_w_s, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
+ },
+ {
+ Ytank_n_w, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
+ },
+ {
+ Ytank_stone, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_SMASHED_BY_ROCK, -1
+ },
+ {
+ Ytank_spring, FALSE, FALSE,
+ EL_SPACESHIP, ACTION_SMASHED_BY_SPRING, -1
+ },
+ {
+ Xandroid, TRUE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, -1
+ },
+ {
+ Xandroid_1_n, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
+ },
+ {
+ Xandroid_2_n, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
+ },
+ {
+ Xandroid_1_e, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
+ },
+ {
+ Xandroid_2_e, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
+ },
+ {
+ Xandroid_1_w, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
+ },
+ {
+ Xandroid_2_w, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
+ },
+ {
+ Xandroid_1_s, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
+ },
+ {
+ Xandroid_2_s, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
+ },
+ {
+ Yandroid_n, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yandroid_nB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yandroid_ne, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPRIGHT
+ },
+ {
+ Yandroid_neB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPRIGHT
+ },
+ {
+ Yandroid_e, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yandroid_eB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yandroid_se, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNRIGHT
+ },
+ {
+ Yandroid_seB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNRIGHT
+ },
+ {
+ Yandroid_s, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yandroid_sB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yandroid_sw, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNLEFT
+ },
+ {
+ Yandroid_swB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNLEFT
+ },
+ {
+ Yandroid_w, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yandroid_wB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yandroid_nw, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPLEFT
+ },
+ {
+ Yandroid_nwB, FALSE, TRUE,
+ EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPLEFT
+ },
+ {
+ Xspring, TRUE, FALSE,
+ EL_SPRING, -1, -1
+ },
+ {
+ Xspring_pause, FALSE, FALSE,
+ EL_SPRING, -1, -1
+ },
+ {
+ Xspring_e, FALSE, FALSE,
+ EL_SPRING, -1, -1
+ },
+ {
+ Xspring_w, FALSE, FALSE,
+ EL_SPRING, -1, -1
+ },
+ {
+ Xspring_fall, FALSE, FALSE,
+ EL_SPRING, -1, -1
+ },
+ {
+ Yspring_s, FALSE, FALSE,
+ EL_SPRING, ACTION_FALLING, -1
+ },
+ {
+ Yspring_sB, FALSE, TRUE,
+ EL_SPRING, ACTION_FALLING, -1
+ },
+ {
+ Yspring_e, FALSE, FALSE,
+ EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yspring_eB, FALSE, TRUE,
+ EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yspring_w, FALSE, FALSE,
+ EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yspring_wB, FALSE, TRUE,
+ EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yspring_kill_e, FALSE, FALSE,
+ EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
+ },
+ {
+ Yspring_kill_eB, FALSE, TRUE,
+ EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
+ },
+ {
+ Yspring_kill_w, FALSE, FALSE,
+ EL_SPRING, ACTION_EATING, MV_BIT_LEFT
+ },
+ {
+ Yspring_kill_wB, FALSE, TRUE,
+ EL_SPRING, ACTION_EATING, MV_BIT_LEFT
+ },
+ {
+ Xeater_n, TRUE, FALSE,
+ EL_YAMYAM_UP, -1, -1
+ },
+ {
+ Xeater_e, TRUE, FALSE,
+ EL_YAMYAM_RIGHT, -1, -1
+ },
+ {
+ Xeater_w, TRUE, FALSE,
+ EL_YAMYAM_LEFT, -1, -1
+ },
+ {
+ Xeater_s, TRUE, FALSE,
+ EL_YAMYAM_DOWN, -1, -1
+ },
+ {
+ Yeater_n, FALSE, FALSE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yeater_nB, FALSE, TRUE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yeater_e, FALSE, FALSE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yeater_eB, FALSE, TRUE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yeater_s, FALSE, FALSE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yeater_sB, FALSE, TRUE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yeater_w, FALSE, FALSE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yeater_wB, FALSE, TRUE,
+ EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yeater_stone, FALSE, FALSE,
+ EL_YAMYAM, ACTION_SMASHED_BY_ROCK, -1
+ },
+ {
+ Yeater_spring, FALSE, FALSE,
+ EL_YAMYAM, ACTION_SMASHED_BY_SPRING, -1
+ },
+ {
+ Xalien, TRUE, FALSE,
+ EL_ROBOT, -1, -1
+ },
+ {
+ Xalien_pause, FALSE, FALSE,
+ EL_ROBOT, -1, -1
+ },
+ {
+ Yalien_n, FALSE, FALSE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yalien_nB, FALSE, TRUE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yalien_e, FALSE, FALSE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yalien_eB, FALSE, TRUE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yalien_s, FALSE, FALSE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yalien_sB, FALSE, TRUE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yalien_w, FALSE, FALSE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yalien_wB, FALSE, TRUE,
+ EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yalien_stone, FALSE, FALSE,
+ EL_ROBOT, ACTION_SMASHED_BY_ROCK, -1
+ },
+ {
+ Yalien_spring, FALSE, FALSE,
+ EL_ROBOT, ACTION_SMASHED_BY_SPRING, -1
+ },
+ {
+ Xemerald, TRUE, FALSE,
+ EL_EMERALD, -1, -1
+ },
+ {
+ Xemerald_pause, FALSE, FALSE,
+ EL_EMERALD, -1, -1
+ },
+ {
+ Xemerald_fall, FALSE, FALSE,
+ EL_EMERALD, -1, -1
+ },
+ {
+ Xemerald_shine, FALSE, FALSE,
+ EL_EMERALD, ACTION_TWINKLING, -1
+ },
+ {
+ Yemerald_s, FALSE, FALSE,
+ EL_EMERALD, ACTION_FALLING, -1
+ },
+ {
+ Yemerald_sB, FALSE, TRUE,
+ EL_EMERALD, ACTION_FALLING, -1
+ },
+ {
+ Yemerald_e, FALSE, FALSE,
+ EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yemerald_eB, FALSE, TRUE,
+ EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yemerald_w, FALSE, FALSE,
+ EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yemerald_wB, FALSE, TRUE,
+ EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yemerald_eat, FALSE, FALSE,
+ EL_EMERALD, ACTION_COLLECTING, -1
+ },
+ {
+ Yemerald_stone, FALSE, FALSE,
+ EL_NUT, ACTION_BREAKING, -1
+ },
+ {
+ Xdiamond, TRUE, FALSE,
+ EL_DIAMOND, -1, -1
+ },
+ {
+ Xdiamond_pause, FALSE, FALSE,
+ EL_DIAMOND, -1, -1
+ },
+ {
+ Xdiamond_fall, FALSE, FALSE,
+ EL_DIAMOND, -1, -1
+ },
+ {
+ Xdiamond_shine, FALSE, FALSE,
+ EL_DIAMOND, ACTION_TWINKLING, -1
+ },
+ {
+ Ydiamond_s, FALSE, FALSE,
+ EL_DIAMOND, ACTION_FALLING, -1
+ },
+ {
+ Ydiamond_sB, FALSE, TRUE,
+ EL_DIAMOND, ACTION_FALLING, -1
+ },
+ {
+ Ydiamond_e, FALSE, FALSE,
+ EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ydiamond_eB, FALSE, TRUE,
+ EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ydiamond_w, FALSE, FALSE,
+ EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ydiamond_wB, FALSE, TRUE,
+ EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ydiamond_eat, FALSE, FALSE,
+ EL_DIAMOND, ACTION_COLLECTING, -1
+ },
+ {
+ Ydiamond_stone, FALSE, FALSE,
+ EL_DIAMOND, ACTION_SMASHED_BY_ROCK, -1
+ },
+ {
+ Xdrip_fall, TRUE, FALSE,
+ EL_AMOEBA_DROP, -1, -1
+ },
+ {
+ Xdrip_stretch, FALSE, FALSE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Xdrip_stretchB, FALSE, TRUE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Xdrip_eat, FALSE, FALSE,
+ EL_AMOEBA_DROP, ACTION_GROWING, -1
+ },
+ {
+ Ydrip_s1, FALSE, FALSE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Ydrip_s1B, FALSE, TRUE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Ydrip_s2, FALSE, FALSE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Ydrip_s2B, FALSE, TRUE,
+ EL_AMOEBA_DROP, ACTION_FALLING, -1
+ },
+ {
+ Xbomb, TRUE, FALSE,
+ EL_BOMB, -1, -1
+ },
+ {
+ Xbomb_pause, FALSE, FALSE,
+ EL_BOMB, -1, -1
+ },
+ {
+ Xbomb_fall, FALSE, FALSE,
+ EL_BOMB, -1, -1
+ },
+ {
+ Ybomb_s, FALSE, FALSE,
+ EL_BOMB, ACTION_FALLING, -1
+ },
+ {
+ Ybomb_sB, FALSE, TRUE,
+ EL_BOMB, ACTION_FALLING, -1
+ },
+ {
+ Ybomb_e, FALSE, FALSE,
+ EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ybomb_eB, FALSE, TRUE,
+ EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Ybomb_w, FALSE, FALSE,
+ EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ybomb_wB, FALSE, TRUE,
+ EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Ybomb_eat, FALSE, FALSE,
+ EL_BOMB, ACTION_ACTIVATING, -1
+ },
+ {
+ Xballoon, TRUE, FALSE,
+ EL_BALLOON, -1, -1
+ },
+ {
+ Yballoon_n, FALSE, FALSE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yballoon_nB, FALSE, TRUE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_UP
+ },
+ {
+ Yballoon_e, FALSE, FALSE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yballoon_eB, FALSE, TRUE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
+ },
+ {
+ Yballoon_s, FALSE, FALSE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yballoon_sB, FALSE, TRUE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
+ },
+ {
+ Yballoon_w, FALSE, FALSE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Yballoon_wB, FALSE, TRUE,
+ EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
+ },
+ {
+ Xgrass, TRUE, FALSE,
+ EL_EMC_GRASS, -1, -1
+ },
+ {
+ Ygrass_nB, FALSE, FALSE,
+ EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_UP
+ },
+ {
+ Ygrass_eB, FALSE, FALSE,
+ EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_RIGHT
+ },
+ {
+ Ygrass_sB, FALSE, FALSE,
+ EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_DOWN
+ },
+ {
+ Ygrass_wB, FALSE, FALSE,
+ EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_LEFT
+ },
+ {
+ Xdirt, TRUE, FALSE,
+ EL_SAND, -1, -1
+ },
+ {
+ Ydirt_nB, FALSE, FALSE,
+ EL_SAND, ACTION_DIGGING, MV_BIT_UP
+ },
+ {
+ Ydirt_eB, FALSE, FALSE,
+ EL_SAND, ACTION_DIGGING, MV_BIT_RIGHT
+ },
+ {
+ Ydirt_sB, FALSE, FALSE,
+ EL_SAND, ACTION_DIGGING, MV_BIT_DOWN
+ },
+ {
+ Ydirt_wB, FALSE, FALSE,
+ EL_SAND, ACTION_DIGGING, MV_BIT_LEFT
+ },
+ {
+ Xacid_ne, TRUE, FALSE,
+ EL_ACID_POOL_TOPRIGHT, -1, -1
+ },
+ {
+ Xacid_se, TRUE, FALSE,
+ EL_ACID_POOL_BOTTOMRIGHT, -1, -1
+ },
+ {
+ Xacid_s, TRUE, FALSE,
+ EL_ACID_POOL_BOTTOM, -1, -1
+ },
+ {
+ Xacid_sw, TRUE, FALSE,
+ EL_ACID_POOL_BOTTOMLEFT, -1, -1
+ },
+ {
+ Xacid_nw, TRUE, FALSE,
+ EL_ACID_POOL_TOPLEFT, -1, -1
+ },
+ {
+ Xacid_1, TRUE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_2, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_3, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_4, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_5, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_6, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_7, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xacid_8, FALSE, FALSE,
+ EL_ACID, -1, -1
+ },
+ {
+ Xball_1, TRUE, FALSE,
+ EL_EMC_MAGIC_BALL, -1, -1
+ },
+ {
+ Xball_1B, FALSE, FALSE,
+ EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
+ },
+ {
+ Xball_2, FALSE, FALSE,
+ EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
+ },
+ {
+ Xball_2B, FALSE, FALSE,
+ EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
+ },
+ {
+ Yball_eat, FALSE, FALSE,
+ EL_EMC_MAGIC_BALL, ACTION_DROPPING, -1
+ },
+ {
+ Ykey_1_eat, FALSE, FALSE,
+ EL_EM_KEY_1, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_2_eat, FALSE, FALSE,
+ EL_EM_KEY_2, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_3_eat, FALSE, FALSE,
+ EL_EM_KEY_3, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_4_eat, FALSE, FALSE,
+ EL_EM_KEY_4, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_5_eat, FALSE, FALSE,
+ EL_EMC_KEY_5, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_6_eat, FALSE, FALSE,
+ EL_EMC_KEY_6, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_7_eat, FALSE, FALSE,
+ EL_EMC_KEY_7, ACTION_COLLECTING, -1
+ },
+ {
+ Ykey_8_eat, FALSE, FALSE,
+ EL_EMC_KEY_8, ACTION_COLLECTING, -1
+ },
+ {
+ Ylenses_eat, FALSE, FALSE,
+ EL_EMC_LENSES, ACTION_COLLECTING, -1
+ },
+ {
+ Ymagnify_eat, FALSE, FALSE,
+ EL_EMC_MAGNIFIER, ACTION_COLLECTING, -1
+ },
+ {
+ Ygrass_eat, FALSE, FALSE,
+ EL_EMC_GRASS, ACTION_SNAPPING, -1
+ },
+ {
+ Ydirt_eat, FALSE, FALSE,
+ EL_SAND, ACTION_SNAPPING, -1
+ },
+ {
+ Xgrow_ns, TRUE, FALSE,
+ EL_EXPANDABLE_WALL_VERTICAL, -1, -1
+ },
+ {
+ Ygrow_ns_eat, FALSE, FALSE,
+ EL_EXPANDABLE_WALL_VERTICAL, ACTION_GROWING, -1
+ },
+ {
+ Xgrow_ew, TRUE, FALSE,
+ EL_EXPANDABLE_WALL_HORIZONTAL, -1, -1
+ },
+ {
+ Ygrow_ew_eat, FALSE, FALSE,
+ EL_EXPANDABLE_WALL_HORIZONTAL, ACTION_GROWING, -1
+ },
+ {
+ Xwonderwall, TRUE, FALSE,
+ EL_MAGIC_WALL, -1, -1
+ },
+ {
+ XwonderwallB, FALSE, FALSE,
+ EL_MAGIC_WALL, ACTION_ACTIVE, -1
+ },
+ {
+ Xamoeba_1, TRUE, FALSE,
+ EL_AMOEBA_DRY, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_2, FALSE, FALSE,
+ EL_AMOEBA_DRY, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_3, FALSE, FALSE,
+ EL_AMOEBA_DRY, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_4, FALSE, FALSE,
+ EL_AMOEBA_DRY, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_5, TRUE, FALSE,
+ EL_AMOEBA_WET, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_6, FALSE, FALSE,
+ EL_AMOEBA_WET, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_7, FALSE, FALSE,
+ EL_AMOEBA_WET, ACTION_OTHER, -1
+ },
+ {
+ Xamoeba_8, FALSE, FALSE,
+ EL_AMOEBA_WET, ACTION_OTHER, -1
+ },
+ {
+ Xdoor_1, TRUE, FALSE,
+ EL_EM_GATE_1, -1, -1
+ },
+ {
+ Xdoor_2, TRUE, FALSE,
+ EL_EM_GATE_2, -1, -1
+ },
+ {
+ Xdoor_3, TRUE, FALSE,
+ EL_EM_GATE_3, -1, -1
+ },
+ {
+ Xdoor_4, TRUE, FALSE,
+ EL_EM_GATE_4, -1, -1
+ },
+ {
+ Xdoor_5, TRUE, FALSE,
+ EL_EMC_GATE_5, -1, -1
+ },
+ {
+ Xdoor_6, TRUE, FALSE,
+ EL_EMC_GATE_6, -1, -1
+ },
+ {
+ Xdoor_7, TRUE, FALSE,
+ EL_EMC_GATE_7, -1, -1
+ },
+ {
+ Xdoor_8, TRUE, FALSE,
+ EL_EMC_GATE_8, -1, -1
+ },
+ {
+ Xkey_1, TRUE, FALSE,
+ EL_EM_KEY_1, -1, -1
+ },
+ {
+ Xkey_2, TRUE, FALSE,
+ EL_EM_KEY_2, -1, -1
+ },
+ {
+ Xkey_3, TRUE, FALSE,
+ EL_EM_KEY_3, -1, -1
+ },
+ {
+ Xkey_4, TRUE, FALSE,
+ EL_EM_KEY_4, -1, -1
+ },
+ {
+ Xkey_5, TRUE, FALSE,
+ EL_EMC_KEY_5, -1, -1
+ },
+ {
+ Xkey_6, TRUE, FALSE,
+ EL_EMC_KEY_6, -1, -1
+ },
+ {
+ Xkey_7, TRUE, FALSE,
+ EL_EMC_KEY_7, -1, -1
+ },
+ {
+ Xkey_8, TRUE, FALSE,
+ EL_EMC_KEY_8, -1, -1
+ },
+ {
+ Xwind_n, TRUE, FALSE,
+ EL_BALLOON_SWITCH_UP, -1, -1
+ },
+ {
+ Xwind_e, TRUE, FALSE,
+ EL_BALLOON_SWITCH_RIGHT, -1, -1
+ },
+ {
+ Xwind_s, TRUE, FALSE,
+ EL_BALLOON_SWITCH_DOWN, -1, -1
+ },
+ {
+ Xwind_w, TRUE, FALSE,
+ EL_BALLOON_SWITCH_LEFT, -1, -1
+ },
+ {
+ Xwind_nesw, TRUE, FALSE,
+ EL_BALLOON_SWITCH_ANY, -1, -1
+ },
+ {
+ Xwind_stop, TRUE, FALSE,
+ EL_BALLOON_SWITCH_NONE, -1, -1
+ },
+ {
+ Xexit, TRUE, FALSE,
+ EL_EM_EXIT_CLOSED, -1, -1
+ },
+ {
+ Xexit_1, TRUE, FALSE,
+ EL_EM_EXIT_OPEN, -1, -1
+ },
+ {
+ Xexit_2, FALSE, FALSE,
+ EL_EM_EXIT_OPEN, -1, -1
+ },
+ {
+ Xexit_3, FALSE, FALSE,
+ EL_EM_EXIT_OPEN, -1, -1
+ },
+ {
+ Xdynamite, TRUE, FALSE,
+ EL_EM_DYNAMITE, -1, -1
+ },
+ {
+ Ydynamite_eat, FALSE, FALSE,
+ EL_EM_DYNAMITE, ACTION_COLLECTING, -1
+ },
+ {
+ Xdynamite_1, TRUE, FALSE,
+ EL_EM_DYNAMITE_ACTIVE, -1, -1
+ },
+ {
+ Xdynamite_2, FALSE, FALSE,
+ EL_EM_DYNAMITE_ACTIVE, -1, -1
+ },
+ {
+ Xdynamite_3, FALSE, FALSE,
+ EL_EM_DYNAMITE_ACTIVE, -1, -1
+ },
+ {
+ Xdynamite_4, FALSE, FALSE,
+ EL_EM_DYNAMITE_ACTIVE, -1, -1
+ },
+ {
+ Xbumper, TRUE, FALSE,
+ EL_EMC_SPRING_BUMPER, -1, -1
+ },
+ {
+ XbumperB, FALSE, FALSE,
+ EL_EMC_SPRING_BUMPER, ACTION_ACTIVE, -1
+ },
+ {
+ Xwheel, TRUE, FALSE,
+ EL_ROBOT_WHEEL, -1, -1
+ },
+ {
+ XwheelB, FALSE, FALSE,
+ EL_ROBOT_WHEEL, ACTION_ACTIVE, -1
+ },
+ {
+ Xswitch, TRUE, FALSE,
+ EL_EMC_MAGIC_BALL_SWITCH, -1, -1
+ },
+ {
+ XswitchB, FALSE, FALSE,
+ EL_EMC_MAGIC_BALL_SWITCH, ACTION_ACTIVE, -1
+ },
+ {
+ Xsand, TRUE, FALSE,
+ EL_QUICKSAND_EMPTY, -1, -1
+ },
+ {
+ Xsand_stone, TRUE, FALSE,
+ EL_QUICKSAND_FULL, -1, -1
+ },
+ {
+ Xsand_stonein_1, FALSE, TRUE,
+ EL_ROCK, ACTION_FILLING, -1
+ },
+ {
+ Xsand_stonein_2, FALSE, TRUE,
+ EL_ROCK, ACTION_FILLING, -1
+ },
+ {
+ Xsand_stonein_3, FALSE, TRUE,
+ EL_ROCK, ACTION_FILLING, -1
+ },
+ {
+ Xsand_stonein_4, FALSE, TRUE,
+ EL_ROCK, ACTION_FILLING, -1
+ },
+ {
+ Xsand_stonesand_1, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_2, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_3, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_4, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_quickout_1, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_quickout_2, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stoneout_1, FALSE, FALSE,
+ EL_ROCK, ACTION_EMPTYING, -1
+ },
+ {
+ Xsand_stoneout_2, FALSE, FALSE,
+ EL_ROCK, ACTION_EMPTYING, -1
+ },
+ {
+ Xsand_sandstone_1, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_2, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_3, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_4, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xplant, TRUE, FALSE,
+ EL_EMC_PLANT, -1, -1
+ },
+ {
+ Yplant, FALSE, FALSE,
+ EL_EMC_PLANT, -1, -1
+ },
+ {
+ Xlenses, TRUE, FALSE,
+ EL_EMC_LENSES, -1, -1
+ },
+ {
+ Xmagnify, TRUE, FALSE,
+ EL_EMC_MAGNIFIER, -1, -1
+ },
+ {
+ Xdripper, TRUE, FALSE,
+ EL_EMC_DRIPPER, -1, -1
+ },
+ {
+ XdripperB, FALSE, FALSE,
+ EL_EMC_DRIPPER, ACTION_ACTIVE, -1
+ },
+ {
+ Xfake_blank, TRUE, FALSE,
+ EL_INVISIBLE_WALL, -1, -1
+ },
+ {
+ Xfake_blankB, FALSE, FALSE,
+ EL_INVISIBLE_WALL, ACTION_ACTIVE, -1
+ },
+ {
+ Xfake_grass, TRUE, FALSE,
+ EL_EMC_FAKE_GRASS, -1, -1
+ },
+ {
+ Xfake_grassB, FALSE, FALSE,
+ EL_EMC_FAKE_GRASS, ACTION_ACTIVE, -1
+ },
+ {
+ Xfake_door_1, TRUE, FALSE,
+ EL_EM_GATE_1_GRAY, -1, -1
+ },
+ {
+ Xfake_door_2, TRUE, FALSE,
+ EL_EM_GATE_2_GRAY, -1, -1
+ },
+ {
+ Xfake_door_3, TRUE, FALSE,
+ EL_EM_GATE_3_GRAY, -1, -1
+ },
+ {
+ Xfake_door_4, TRUE, FALSE,
+ EL_EM_GATE_4_GRAY, -1, -1
+ },
+ {
+ Xfake_door_5, TRUE, FALSE,
+ EL_EMC_GATE_5_GRAY, -1, -1
+ },
+ {
+ Xfake_door_6, TRUE, FALSE,
+ EL_EMC_GATE_6_GRAY, -1, -1
+ },
+ {
+ Xfake_door_7, TRUE, FALSE,
+ EL_EMC_GATE_7_GRAY, -1, -1
+ },
+ {
+ Xfake_door_8, TRUE, FALSE,
+ EL_EMC_GATE_8_GRAY, -1, -1
+ },
+ {
+ Xfake_acid_1, TRUE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_2, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_3, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_4, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_5, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_6, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_7, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xfake_acid_8, FALSE, FALSE,
+ EL_EMC_FAKE_ACID, -1, -1
+ },
+ {
+ Xsteel_1, TRUE, FALSE,
+ EL_STEELWALL, -1, -1
+ },
+ {
+ Xsteel_2, TRUE, FALSE,
+ EL_EMC_STEELWALL_2, -1, -1
+ },
+ {
+ Xsteel_3, TRUE, FALSE,
+ EL_EMC_STEELWALL_3, -1, -1
+ },
+ {
+ Xsteel_4, TRUE, FALSE,
+ EL_EMC_STEELWALL_4, -1, -1
+ },
+ {
+ Xwall_1, TRUE, FALSE,
+ EL_WALL, -1, -1
+ },
+ {
+ Xwall_2, TRUE, FALSE,
+ EL_EMC_WALL_14, -1, -1
+ },
+ {
+ Xwall_3, TRUE, FALSE,
+ EL_EMC_WALL_15, -1, -1
+ },
+ {
+ Xwall_4, TRUE, FALSE,
+ EL_EMC_WALL_16, -1, -1
+ },
+ {
+ Xround_wall_1, TRUE, FALSE,
+ EL_WALL_SLIPPERY, -1, -1
+ },
+ {
+ Xround_wall_2, TRUE, FALSE,
+ EL_EMC_WALL_SLIPPERY_2, -1, -1
+ },
+ {
+ Xround_wall_3, TRUE, FALSE,
+ EL_EMC_WALL_SLIPPERY_3, -1, -1
+ },
+ {
+ Xround_wall_4, TRUE, FALSE,
+ EL_EMC_WALL_SLIPPERY_4, -1, -1
+ },
+ {
+ Xdecor_1, TRUE, FALSE,
+ EL_EMC_WALL_8, -1, -1
+ },
+ {
+ Xdecor_2, TRUE, FALSE,
+ EL_EMC_WALL_6, -1, -1
+ },
+ {
+ Xdecor_3, TRUE, FALSE,
+ EL_EMC_WALL_4, -1, -1
+ },
+ {
+ Xdecor_4, TRUE, FALSE,
+ EL_EMC_WALL_7, -1, -1
+ },
+ {
+ Xdecor_5, TRUE, FALSE,
+ EL_EMC_WALL_5, -1, -1
+ },
+ {
+ Xdecor_6, TRUE, FALSE,
+ EL_EMC_WALL_9, -1, -1
+ },
+ {
+ Xdecor_7, TRUE, FALSE,
+ EL_EMC_WALL_10, -1, -1
+ },
+ {
+ Xdecor_8, TRUE, FALSE,
+ EL_EMC_WALL_1, -1, -1
+ },
+ {
+ Xdecor_9, TRUE, FALSE,
+ EL_EMC_WALL_2, -1, -1
+ },
+ {
+ Xdecor_10, TRUE, FALSE,
+ EL_EMC_WALL_3, -1, -1
+ },
+ {
+ Xdecor_11, TRUE, FALSE,
+ EL_EMC_WALL_11, -1, -1
+ },
+ {
+ Xdecor_12, TRUE, FALSE,
+ EL_EMC_WALL_12, -1, -1
+ },
+ {
+ Xalpha_0, TRUE, FALSE,
+ EL_CHAR('0'), -1, -1
+ },
+ {
+ Xalpha_1, TRUE, FALSE,
+ EL_CHAR('1'), -1, -1
+ },
+ {
+ Xalpha_2, TRUE, FALSE,
+ EL_CHAR('2'), -1, -1
+ },
+ {
+ Xalpha_3, TRUE, FALSE,
+ EL_CHAR('3'), -1, -1
+ },
+ {
+ Xalpha_4, TRUE, FALSE,
+ EL_CHAR('4'), -1, -1
+ },
+ {
+ Xalpha_5, TRUE, FALSE,
+ EL_CHAR('5'), -1, -1
+ },
+ {
+ Xalpha_6, TRUE, FALSE,
+ EL_CHAR('6'), -1, -1
+ },
+ {
+ Xalpha_7, TRUE, FALSE,
+ EL_CHAR('7'), -1, -1
+ },
+ {
+ Xalpha_8, TRUE, FALSE,
+ EL_CHAR('8'), -1, -1
+ },
+ {
+ Xalpha_9, TRUE, FALSE,
+ EL_CHAR('9'), -1, -1
+ },
+ {
+ Xalpha_excla, TRUE, FALSE,
+ EL_CHAR('!'), -1, -1
+ },
+ {
+ Xalpha_quote, TRUE, FALSE,
+ EL_CHAR('"'), -1, -1
+ },
+ {
+ Xalpha_comma, TRUE, FALSE,
+ EL_CHAR(','), -1, -1
+ },
+ {
+ Xalpha_minus, TRUE, FALSE,
+ EL_CHAR('-'), -1, -1
+ },
+ {
+ Xalpha_perio, TRUE, FALSE,
+ EL_CHAR('.'), -1, -1
+ },
+ {
+ Xalpha_colon, TRUE, FALSE,
+ EL_CHAR(':'), -1, -1
+ },
+ {
+ Xalpha_quest, TRUE, FALSE,
+ EL_CHAR('?'), -1, -1
+ },
+ {
+ Xalpha_a, TRUE, FALSE,
+ EL_CHAR('A'), -1, -1
+ },
+ {
+ Xalpha_b, TRUE, FALSE,
+ EL_CHAR('B'), -1, -1
+ },
+ {
+ Xalpha_c, TRUE, FALSE,
+ EL_CHAR('C'), -1, -1
+ },
+ {
+ Xalpha_d, TRUE, FALSE,
+ EL_CHAR('D'), -1, -1
+ },
+ {
+ Xalpha_e, TRUE, FALSE,
+ EL_CHAR('E'), -1, -1
+ },
+ {
+ Xalpha_f, TRUE, FALSE,
+ EL_CHAR('F'), -1, -1
+ },
+ {
+ Xalpha_g, TRUE, FALSE,
+ EL_CHAR('G'), -1, -1
+ },
+ {
+ Xalpha_h, TRUE, FALSE,
+ EL_CHAR('H'), -1, -1
+ },
+ {
+ Xalpha_i, TRUE, FALSE,
+ EL_CHAR('I'), -1, -1
+ },
+ {
+ Xalpha_j, TRUE, FALSE,
+ EL_CHAR('J'), -1, -1
+ },
+ {
+ Xalpha_k, TRUE, FALSE,
+ EL_CHAR('K'), -1, -1
+ },
+ {
+ Xalpha_l, TRUE, FALSE,
+ EL_CHAR('L'), -1, -1
+ },
+ {
+ Xalpha_m, TRUE, FALSE,
+ EL_CHAR('M'), -1, -1
+ },
+ {
+ Xalpha_n, TRUE, FALSE,
+ EL_CHAR('N'), -1, -1
+ },
+ {
+ Xalpha_o, TRUE, FALSE,
+ EL_CHAR('O'), -1, -1
+ },
+ {
+ Xalpha_p, TRUE, FALSE,
+ EL_CHAR('P'), -1, -1
+ },
+ {
+ Xalpha_q, TRUE, FALSE,
+ EL_CHAR('Q'), -1, -1
+ },
+ {
+ Xalpha_r, TRUE, FALSE,
+ EL_CHAR('R'), -1, -1
+ },
+ {
+ Xalpha_s, TRUE, FALSE,
+ EL_CHAR('S'), -1, -1
+ },
+ {
+ Xalpha_t, TRUE, FALSE,
+ EL_CHAR('T'), -1, -1
+ },
+ {
+ Xalpha_u, TRUE, FALSE,
+ EL_CHAR('U'), -1, -1
+ },
+ {
+ Xalpha_v, TRUE, FALSE,
+ EL_CHAR('V'), -1, -1
+ },
+ {
+ Xalpha_w, TRUE, FALSE,
+ EL_CHAR('W'), -1, -1
+ },
+ {
+ Xalpha_x, TRUE, FALSE,
+ EL_CHAR('X'), -1, -1
+ },
+ {
+ Xalpha_y, TRUE, FALSE,
+ EL_CHAR('Y'), -1, -1
+ },
+ {
+ Xalpha_z, TRUE, FALSE,
+ EL_CHAR('Z'), -1, -1
+ },
+ {
+ Xalpha_arrow_e, TRUE, FALSE,
+ EL_CHAR('>'), -1, -1
+ },
+ {
+ Xalpha_arrow_w, TRUE, FALSE,
+ EL_CHAR('<'), -1, -1
+ },
+ {
+ Xalpha_copyr, TRUE, FALSE,
+ EL_CHAR(CHAR_BYTE_COPYRIGHT), -1, -1
+ },
+
+ {
+ Xboom_bug, FALSE, FALSE,
+ EL_BUG, ACTION_EXPLODING, -1
+ },
+ {
+ Xboom_bomb, FALSE, FALSE,
+ EL_BOMB, ACTION_EXPLODING, -1
+ },
+ {
+ Xboom_android, FALSE, FALSE,
+ EL_EMC_ANDROID, ACTION_OTHER, -1
+ },
+ {
+ Xboom_1, FALSE, FALSE,
+ EL_DEFAULT, ACTION_EXPLODING, -1
+ },
+ {
+ Xboom_2, FALSE, FALSE,
+ EL_DEFAULT, ACTION_EXPLODING, -1
+ },
+ {
+ Znormal, FALSE, FALSE,
+ EL_EMPTY, -1, -1
+ },
+ {
+ Zdynamite, FALSE, FALSE,
+ EL_EMPTY, -1, -1
+ },
+ {
+ Zplayer, FALSE, FALSE,
+ EL_EMPTY, -1, -1
+ },
+ {
+ ZBORDER, FALSE, FALSE,
+ EL_EMPTY, -1, -1
+ },
+
+ {
+ -1, FALSE, FALSE,
+ -1, -1, -1
+ }
+};
+
+static struct Mapping_EM_to_RND_player
+{
+ int action_em;
+ int player_nr;
+
+ int element_rnd;
+ int action;
+ int direction;
+}
+em_player_mapping_list[] =
+{
+ {
+ SPR_walk + 0, 0,
+ EL_PLAYER_1, ACTION_MOVING, MV_BIT_UP,
+ },
+ {
+ SPR_walk + 1, 0,
+ EL_PLAYER_1, ACTION_MOVING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_walk + 2, 0,
+ EL_PLAYER_1, ACTION_MOVING, MV_BIT_DOWN,
+ },
+ {
+ SPR_walk + 3, 0,
+ EL_PLAYER_1, ACTION_MOVING, MV_BIT_LEFT,
+ },
+ {
+ SPR_push + 0, 0,
+ EL_PLAYER_1, ACTION_PUSHING, MV_BIT_UP,
+ },
+ {
+ SPR_push + 1, 0,
+ EL_PLAYER_1, ACTION_PUSHING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_push + 2, 0,
+ EL_PLAYER_1, ACTION_PUSHING, MV_BIT_DOWN,
+ },
+ {
+ SPR_push + 3, 0,
+ EL_PLAYER_1, ACTION_PUSHING, MV_BIT_LEFT,
+ },
+ {
+ SPR_spray + 0, 0,
+ EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_UP,
+ },
+ {
+ SPR_spray + 1, 0,
+ EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_spray + 2, 0,
+ EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_DOWN,
+ },
+ {
+ SPR_spray + 3, 0,
+ EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_LEFT,
+ },
+ {
+ SPR_walk + 0, 1,
+ EL_PLAYER_2, ACTION_MOVING, MV_BIT_UP,
+ },
+ {
+ SPR_walk + 1, 1,
+ EL_PLAYER_2, ACTION_MOVING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_walk + 2, 1,
+ EL_PLAYER_2, ACTION_MOVING, MV_BIT_DOWN,
+ },
+ {
+ SPR_walk + 3, 1,
+ EL_PLAYER_2, ACTION_MOVING, MV_BIT_LEFT,
+ },
+ {
+ SPR_push + 0, 1,
+ EL_PLAYER_2, ACTION_PUSHING, MV_BIT_UP,
+ },
+ {
+ SPR_push + 1, 1,
+ EL_PLAYER_2, ACTION_PUSHING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_push + 2, 1,
+ EL_PLAYER_2, ACTION_PUSHING, MV_BIT_DOWN,
+ },
+ {
+ SPR_push + 3, 1,
+ EL_PLAYER_2, ACTION_PUSHING, MV_BIT_LEFT,
+ },
+ {
+ SPR_spray + 0, 1,
+ EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_UP,
+ },
+ {
+ SPR_spray + 1, 1,
+ EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_spray + 2, 1,
+ EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_DOWN,
+ },
+ {
+ SPR_spray + 3, 1,
+ EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_LEFT,
+ },
+ {
+ SPR_still, 0,
+ EL_PLAYER_1, ACTION_DEFAULT, -1,
+ },
+ {
+ SPR_still, 1,
+ EL_PLAYER_2, ACTION_DEFAULT, -1,
+ },
+ {
+ SPR_walk + 0, 2,
+ EL_PLAYER_3, ACTION_MOVING, MV_BIT_UP,
+ },
+ {
+ SPR_walk + 1, 2,
+ EL_PLAYER_3, ACTION_MOVING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_walk + 2, 2,
+ EL_PLAYER_3, ACTION_MOVING, MV_BIT_DOWN,
+ },
+ {
+ SPR_walk + 3, 2,
+ EL_PLAYER_3, ACTION_MOVING, MV_BIT_LEFT,
+ },
+ {
+ SPR_push + 0, 2,
+ EL_PLAYER_3, ACTION_PUSHING, MV_BIT_UP,
+ },
+ {
+ SPR_push + 1, 2,
+ EL_PLAYER_3, ACTION_PUSHING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_push + 2, 2,
+ EL_PLAYER_3, ACTION_PUSHING, MV_BIT_DOWN,
+ },
+ {
+ SPR_push + 3, 2,
+ EL_PLAYER_3, ACTION_PUSHING, MV_BIT_LEFT,
+ },
+ {
+ SPR_spray + 0, 2,
+ EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_UP,
+ },
+ {
+ SPR_spray + 1, 2,
+ EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_spray + 2, 2,
+ EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_DOWN,
+ },
+ {
+ SPR_spray + 3, 2,
+ EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_LEFT,
+ },
+ {
+ SPR_walk + 0, 3,
+ EL_PLAYER_4, ACTION_MOVING, MV_BIT_UP,
+ },
+ {
+ SPR_walk + 1, 3,
+ EL_PLAYER_4, ACTION_MOVING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_walk + 2, 3,
+ EL_PLAYER_4, ACTION_MOVING, MV_BIT_DOWN,
+ },
+ {
+ SPR_walk + 3, 3,
+ EL_PLAYER_4, ACTION_MOVING, MV_BIT_LEFT,
+ },
+ {
+ SPR_push + 0, 3,
+ EL_PLAYER_4, ACTION_PUSHING, MV_BIT_UP,
+ },
+ {
+ SPR_push + 1, 3,
+ EL_PLAYER_4, ACTION_PUSHING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_push + 2, 3,
+ EL_PLAYER_4, ACTION_PUSHING, MV_BIT_DOWN,
+ },
+ {
+ SPR_push + 3, 3,
+ EL_PLAYER_4, ACTION_PUSHING, MV_BIT_LEFT,
+ },
+ {
+ SPR_spray + 0, 3,
+ EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_UP,
+ },
+ {
+ SPR_spray + 1, 3,
+ EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_RIGHT,
+ },
+ {
+ SPR_spray + 2, 3,
+ EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_DOWN,
+ },
+ {
+ SPR_spray + 3, 3,
+ EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_LEFT,
+ },
+ {
+ SPR_still, 2,
+ EL_PLAYER_3, ACTION_DEFAULT, -1,
+ },
+ {
+ SPR_still, 3,
+ EL_PLAYER_4, ACTION_DEFAULT, -1,
+ },
+
+ {
+ -1, -1,
+ -1, -1, -1
+ }
+};
+
+int map_element_RND_to_EM(int element_rnd)
+{
+ static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
+ static boolean mapping_initialized = FALSE;
+
+ if (!mapping_initialized)
+ {
+ int i;
+
+ /* return "Xalpha_quest" for all undefined elements in mapping array */
+ for (i = 0; i < NUM_FILE_ELEMENTS; i++)
+ mapping_RND_to_EM[i] = Xalpha_quest;
+
+ for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
+ if (em_object_mapping_list[i].is_rnd_to_em_mapping)
+ mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
+ em_object_mapping_list[i].element_em;
+
+ mapping_initialized = TRUE;
+ }
+
+ if (element_rnd >= 0 && element_rnd < NUM_FILE_ELEMENTS)
+ return mapping_RND_to_EM[element_rnd];
+
+ Error(ERR_WARN, "invalid RND level element %d", element_rnd);
+
+ return EL_UNKNOWN;
+}
+
+int map_element_EM_to_RND(int element_em)
+{
+ static unsigned short mapping_EM_to_RND[TILE_MAX];
+ static boolean mapping_initialized = FALSE;
+
+ if (!mapping_initialized)
+ {
+ int i;
+
+ /* return "EL_UNKNOWN" for all undefined elements in mapping array */
+ for (i = 0; i < TILE_MAX; i++)
+ mapping_EM_to_RND[i] = EL_UNKNOWN;
+
+ for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
+ mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
+ em_object_mapping_list[i].element_rnd;
+
+ mapping_initialized = TRUE;
+ }
+
+ if (element_em >= 0 && element_em < TILE_MAX)
+ return mapping_EM_to_RND[element_em];
+
+ Error(ERR_WARN, "invalid EM level element %d", element_em);
+
+ 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 < TILE_MAX; i++)
+ lev->android_array[i] = Xblank;
+
+ 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;
+ }
+}
+
+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 map_element_RND_to_SP(int element_rnd)
+{
+ int element_sp = 0x20; /* map unknown elements to yellow "hardware" */
+
+ if (element_rnd >= EL_SP_START &&
+ element_rnd <= EL_SP_END)
+ element_sp = element_rnd - EL_SP_START;
+ else if (element_rnd == EL_EMPTY_SPACE)
+ element_sp = 0x00;
+ else if (element_rnd == EL_INVISIBLE_WALL)
+ element_sp = 0x28;
+
+ return element_sp;
+}
+
+int map_element_SP_to_RND(int element_sp)
+{
+ int element_rnd = EL_UNKNOWN;
+
+ if (element_sp >= 0x00 &&
+ element_sp <= 0x27)
+ element_rnd = EL_SP_START + element_sp;
+ else if (element_sp == 0x28)
+ element_rnd = EL_INVISIBLE_WALL;
+
+ return element_rnd;
+}
+
+int map_action_SP_to_RND(int action_sp)
+{
+ switch (action_sp)
+ {
+ case actActive: return ACTION_ACTIVE;
+ case actImpact: return ACTION_IMPACT;
+ case actExploding: return ACTION_EXPLODING;
+ case actDigging: return ACTION_DIGGING;
+ case actSnapping: return ACTION_SNAPPING;
+ case actCollecting: return ACTION_COLLECTING;
+ case actPassing: return ACTION_PASSING;
+ case actPushing: return ACTION_PUSHING;
+ case actDropping: return ACTION_DROPPING;
+
+ default: return ACTION_DEFAULT;
+ }
+}
+
+int get_next_element(int element)
+{
+ switch (element)
+ {
+ case EL_QUICKSAND_FILLING: return EL_QUICKSAND_FULL;
+ case EL_QUICKSAND_EMPTYING: return EL_QUICKSAND_EMPTY;
+ case EL_QUICKSAND_FAST_FILLING: return EL_QUICKSAND_FAST_FULL;
+ case EL_QUICKSAND_FAST_EMPTYING: return EL_QUICKSAND_FAST_EMPTY;
+ case EL_MAGIC_WALL_FILLING: return EL_MAGIC_WALL_FULL;
+ case EL_MAGIC_WALL_EMPTYING: return EL_MAGIC_WALL_ACTIVE;
+ case EL_BD_MAGIC_WALL_FILLING: return EL_BD_MAGIC_WALL_FULL;
+ case EL_BD_MAGIC_WALL_EMPTYING: return EL_BD_MAGIC_WALL_ACTIVE;
+ case EL_DC_MAGIC_WALL_FILLING: return EL_DC_MAGIC_WALL_FULL;
+ case EL_DC_MAGIC_WALL_EMPTYING: return EL_DC_MAGIC_WALL_ACTIVE;
+ case EL_AMOEBA_DROPPING: return EL_AMOEBA_WET;
+
+ default: return element;
+ }
+}
+
+int el_act_dir2img(int element, int action, int direction)
+{
+ element = GFX_ELEMENT(element);
+ direction = MV_DIR_TO_BIT(direction); /* default: MV_NONE => MV_DOWN */
+
+ /* direction_graphic[][] == graphic[] for undefined direction graphics */
+ return element_info[element].direction_graphic[action][direction];
+}
+
+static int el_act_dir2crm(int element, int action, int direction)
+{
+ element = GFX_ELEMENT(element);
+ direction = MV_DIR_TO_BIT(direction); /* default: MV_NONE => MV_DOWN */
+
+ /* direction_graphic[][] == graphic[] for undefined direction graphics */
+ return element_info[element].direction_crumbled[action][direction];
+}
+
+int el_act2img(int element, int action)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].graphic[action];
+}
+
+int el_act2crm(int element, int action)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].crumbled[action];
+}
+
+int el_dir2img(int element, int direction)
+{
+ element = GFX_ELEMENT(element);
+
+ return el_act_dir2img(element, ACTION_DEFAULT, direction);
+}
+
+int el2baseimg(int element)
+{
+ return element_info[element].graphic[ACTION_DEFAULT];
+}
+
+int el2img(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].graphic[ACTION_DEFAULT];
+}
+
+int el2edimg(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
+}
+
+int el2preimg(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
+}
+
+int el2panelimg(int element)
+{
+ element = GFX_ELEMENT(element);
+
+ return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
+}
+
+int font2baseimg(int font_nr)
+{
+ return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
+}
+
+int getBeltNrFromBeltElement(int element)
+{
+ return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
+ element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
+ element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
+}
+
+int getBeltNrFromBeltActiveElement(int element)
+{
+ return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
+ element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
+ element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
+}
+
+int getBeltNrFromBeltSwitchElement(int element)
+{
+ return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
+ element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
+ element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
+}
+
+int getBeltDirNrFromBeltElement(int element)
+{
+ static int belt_base_element[4] =
+ {
+ EL_CONVEYOR_BELT_1_LEFT,
+ EL_CONVEYOR_BELT_2_LEFT,
+ EL_CONVEYOR_BELT_3_LEFT,
+ EL_CONVEYOR_BELT_4_LEFT
+ };
+
+ int belt_nr = getBeltNrFromBeltElement(element);
+ int belt_dir_nr = element - belt_base_element[belt_nr];
+
+ return (belt_dir_nr % 3);
+}
+
+int getBeltDirNrFromBeltSwitchElement(int element)
+{
+ static int belt_base_element[4] =
+ {
+ EL_CONVEYOR_BELT_1_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_2_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_3_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_4_SWITCH_LEFT
+ };
+
+ int belt_nr = getBeltNrFromBeltSwitchElement(element);
+ int belt_dir_nr = element - belt_base_element[belt_nr];
+
+ return (belt_dir_nr % 3);
+}
+
+int getBeltDirFromBeltElement(int element)
+{
+ static int belt_move_dir[3] =
+ {
+ MV_LEFT,
+ MV_NONE,
+ MV_RIGHT
+ };
+
+ int belt_dir_nr = getBeltDirNrFromBeltElement(element);
+
+ return belt_move_dir[belt_dir_nr];
+}
+
+int getBeltDirFromBeltSwitchElement(int element)
+{
+ static int belt_move_dir[3] =
+ {
+ MV_LEFT,
+ MV_NONE,
+ MV_RIGHT
+ };
+
+ int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
+
+ return belt_move_dir[belt_dir_nr];
+}
+
+int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
+{
+ static int belt_base_element[4] =
+ {
+ EL_CONVEYOR_BELT_1_LEFT,
+ EL_CONVEYOR_BELT_2_LEFT,
+ EL_CONVEYOR_BELT_3_LEFT,
+ EL_CONVEYOR_BELT_4_LEFT
+ };
+
+ return belt_base_element[belt_nr] + belt_dir_nr;
+}
+
+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_1_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_2_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_3_SWITCH_LEFT,
+ EL_CONVEYOR_BELT_4_SWITCH_LEFT
+ };
+
+ 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);
+}
+
+boolean getTeamMode_EM()
+{
+ return game.team_mode;
+}
+
+int getGameFrameDelay_EM(int native_em_game_frame_delay)
+{
+ int game_frame_delay_value;
+
+ game_frame_delay_value =
+ (tape.playing && tape.fast_forward ? FfwdFrameDelay :
+ GameFrameDelay == GAME_FRAME_DELAY ? native_em_game_frame_delay :
+ GameFrameDelay);
+
+ if (tape.playing && tape.warp_forward && !tape.pausing)
+ game_frame_delay_value = 0;
+
+ return game_frame_delay_value;
+}
+
+unsigned int InitRND(int seed)
+{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ return InitEngineRandom_EM(seed);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ return InitEngineRandom_SP(seed);
+ else
+ return InitEngineRandom_RND(seed);
+}
+
+static struct Mapping_EM_to_RND_object object_mapping[TILE_MAX];
+static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][SPR_MAX];
+
+inline static int get_effective_element_EM(int tile, int frame_em)
+{
+ int element = object_mapping[tile].element_rnd;
+ int action = object_mapping[tile].action;
+ boolean is_backside = object_mapping[tile].is_backside;
+ boolean action_removing = (action == ACTION_DIGGING ||
+ action == ACTION_SNAPPING ||
+ action == ACTION_COLLECTING);
+
+ if (frame_em < 7)
+ {
+ switch (tile)
+ {
+ case Yacid_splash_eB:
+ case Yacid_splash_wB:
+ return (frame_em > 5 ? EL_EMPTY : element);
+
+ default:
+ return element;
+ }
+ }
+ else /* frame_em == 7 */
+ {
+ switch (tile)
+ {
+ case Yacid_splash_eB:
+ case Yacid_splash_wB:
+ return EL_EMPTY;
+
+ case Yemerald_stone:
+ return EL_EMERALD;
+
+ case Ydiamond_stone:
+ return EL_ROCK;
+
+ case Xdrip_stretch:
+ case Xdrip_stretchB:
+ case Ydrip_s1:
+ case Ydrip_s1B:
+ case Xball_1B:
+ case Xball_2:
+ case Xball_2B:
+ case Yball_eat:
+ case Ykey_1_eat:
+ case Ykey_2_eat:
+ case Ykey_3_eat:
+ case Ykey_4_eat:
+ case Ykey_5_eat:
+ case Ykey_6_eat:
+ case Ykey_7_eat:
+ case Ykey_8_eat:
+ case Ylenses_eat:
+ case Ymagnify_eat:
+ case Ygrass_eat:
+ case Ydirt_eat:
+ case Xsand_stonein_1:
+ case Xsand_stonein_2:
+ case Xsand_stonein_3:
+ case Xsand_stonein_4:
+ return element;